Prices shown are a USD base. Your local-market price is calculated at checkout in your own currency, plus any local sales tax.
What is inside
20 chapters, in the order the interviews tend to ask them:
The object model and object lifetime
Classes, inheritance and runtime polymorphism
RAII and deterministic resource management
Smart pointers and expressing ownership in the type system
Move semantics and value categories
The rule of five and the rule of zero
Templates, deduction and constraints
STL containers and choosing between them
Iterators, algorithms and range based for
Exception safety and error reporting
The preprocessor and translation phases
Modules, headers and API boundaries
Compile times, build systems and header hygiene
Threads, mutexes and condition variables
The C++ memory model and atomics
Futures, promises and async primitives
Pointers, references, arrays and raw memory
Constness, constexpr and compile time computation
Overload resolution, conversions and casts
Performance, profiling and evidence
How the answers are built
Each chapter opens with the checklist the question is really testing. A few from this pack:
A C++ object is a region of data storage whose contents can represent a value of the object's type, and the standard says little more than that.
A virtual call resolves twice: the call itself is fixed by the static type of the expression, then the object's dynamic type selects the final overrider at run time.
RAII binds a resource's lifetime to an object's lifetime, so every exit from a scope, including an exception, runs the same release code.
unique_ptr is the default: it expresses single ownership, costs one pointer, and deletes its copy constructor so ownership cannot be duplicated by accident.
C++20 names five value categories: lvalue, xvalue, glvalue, prvalue and rvalue, where glvalue is an lvalue or xvalue and rvalue is an xvalue or prvalue.
The five are the destructor, the copy constructor, the copy assignment operator, the move constructor and the move assignment operator.
Questions this pack covers
What is the object model in C++, in the words the standard actually uses?
How does object lifetime differ from storage duration in C++?
How does virtual dispatch work when you call through a base pointer?
What is object slicing, and when does it bite in real code?
What does resource acquisition is initialization actually guarantee?
How do you make a C++ type own a raw file descriptor?
When should you choose unique_ptr over shared_ptr?
Why does shared_ptr have a weak_ptr companion type at all?
Each one is answered in full in the pack, with the reasoning written out rather than a bullet list.
