C++ – Practical Programming for Advanced Developers (CPP2)

Programming, C, C++

Modern C++ has evolved far from its 1980s roots, driven by demands for extreme performance, low latency and functional safety. The language now offers industrial features that make C++ easier to use in high-reliability environments.

Recent standards help eliminate dynamic allocation and avoid sources of unexpected latency, enabling safer, more readable and higher-performance code. The course is updated for C++20, C++23 and C++26 and can be tailored to other versions.

Location, current course term

Contact us

Custom

Customized Training (date, location, content, duration)

The course:

Hide detail

• Capabilities of the C++ language
1. Modern C++ up to C++26
2. How C++ differs from other languages
3. Present and future of C++ in embedded systems

• Object storage in memory
1. Stack and heap allocation
2. Bulk memory allocation and containers
3. Initialization of allocated objects

• Object initialization order
1. Two-phase initialization for globals
2. Initialization of class instance parts
3. Local initialization and static variables

• Working with raw pointers
1. Pointer arithmetic
2. Ownership and borrowing
3. Advanced memory allocation

• Smart pointers
1. Allocating objects via smart pointers
2. Shared pointers and weak references
3. References and reference wrappers

• Iterators, ranges and views
1. From pointers to iterators
2. Library support for ranges
3. Practical chaining of views

• Moving and copying objects
1. Copying, move and forwarding
2. Constructors and assignment operators
3. Return value optimization (RVO)

• Inheritance and polymorphism
1. Virtual and abstract methods
2. Mandatory virtual destructors
3. Multiple and virtual inheritance

• Polymorphic variables and dependencies
1. Polymorphic references (borrowing)
2. Polymorphic smart pointers
3. Use of std::enable_shared_from_this and CRTP

• Polymorphism without virtual methods
1. Does not require dynamic allocation
2. Variant types and the visitor pattern
3. Lambdas and the overload pattern

• Modularity
1. Header files and #pragma once
2. Namespaces and using declarations
3. Support for modules in C++ (C++20, C++23)

• Working with bits and bytes
1. Fixed-width numeric types
2. Endianness and byte order (C++20, C++23)
3. Bit registers and bitmaps

• Error handling and debugging
1. User and programmer errors
2. The exception handling system
3. Debugging with a debugger

• Building correct programs
1. Undefined behavior
2. Using sanitizers during debugging
3. Static analyzers

Assumed knowledge:

Experience with C++ programming.

Recommended previous course:

C++ – Fundamentals of Modern C++ Programming (CPP1)

Recommended subsequent course:

C++ – Metaprogramming and High-Performance Applications (CPP5)

Schedule:

3 days (9:00 AM - 5:00 PM )

Language: