A self-contained reference book covering the fundamentals of C++
What C++ is, how source code becomes an executable, and the trade-offs of the language.
Preprocessor directives, namespaces, functions, and standard I/O with iostream.
Primitive types, overflow, constants, enums, type deduction, and memory layout.
Static and dynamic arrays, multidimensional arrays, array decay, C-strings, std::string, std::array, and std::vector.
Arithmetic, comparison, logical, increment/decrement, compound assignment, bitwise operators, and std::bitset.
if/else, while, do-while, for, range-based for, break, continue, switch/case, ternary operator, and goto.
Prototypes, extern linkage, default values, pass by reference, function stacks, inline, overloading, name mangling, and overload resolution.
Pointers, dynamic allocation, delete, const pointers, nullptr, placement new, references, resource management, and smart pointers.
Encapsulation, access specifiers, constructors, init lists, destructors, copy/move semantics, object initialization, static members, const member functions, mutable, friends, unions, and the this pointer.
How the compiler eliminates unnecessary copies on return — RVO, NRVO, Copy Elision, and when these optimizations don't apply.
Type sizes, alignment boundaries, struct padding, member ordering, #pragma pack, empty class size, and cache architecture.
Public, protected and private inheritance, base class initialization, overriding, slicing, multiple inheritance, and copy/assignment in derived classes.
Virtual functions, vtables, abstract base classes, pure virtual functions, the diamond problem, and override/final specifiers.
Template Method and Strategy patterns, non-member non-friend functions, conversion design, and exceptions in destructors.
Unary and binary operators, equality, subscript, function operator, move assignment, conversion operators, and user-defined literals.
C-style casts vs C++ casts — static_cast, dynamic_cast, reinterpret_cast, const_cast, and volatile.
What macros are, include guards, function macros, assert, and when to prefer consts, enums, and inlines.
Template functions and classes, specialization, variadic templates, static_assert, generic programming, and std::tuple.