C++ Training¶

Success factors context

History of the language

Modern features

Uniform initialization syntax and automatic type deduction

Defaulted, delegated, and deleted special member functions

Move semantics, rvalue references, and value categories

Convenient syntax: lambda functions and range-based for-loops

Type-safety: typed-nullptr, typed-enums, and variadic templates

Compile-time features: “constexpr” keyword and static_assert

STL features: multi-threading, smart pointers, chrono, regex

Characterizing “has a” and “is a” relationships

Inheritance, “virtual” keyword, and vtable implementation

Special member functions and the rule of 3/5/0

Constructors and member initializer lists

Base and derived class construction and destruction

Access modifiers – public, protected, and private

Exceptions: “try/catch”, “throw”, “noexcept”, std::exception hierarchy

RAII – Resource Acquisition Is Initialization

Error codes – benefits and drawbacks

Swap operation, “friend” keyword, and copy-and-swap idiom

Exceptions thrown from constructors and destructors

Commonly overloaded operators

Operator overloading best practices

Prefix vs. postfix increment operators

Member functions vs non-member functions

Type conversions and the “explicit” keyword

Exception-safety levels, guarantees, and neutrality

Member initialization order

Allocations, copies, and exceptions

Delegating constructors

Move-and-swap idiom

Value Categories – lvalue, rvalue, prvalue, xvalue, glvalue

Value categories and argument passing overloads

Move semantics, copies, and copy elision optimization

Argument-dependent name lookup (Koenig Lookup)

Function call argument evaluation order

Unique-pointer and shared-pointer semantics

Braces initialization, type narrowing, and the “most vexing parse”

Benefits and drawbacks of the “auto” and “decltype” keywords

User defined literals

Basics: array, vector, deque, forward_list, and list

Container adaptors: stack, queue, and priority_queue

Trees and hashes: set and map with multi-* and unordered_* variants

Iterators: traversal, insertion, output, and utilities

Basics: fill, for_each, copy, transform, rotate, accumulate, iota

Variations: policy functors, *_if variants, *_n variants

Range-based for-loop semantics

Utilities: bind, operators, hash, pair, tuple

Challenge and science of benchmarking

Understanding profiles and flame graphs

Timing language features: new/delete, exceptions, smart pointers, etc.

Timing STL features: vector vs. list, map vs. unordered_map, etc.