C++ Training: Using Modern C++ Safely and Effectively

Who this training is for

Engineers using C++ productively while largely working to a standard set years ago. The typical picture is a grown codebase with manual memory management, raw pointers and comments explaining who is responsible for what – things that more modern C++ expresses in the type system rather than in prose.

Equally for teams who have already raised the standard but use the new features only sporadically, because it is unclear what they cost.

Contents

Day 1 – Resources and ownership. RAII as a founding principle, not a matter of style. Move semantics: what actually happens, when the compiler applies them, and why a badly written constructor quietly prevents them. Smart pointers and the question behind them: who owns this object, and for how long. We rework example code together and turn ownership from comments into types.

Day 2 – Abstraction without runtime cost. Templates beyond containers, constexpr and what can be settled at compile time. Concepts as readable requirements on template parameters – the point where error messages become comprehensible again. Ranges and algorithms in place of hand-written loops. Throughout, with attention to what ends up in the generated code.

Day 3 – Robustness in daily work. Error handling: exceptions, return types and the trade-off behind them, particularly where exceptions are disabled in the project. Concurrency: threads, locks, atomics and the usual traps. Tools that find bugs before the customer does – sanitizers, static analysis, unit tests as part of design.

What your team can do afterwards

Express ownership in the type system rather than in comments. Judge whether an abstraction costs anything at runtime – and measure it when in doubt. Write templates whose error messages stay readable. And in an existing codebase, decide on solid grounds which modernization pays off and which is merely motion.

Prerequisites

Practical C++ experience. Familiarity with classes, inheritance and templates at usage level. Knowledge of the newer standards is not required – that is the point.

Format and delivery

Three days, on site or remote. The hands-on share is high: we rework prepared code together rather than demonstrating language features in isolation.

For teams with an embedded focus we go deeper on code size, allocation and real-time behaviour – the background is in our article on modern C++ for embedded systems.