C++ Advanced Training: Extended Knowledge for C++ Developers

In view of the increase in software complexity, many applications benefit from advanced C++ constructs; additional support is provided by modifications and extensions of the current C++ standard.

Goals -
Your benefits

You will acquire advanced knowledge of classic object-oriented programming with C++, the use of templates, and the standard library. You will also get an overview of exceptions, metaprogramming and multithreading. You will be able to make an informed choice from alternative approaches based on runtime performance and resource consumption.

Participant

The C++ advanced training addresses programmers, software developers, software designers and software

Requirements

Solid knowledge of C++ basics as covered in our training "C++: Object-Oriented Programming"

Contents

• Recap of C++ basics (only if required)

• Encapsulation and access protection
• Association, aggregation and inheritance
• Liskov's substitution principle (LSP)
• Late binding, abstract base classes
• “Non virtual interface” idiom (NVI)
• Interfaces and their implementation
• Specifics of multiple inheritance

• Types as template parameters
• Values as template parameters
• Variations of the open-close principle
• “Curiously recurring template” (CRTP) idiom
• Problems with error cascades in practical application

• Basic principle (short recap if required)
• Best practice for the use of “throw” and “catch”
• Standard exceptions as a base class
• Exceptions and “std::terminate”
• When to use “noexcept”
• “std::move” and ”std::move_if_noexcept”

• Advantages and disadvantages of static typing
• Type-dependent selection of operations
• Keyword-based cast syntax
• Static and dynamic conversions
• Compile time type vs. runtime type and RTTI
• Type customization through constructor
• Type customization through “type cast” function
• Type-safe operator overloads

• Functions in C and C++
• Arguments and return values (in part by recap)
• Function pointers and member function pointers
• Callable objects (aka. functors)
• Lambda functions and “capture” lists
• “Type erasure” using ”std::function”
• Replace “std::bind” with Lambda
• Realization of callbacks via interfaces

• Pointer vs. references (short recap if required)
• Direct use of “new” and “delete”
• “std::unique_ptr” (exclusive ownership)
• “std::shared_ptr” (shared ownership)
• “std::shared_from_this” (extend ownership)
• “std::weak_ptr” (non-owning)
• Custom deleter for “std::unique_ptr”
• Custom deleter for “std::shared_ptr”
• Type conversions between smart pointers

• Brief recap of STL design (only if required)
• Flexibility by separating containers and iterators
• Algorithm overview (C++98, C++11, C++14, ...)
• “std::tuple” and “Structured Binding”
• “std::optional”, ‘std::any’, ”std::variant”

• Runtime code vs. compile time code
• “constexpr”, “consteval” and “constinit”
• Templates as compile-time functions
• Standard type-trait templates
• Type-trait based argument types
• Type-trait based overloading
• C++20 concepts

• Short introduction to threads (only if required request)
• Asynchronous function calls
• Exception handling across threads
• Basic building blocks “promise” and “future”
• Thread pools with “packaged task”
• Synchronization by using mutex
• Deadlocks and race conditions
• Safe unlocking of mutex (RAII idiom)

• Extended behavior guarantees
• Atomic setting and testing
• Use of lock-free algorithms
• Race conditions for smart pointers
• Automatically synchronized streams

• Due to the extensive scope of the C++ language and the associated standard library, not all topics can be covered in equal detail in one dedicated training course. However, all topics will be addressed at least once. Those topics, which are of specific interest for the attendees, will be covered in more detail.

• A practical exercise that is extended step by step completes the training course and will account for about 50 % of the training scope, in continuous blocks of 90 to 120 minutes.
• A sample solution is provided in advance for each step so that the individual subtasks can either be programmed independently or executed as a “side-by-side” review of the differences, while the remaining supervised lab time can be used to deepen your knowledge of C++ topics as required.

• All code examples covered in the training are available online in compilable format for in-depth study. For face-to-face trainings, MicroConsult provides the attendees with PCs in the classrooms. For online trainings and onsite courses, there is remote access to the training environment available. You are also welcome to use your own laptop with your familiar development environment (at least C++20).

Appointments

September 14, 2026 - September 17, 2026 | Price: €2,600.00 | Duration: 4 days

February 1st - February 4th, 2027 | Price: €2,600.00 | Duration: 4 days

Registration code:

E-C++/FOR