Modern C++20 Bootcamp: Basics to Advanced Multithreading

How does a C++ source file get translated into an executable through the compiler and linker pipeline?

A C++ program begins as human-readable source code stored in source files. The compiler translates each source file into an object file — an intermediate symbol representation aligned with machine requirements. The linker then combines one or more object files into a final executable. Multiple source files can contribute to a single program, each compiled independently before being linked together.

The resulting executable is specific to a target operating system and hardware architecture; compilers accept flags to control this translation. All C++ compilers implement the ISO C++ standard, which defines core language features (built-in types, loops, control flow) and the standard library (containers, I/O), where library components are built on top of core language features. C++ is a statically typed language: the type of every object, name, and expression must be known to the compiler at the point of use, enabling compile-time error detection and memory optimization.

After this lecture, learners will be able to trace the source file to object file to executable pipeline and explain the distinct roles of the compiler and linker in producing a runnable C++ program.

Key Topics: compiler, linker, object file, executable, source file, ISO C++ standard, static typing, compilation pipeline, core language

What are the required structural components of a minimal C++ program that produces console output?

A minimal C++ program requires exactly one main function as its entry point — a contract imposed by the operating system — which returns an int communicating execution status (zero signals success). Adding console output requires the preprocessor directive #include to make std::cout available, then using the << (put-to) operator to write a string literal to the standard output stream.

String literals are sequences of characters enclosed in double quotes. The escape sequence \n encodes a newline character. Single-line comments begin with // and are ignored by the compiler. The int keyword declares main's return type, which implicitly defaults to zero when no return statement is provided. The std:: prefix is a namespace qualifier; std::cout refers to the standard output stream provided by the C++ standard library.

After this lecture, learners will be able to write and explain every component of a complete C++ Hello World program including the entry point, output operator, preprocessor include, and string literal syntax.

Keywords: main function, int, std::cout, operator<<, #include, iostream, string literal, escape sequence, namespace, C++

How do you configure Compiler Explorer to compile and execute C++20 programs in a browser?

Compiler Explorer (godbolt.org) is a browser-based C++ development tool that compiles source code and displays the resulting assembly output in real time, eliminating the need for a local IDE or toolchain during early learning. To execute a program rather than only compile it, the "execute the code" checkbox in the outputs dropdown must be enabled; program output then appears in a panel at the bottom of the screen.

To target C++20, the compiler options field must include the flag -std=c++20. The left pane accepts C++ source code; the right pane shows generated x86-64 assembly, which becomes relevant when analyzing performance-critical code. The compiler and target architecture (x86-64, ARM, PowerPC) can be changed via dropdown menus, though defaults are sufficient for all course exercises. Compiler Explorer supports multiple compilers including GCC and Clang.

After this lecture, learners will be able to configure Compiler Explorer with -std=c++20, enable program execution, and run C++ programs directly in a browser tab without any local installation.

Keywords: Compiler Explorer, godbolt.org, -std=c++20, assembly output, browser-based compiler, C++20, compiler flags, x86-64

How does the Udemy coding exercise environment work for submitting and testing C++ solutions?

The Udemy coding exercise environment provides a browser-based coding area where learners submit functions — not complete programs with main — that are run against instructor-written test cases. Compiler output and test results appear directly in the interface, making it the primary way to interpret C++ diagnostic messages in this course.

The platform supported C++14 as of July 2023; exercises requiring C++20 features are directed to Compiler Explorer instead. Each exercise provides starter code with commented prerequisites, a hints tab, and a solution explanation tab. The Run Tests button executes automated test cases against submitted code; a failed test displays the specific function the test expected to find, training learners to read compiler and linker errors as a deliberate skill.

After this lecture, learners will be able to navigate the Udemy coding exercise interface, submit C++ function implementations, and interpret compiler error output from failed test runs.

Keywords: Udemy coding exercises, C++14, compiler errors, test cases, exercise submission, coding environment

The course capstone is a self-directed C++ implementation of a key-value store structured across five progressive stages: an in-memory CRUD store with a command-line interface and unit tests; a custom HashMap replacing the standard library container; persistence via append-only logs with snapshot and compaction support; a networked server with a custom wire protocol and client library; and distributed features including leader-follower replication, Raft consensus-based leader election, sharding, and distributed transactions.

Each stage deliberately introduces engineering challenges beyond C++ syntax: API design, error handling, concurrency, third-party library evaluation, and distributed systems design. Learners are expected to use AI tools for task breakdown and knowledge acquisition while implementing the code independently to build language fluency. No boilerplate, downloadable solutions, or instructor grading are provided — the project is self-driven and intended to be revisited as language features are introduced throughout the course.

After this lecture, learners will be able to map the five capstone stages to a software engineering roadmap and identify which C++ features from later lectures apply to each implementation milestone.

Keywords: key-value store, capstone project, append-only log, Raft consensus, CRUD, distributed systems, API design, C++

A C++ function declaration specifies three components: return type, function name, and a parenthesized list of argument types, terminated by a semicolon. The declaration makes the function's signature known to the compiler; the definition, enclosed in curly braces, provides the implementation. A function cannot be called before it is declared — the compiler uses the declaration to perform argument type checking at every call site.

Passing an argument of the wrong type (e.g., a string to a function declared to accept int) causes a compile-time error. Argument names in a declaration are optional — only types are required; names become necessary in the definition where they are referenced in the body. The void return type is used for functions that return nothing. Separating declaration from definition is fundamental in multi-file C++ programs.

After this lecture, learners will be able to write correct C++ function declarations, distinguish them from definitions, and interpret compiler errors caused by type mismatches at call sites.

Keywords: function declaration, function definition, return type, argument type, void, compiler type checking, function signature, C++

Key Takeaways:

1. Components of function declaration in C++.

2. Difference between function declaration and implementation.

3. Importance of argument type checking.

4. Optional nature of argument names in function declarations.

5. Role of hands-on examples in understanding function declarations.

Function overloading in C++ allows multiple functions to share the same name as long as their argument types differ. The compiler selects the correct overload by matching argument types at the call site: calling add(2.5, 1.5) invokes the double overload, while add(2, 1) invokes the int overload. If no overload matches or the call is ambiguous, the compiler raises an error.

Additional function syntax variations include functions with multiple mixed-type arguments, member functions declared with the class::function syntax to indicate class membership, and functions that call other functions. Functions can also accept user-defined types as arguments. Good function design decomposes programs into small, single-responsibility units; a function named print and a function named add serve distinct roles rather than being combined into a single function.

After this lecture, learners will be able to define overloaded functions, read member function syntax, and explain how the compiler resolves overloads at call sites.

Keywords: function overloading, overload resolution, member function, class scope, argument types, multiple arguments, C++

Key Takeaways:

• Functions can accept diverse argument types.

• Functions can be members of classes.

• Importance of maintainable code using functions.

• Introduction to function overloading in C++.

In C++, every name and expression carries a type that defines the complete set of values it can hold and the operations that may be applied to it. A declaration introduces an entity to the compiler, asserting its existence and binding it to a type contract enforced at compile time.

A type defines permitted values and operations; an object is actual memory (in RAM) holding a value of that type; a variable is a named object that both programmer and compiler can reference; a value is a set of bits interpreted according to the type. C++ provides built-in fundamental types: bool (true/false), char (character, typically 8 bits), int (whole number, typically 4 bytes), double (double-precision floating-point), and unsigned (non-negative integer). The sizeof operator returns the byte size of a type on the current machine.

After this lecture, learners will be able to declare typed variables using C++ fundamental types and explain the distinction between type, object, variable, and value.

Keywords: type system, declaration, variable, object, fundamental types, bool, int, double, sizeof, C++

Key Takeaways:

• Types and Declarations in C++

• Importance of Objects, Values, and Variables

• Predefined Types: bool, char, int, double, unsigned

• Hardware considerations and machine-specific type sizes

• 'sizeof' function in C++

• The significance of CPP reference for ongoing learning

C++ provides five arithmetic operators (+, -, *, /, %) and a full set of comparison operators (==, !=, <, >, <=, >=) for fundamental types. Logical operators (&&, ||, !) treat values as a whole, while bitwise operators (&, |, ^, ~) act on individual bits of the underlying representation.

When mixing types in expressions — for example, adding a double and an int — C++ performs implicit type conversion toward the wider type. Assigning the result back to the narrower type causes truncation (e.g., double to int), which the compiler may warn about but will not always reject as an error. Compound assignment operators such as += and *= combine an arithmetic operation and assignment; the right-hand expression is evaluated first, then the result is assigned to the left-hand operand.

After this lecture, learners will be able to apply arithmetic, comparison, and bitwise operators to fundamental types and identify situations where implicit narrowing conversion silently truncates values.

Keywords: arithmetic operators, comparison operators, bitwise operators, implicit type conversion, narrowing conversion, compound assignment, fundamental types, C++

Key Takeaways:

• Fundamental types in C++ and arithmetic operations.

• Difference between comparison and assignment operators.

• Understanding of logical operations: bitwise and logical.

• Automatic type conversions in C++.

• Benefits of combining operators for readability and performance.

C++ supports two initialization syntaxes: the traditional = operator (int i = 3;) and the universal braced initializer list (int i{3};). The braced form prevents narrowing: assigning a double value to an int variable using {} causes a compile-time error rather than silently truncating, making it the recommended approach. The RAII idiom reinforces declaring and initializing variables at the same point.

The auto keyword enables compiler-driven type deduction: when the initial value unambiguously implies a type (false implies bool, 'x' implies char), the compiler deduces the type. auto is most valuable when type names are long or in generic programming contexts. However, auto should be avoided in large scopes where the type is not visible near its use site, and when deduction could silently select an unintended type — for example, auto deduces 1 as int rather than complex.

After this lecture, learners will be able to choose between = and {} initialization, explain why braced initialization prevents narrowing, and identify cases where explicit types are preferable to auto.

Keywords: uniform initialization, braced initializer list, narrowing conversion, auto, type deduction, RAII, C++

Key Takeaways:

• Traditional value assignment in C++ using the equal-to operator.

• Introduction of curly brace delimited initializer list for value assignment.

• Avoiding truncation and narrowing using the new method.

• Importance of RAII paradigm in C++.

• Utility and caveats of the auto keyword.

• The significance of explicit variable initialization.

In C++, every declaration introduces a name into a specific scope that governs both its visibility and the lifetime of its object. The smallest scope is a block (enclosed by curly braces): names declared inside are inaccessible outside, and objects are destroyed at the closing brace. Function scope spans all blocks within a function; an inner block can access names from the enclosing function, but not the reverse.

Class scope binds a member's lifetime to the lifetime of its containing object. Namespace scope makes names visible to any code that sees the namespace, accessed via the namespace::name syntax. Global scope is the widest: names declared outside all blocks, functions, and classes are visible and alive throughout the entire program execution. Limiting object lifetime to the narrowest necessary scope is a key C++ technique for conserving memory and improving performance.

After this lecture, learners will be able to identify which scope owns any C++ name and predict when an object is constructed, visible, and destroyed.

Keywords: scope, lifetime, block scope, function scope, class scope, namespace scope, global scope, C++

Key Takeaways:

• Introduction to scopes in C++

• Understanding of local, function, class, namespace, and global scopes

• Importance of scope for memory management and high-performance code

  1. Code examples to demonstrate different scopes and their relationships

const declares that a variable's value cannot change after initialization; it may be computed at runtime. constexpr requires the compiler to evaluate the expression at compile time, embedding the result directly in the binary — both the value and any function used to compute it must be compile-time constants. consteval (C++20) is stricter: the decorated function can only be called with compile-time arguments, and passing a runtime variable causes a compiler error.

A constexpr function serves double duty: evaluated at compile time when all arguments are constants, and at runtime when they are not — flexibility unavailable with consteval. Both constexpr and consteval support pure-function semantics, meaning they may only use their arguments and locally-scoped variables, preventing side effects. const in function argument lists guarantees that a passed-by-reference argument will not be modified inside the function body, enforced by the compiler.

After this lecture, learners will be able to select const, constexpr, or consteval for a given scenario and explain why constexpr functions accept runtime arguments while consteval functions do not.

Keywords: const, constexpr, consteval, compile-time evaluation, pure function, immutability, constant expression, C++20

Key takeaways:

• Understanding immutability in C++.

• The distinction between const and constexpr keywords.

• Application and benefits of immutability in interface definitions.

• Introduction to the notion of pure functions through constexpr and consteval.

An array in C++ is a contiguous sequence of elements of a single type, declared as T arr[N]; indexing starts at zero. A pointer is declared as T* p and holds the memory address of an element; the unary & (address-of) operator obtains an address, and * (dereference) retrieves the value at that address. A reference is declared as T& r and must be bound to an object at declaration; once bound, a reference cannot be redirected to a different object.

Arrays can be iterated with a traditional index-based for loop or a range-based for loop (for (auto x : arr)). Passing a const reference to a function — const T& — avoids copying while preventing modification; the compiler enforces this guarantee with a compile-time error on any modification attempt. The three declarative operators are square brackets [] (array of), asterisk * (pointer to), and ampersand & (reference to).

After this lecture, learners will be able to declare arrays, pointers, and references in C++ and distinguish the address-of operator from the reference declarator.

Keywords: array, pointer, reference, address-of operator, dereference, range-based for loop, const reference, declarative operators, C++

Key takeaways:

• Arrays represent contiguous blocks of memory.

• Pointers hold memory addresses, while references are bound to a memory location once created.

• Understanding of for-loops for array iteration.

• Efficient use of references to avoid unnecessary memory copy and improve code safety.

nullptr is the type-safe null pointer constant in C++ (available since C++11) that explicitly represents the absence of a pointed-to object. Unlike NULL (a macro typically defined as 0) and the integer literal 0, nullptr has a distinct type (std::nullptr_t) and is unambiguous to the compiler — assigning nullptr to a non-pointer variable such as int x produces a compile-time error, while assigning 0 would silently succeed.

nullptr is common to all pointer types: the same nullptr value is used whether the pointer is to double, int, or a user-defined type. Before dereferencing a pointer, checking if it equals nullptr guards against undefined behavior from reading invalid memory. A while loop serves as an alternative to for when iteration depends only on a condition, as demonstrated in the null-terminated array traversal example. Legacy code may use 0 or NULL; these should be replaced with nullptr in modern C++.

After this lecture, learners will be able to initialize pointers with nullptr, explain why nullptr is safer than NULL or 0, and write null-pointer guard checks before dereferencing.

Keywords: nullptr, NULL, null pointer, std::nullptr_t, pointer initialization, C++11, type safety, dereference

Key Takeaways:

• Importance of pointers pointing to valid objects.

• Introduction and significance of nullptr in C++.

• Use of nullptr with different data types.

• Practical application with the count_care function.

• Introduction to for and while loop syntaxes.

From a hardware perspective, C++ variables correspond to named memory locations; the compiler translates names into addresses, and the machine operates entirely on addresses. A pointer stores the address of another object: assigning one pointer to another (p = q) changes which address p holds, redirecting it to a new target. A reference also stores an address internally, but assigning one reference to another (r = r2) does not redirect the reference — it copies the value from r2's target into r's target, leaving both references bound to their original objects.

This behavioral difference is illustrated through a name/address/value triad model: pointer assignment changes the stored address; reference assignment changes the stored value at the existing address. References must be initialized at declaration and cannot be redirected afterward. The const qualifier applied to a reference prevents value changes from propagating through it. Initialization and assignment are semantically distinct: initialization creates a valid object from uninitialized memory; assignment copies a value between two already-valid objects.

After this lecture, learners will be able to predict the outcome of pointer and reference assignment by tracing memory addresses and explain why reference assignment differs fundamentally from pointer assignment.

Keywords: pointer, reference, memory address, pointer assignment, reference assignment, hardware model, initialization, assignment, C++

Key Takeaways:

• Direct hardware mapping of C++.

• Memory location's fundamental role.

• Interpretation of memory by C++.

• Pointer and reference operations.

• Significance of memory addresses in C++.

C++ provides four primary control flow constructs: if-else for two-branch conditional execution, switch-case for multi-branch selection against constant case labels, and for and while loops for repeated execution. In a switch statement, each case label tests against a compile-time constant; a default block handles all unmatched values; the break statement exits the switch after executing a matched case that does not return.

std::cin reads user input using the >> operator, the reverse direction of std::cout's <<. A variable declared inside an if statement's condition is scoped to the entire if-else block and accessible in the else branch. The using namespace std; directive eliminates the need to qualify standard library names with std:: throughout the file. Variables declared in a for loop initializer are scoped to the loop body only.

After this lecture, learners will be able to write if-else and switch-case statements, declare variables scoped to a conditional, and choose between for and while loops based on the control structure needed.

Keywords: if-else, switch-case, for loop, while loop, std::cin, case label, break, control flow, C++

Key Takeaways:

• C++ selection and looping constructs

• Understanding 'namespace std'

• The significance of 'cin' and 'cout'

• Conditional testing in C++

• Best practices in switch-case statements

• Memory and speed optimization tips in programming

Built-in types (int, double, char, bool) are designed to directly and efficiently reflect hardware capabilities; they are minimal, generic, and fixed by the language standard. They are intentionally insufficient for higher-level applications — this is by design, not a limitation.

User-defined types are built from other types using C++ abstraction mechanisms: classes and enumerations. They allow programmers to define domain-specific types that are easier to use, more flexible, and more error-resistant than raw combinations of built-in types. The C++ standard library itself is composed of user-defined types (std::vector, std::string) built from built-in primitives. The degree of strictness, available operations, and enforced invariants are entirely under the programmer's control — making UDT design a skill requiring significant practice.

After this lecture, learners will be able to explain why C++ separates built-in from user-defined types and identify how classes and enumerations serve as the primary mechanisms for constructing user-defined types.

Keywords: built-in types, user-defined types, abstraction, class, enumeration, standard library, C++

Key takeaways:

• Built-in types in C++ and their relationship to hardware capabilities.

• The design and limitations of built-in types.

• Introduction to user-defined types and their advantages.

• The role of user-defined types in the C++ standard library.

A struct in C++ groups named data members into a single compound type. Because a struct declaration alone does not allocate memory for its members, an explicit initialization function is required — for example, using operator new to allocate heap memory from the free store and assigning the returned pointer to the struct's pointer member. Objects allocated with operator new persist beyond the enclosing scope until explicitly destroyed with operator delete.

Struct members are accessed three ways depending on how the object is passed: the dot operator (.) for objects passed by value or by reference, and the arrow operator (->) for objects passed as pointers. When iterating over struct-backed data, std::cin reads values from standard input into struct members using the >> operator. Standard library types such as std::vector already implement this pattern; custom structs should only be written when standard alternatives are insufficient.

After this lecture, learners will be able to define and initialize a C++ struct, allocate its backing storage with operator new, and access its members via the dot and arrow operators.

Keywords: struct, operator new, free store, heap allocation, dot operator, arrow operator, member access, C++

Key Takeaways:

• C++ 'struct' introduction and its origin from the C language.

• Defining and initializing a 'vector' in C++.

• Memory allocation with the 'new' operator.

• Methods to access object elements in various scenarios.

• Practical application: summing elements of a vector.

• Advocacy for using existing C++ standard library resources.

A C++ class groups data members and member functions under access specifiers: public members form the externally visible interface, while private members are accessible only within the class or through its public interface. The constructor — a member function with the same name as the class and no return type — is automatically invoked when an object is created and initializes private data using a member initializer list.

Member functions are defined inside the class body; operator overloading (e.g., operator[]) allows standard syntax to invoke class-defined behavior. struct and class differ only in default access: struct members are public by default, class members are private by default — reflecting struct's roots in C. Encapsulation separates interface from representation, allowing internal implementation to change without affecting users of the class.

After this lecture, learners will be able to declare a C++ class with a constructor, public member functions, and private data members, and explain why encapsulation enables independent evolution of implementation.

Keywords: class, constructor, access specifier, public, private, member function, operator overloading, encapsulation, struct, C++

Key Takeaways:

• Importance of separating data from operations.

• Benefits of keeping data representation hidden.

• Introduction to C++ classes and their components.

• Difference between interface and implementation in classes.

• Understanding public and private members using the 'vector' class example.

enum class (strongly typed enumeration) scopes its named integer constants to the enumeration: members are accessed as Color::red, not red. The compiler enforces strict typing: assigning a value from one enum class to a variable of a different enum class, or to a raw int, produces a compile-time error. Converting back to int requires an explicit cast.

Plain enum (the pre-C++11 style) omits scoping and strong typing: members pollute the enclosing namespace and implicitly convert to int, creating ambiguity and bugs. enum class should always be preferred in new code. The underlying storage defaults to int; default operators are limited to assignment, initialization, and comparison (==, <) — additional operators can be added manually (e.g., prefix ++ via a switch on member values). The using enum directive removes the need to qualify members with the enum class name within a local scope.

After this lecture, learners will be able to declare enum class types with scoped members, explain why plain enum is less safe, and extend an enum class with custom operators.

Keywords: enum class, plain enum, scoped enumeration, type safety, scope resolution, underlying type, C++11, using enum

Key takeaways:

• Enums provide a method to represent a limited set of values.

• Strong typing via enum class ensures cleaner code and fewer bugs.

• The scope is essential when accessing enum members.

• Enums can be extended to include more operations.

• Plain enums are a legacy but still prevalent in older codebases.

A raw union in C++ allocates all its members at the same address, consuming only as much memory as its largest member — useful when a value is exactly one of several mutually exclusive types at a time. However, the programmer must manually track which type is active and perform runtime type detection; the C++ type system has no awareness of the active member, creating risk of misinterpretation.

std::variant (modern C++) solves this by bundling the type tag with the value. The compiler participates in type checking: holds_alternative() tests which type is active, and get() retrieves the value with compiler-enforced correctness. Unlike a raw union, std::variant eliminates reading the wrong member without triggering a type-system error. std::variant is always preferred over raw unions in modern C++ unless extreme memory constraints require the manual approach.

After this lecture, learners will be able to implement std::variant as a type-safe alternative to union and explain when each is appropriate.

Keywords: union, std::variant, type-safe storage, holds_alternative, get, type tag, modern C++

Key Takeaways:

• Unions in C++ allow multiple members to share the same memory space.

• Practical application of unions in a symbol table storing pointers or numbers.

• The risk of raw unions hiding types from the compiler.

• Introduction to std::variant as a type-safe alternative to unions.

A C++ program is a collection of separately developed parts; each part exposes an interface (declaration) that describes its behavior without revealing its implementation. This separation allows multiple translation units to reference a declaration without needing access to the underlying definition — the linker resolves the connection at link time.

The One Definition Rule (ODR) permits multiple declarations of the same entity across a program but allows exactly one definition. The compiler immediately rejects a second definition of the same function or class. This is what makes the header-file model work: a class interface declared in a header can be included by many .cpp files, while definitions reside in a single implementation file. Standard library functions (e.g., std::sqrt) are declared by #include but defined entirely within the library, never by user code.

After this lecture, learners will be able to explain why multiple declarations are permitted while multiple definitions are not, and identify the interface/implementation boundary in a multi-file C++ program.

Keywords: One Definition Rule, ODR, declaration, definition, separate compilation, interface, translation unit, linker, C++

Key Takeaways:

• A program consists of various components working collectively.

• Distinguishing between interface and implementation is crucial for modularity.

• The One Definition Rule (ODR) in C++ ensures a single definition for each entity or function.

Separate compilation in C++ partitions a program into independent fragments: declarations (interface) reside in header files (.h), and definitions (implementation) reside in .cpp files. A .cpp file that includes its header is called a translation unit — the atomic compilation unit. The linker combines all translation units into a single binary, resolving cross-unit symbol references.

Header files date back to C (early 1970s) but carry known limitations: every translation unit that #includes a header re-parses its full content, so compilation time grows with include depth. Include order can change macro and constant interpretation, creating fragile ordering dependencies. Header-to-header includes cause unintended transitive dependencies that may pull in third-party types unnoticed. These limitations motivated C++20 modules. The collection of header files in a codebase represents its modularity structure — reading headers alone should reveal all available entities and interactions.

After this lecture, learners will be able to organize a C++ program into header and implementation files, explain what a translation unit is, and identify the root causes of header-file compilation overhead.

Keywords: separate compilation, header file, translation unit, linker, #include, declaration, definition, compilation time, C++

Key Takeaways:

• Significance of modularity in large software systems.

• Importance of separate compilation in C++.

• Introduction to header files and their role in defining interfaces.

• Challenges of using header files, including increased compilation time and potential inconsistencies.

• Understanding dependencies and the risks of unintended connections.

C++20 modules replace the #include mechanism with a pair of keywords: export marks entities for external visibility in the module file, and import makes those entities available in consuming translation units. Unlike #include, import is not transitive: internal dependencies of a module are hidden from the importer, preventing unintended dependency graph expansion.

Modules compile exactly once regardless of how many files import them; header files are re-parsed for every translation unit that includes them, causing code bloat in large projects. Replacing #include with import std can produce up to a 10x compilation speed-up on simple programs. Header ordering issues — where include order changes constant or macro interpretation — are eliminated because module interfaces are self-contained. As of C++20, module support was partial in most compilers; full toolchain support requires local IDE configuration.

After this lecture, learners will be able to write a module definition with export, import it in a consumer file, and explain the compilation advantages over #include.

Keywords: C++20 modules, export, import, header files, translation unit, compilation time, dependency management, non-transitive imports

Key Takeaways:

• Introduction to C++ modules

• Efficient use of the export keyword

• Drawbacks of the traditional #include system

• Modules compile only once, leading to faster execution

• Current partial availability of modules in C++20

A namespace groups logically related declarations — classes, functions, enumerations — under a single named scope. Declared with the namespace keyword followed by a name, the namespace body encloses all declarations; member definitions written outside the namespace block must use the fully qualified name (namespace_name::class_name::function_name).

To access a namespace member, the caller prefixes it with the namespace name and :: (the scope resolution operator); omitting the prefix causes a compiler error. The using namespace directive injects all names from a namespace into the current scope, reducing verbosity. However, applied to rich namespaces such as std, it exposes hundreds of names that can collide with user-defined identifiers — creating ambiguous resolution or silent incorrect overload selection. Many codebases forbid using namespace std; at file scope for clarity. Namespaces used inside a module's implementation remain internal and are not visible to importing code.

After this lecture, learners will be able to declare namespaces, write fully qualified names for out-of-namespace definitions, and explain why using namespace std; is risky at global scope.

Keywords: namespace, scope resolution, fully qualified name, using namespace, name conflict, std, C++

Key Takeaways:

• Importance of namespaces in collecting logical declarations.

• Detailed method to declare and define in namespaces.

• Relationship between namespaces and modules.

• Risks and benefits of the 'using namespace' directive.

• Emphasis on code readability and clarity in software engineering.

Pass-by-value creates an independent copy of the argument inside the function; changes to the copy do not affect the caller's object, making it appropriate for small built-in types where copying is cheap. Pass-by-reference shares the caller's memory location — any modifications inside the function are visible to the caller, enabling intentional side effects. Const reference combines the efficiency of sharing (no copy) with the safety of immutability: the compiler enforces that the function cannot modify the argument.

Default argument values allow callers to omit trailing arguments; the compiler substitutes the default when no value is provided. Global mutable variables are discouraged because uncontrolled shared state causes hard-to-debug side effects; constexpr values at global scope are acceptable since they are immutable. When two functions are closely related, class members provide the preferred alternative to global state for sharing information.

After this lecture, learners will be able to choose among pass-by-value, pass-by-reference, and const reference based on ownership, mutability, and performance requirements, and define functions with default argument values.

Keywords: pass-by-value, pass-by-reference, const reference, default arguments, function arguments, global variables, C++

Key Takeaways:

• Importance of function arguments and return types in C++.

• Pitfalls of using global variables.

• Benefits of employing class members for state sharing.

• Design considerations in C++ programming.

• Differences and use cases for 'pass by value' and 'pass by reference'.

• Advantages of using const references.

• Introduction to default function values.

A C++ function can return a value by copy (return type T), producing an independent object for the caller; or by reference (return type T&), allowing the caller to observe or modify the original object. Returning a reference or pointer to a local variable is undefined behavior — the local is destroyed when the function returns, leaving a dangling reference. Modern compilers flag this as an error.

For large objects such as matrices, returning by copy is expensive. C++11 introduced move semantics for transferring ownership without copying, addressing this case. The auto return type keyword deduces the return type from the return statement; the trailing return type syntax (auto f() -> T) provides an alternative readable form. Functions can return multiple values by returning a struct or class object, which callers unpack using structured bindings (auto [a, b] = f();).

After this lecture, learners will be able to write functions with value return, reference return, auto-deduced return types, trailing return syntax, and structured bindings.

Keywords: return by value, return by reference, trailing return type, auto return type, structured bindings, move semantics, dangling reference, C++11

Key Takeaways:

• The distinction between returning by value and by reference.

• C++ feature of returning pointers from functions.

• Introduction to Move Semantics in C++.

• Using 'auto' for return type deduction.

• Syntax and usage of structured bindings in C++.

Error handling in C++ begins before any language keyword is typed: the type system itself is a first-line error prevention tool, catching type mismatches and invalid operations at compile time. Using standard library containers and algorithms (std::vector, std::map, STL algorithms) instead of hand-rolled data structures further reduces the defect surface by eliminating re-implementation bugs.

Language facilities — exceptions, assertions, error codes — address errors that emerge at runtime and must be routed through the program. But they are tools, not a strategy. Effective error handling requires deciding, during initial design, what constitutes a failure, where in the call stack it can be meaningfully handled, and how much context is needed to recover. In production systems, every unhandled runtime error can cost thousands of dollars; treating error handling as an afterthought — common in competitive programming — is inadequate for commercial software.

After this lecture, learners will be able to explain the three layers of C++ error prevention (type system, standard library, runtime mechanisms) and describe why error strategy belongs in the initial design phase.

Keywords: error handling, type system, standard library, runtime errors, design strategy, exceptions, C++

Key takeaways:

• Importance of error handling in programming.

• Role of C++ language facilities in error handling.

• Significance of the type system in bug detection.

• Value of higher-level constructs in C++.

• The financial implications of errors in production.

When a C++ function detects an error it cannot resolve (e.g., an out-of-bounds subscript), it throws an exception using the throw keyword followed by an exception object (e.g., std::out_of_range). The exception propagates up the call stack, bypassing normal return paths. Stack unwinding occurs automatically: every object created inside the try block between the throw point and the catch is destroyed in reverse construction order via its destructor — ensuring no resource leaks if RAII is used.

A catch block specifies the exception type it handles, caught by reference for efficiency and polymorphism: catch (std::out_of_range& err). The .what() member function of standard exception objects returns the error description as a string. try-catch blocks should not appear in every function; exceptions may bubble up multiple levels before being caught where the error can be meaningfully handled. Overusing try blocks where exceptions are routine is a design error.

After this lecture, learners will be able to throw exceptions using standard types, structure try-catch blocks, access error descriptions via .what(), and explain stack unwinding.

Keywords: throw, try-catch, stack unwinding, std::out_of_range, .what(), RAII, destructor, exception propagation, C++

Key Takeaways:

• Challenges of accessing out-of-range elements in the vector class.

• Importance and usage of try and catch blocks for error-handling.

• RAII (Resource Allocation Is Initialization) for systematic error handling.

• Judicious use of exception handling to avoid performance hits.

A class invariant is a condition that must remain true for all valid objects of a class — a fact the class's member functions rely on to operate correctly. For a vector class, the invariant is that the internal pointer references a validly allocated array of the declared size; without it, every element-access operation is unsafe.

The constructor is responsible for establishing the invariant: if the provided size is negative, it throws std::length_error before any allocation occurs, preventing an invalid object from being observed by the rest of the program. Preconditions — argument checks at a function's entry — complement invariants by verifying caller-supplied inputs. Custom exception classes enable domain-specific error reporting for production systems. Invariants make code more robust and readable: examining an invariant reveals the designer's intent immediately. Constructors and destructors together form the resource-management invariants of an object: constructor acquires, destructor releases.

After this lecture, learners will be able to identify class invariants, enforce them in constructors via throw, and explain why explicit invariants improve code robustness and readability.

Keywords: class invariant, constructor, precondition, throw, std::length_error, resource management, RAII, C++

Key Takeaways:

• Importance of preconditions in functions.

• Concept and significance of class invariants.

• Error handling techniques in C++ (length errors and memory exhaustion errors).

• Custom exception classes for domain-specific solutions.

• The role of invariants in ensuring code robustness and readability.

Exceptions are the preferred C++ mechanism for rare, unanticipated failures that must propagate up a call stack because intermediate functions have no suitable return path. Error codes are preferable when failure is expected (e.g., file not found), when the immediate caller can handle it directly, or in memory-constrained environments where exception machinery is unacceptable. Program termination (std::terminate, std::exit, noexcept) applies when recovery is impossible and a system restart is the cheapest resolution.

The noexcept keyword marks a function as non-throwing; any throw that propagates through it immediately calls std::terminate. Libraries should never unconditionally terminate. Overusing try blocks where failures are expected is a design smell — exceptions are for genuinely rare, exceptional situations. The right choice depends on failure frequency, call-stack depth, memory constraints, and whether the caller can meaningfully react to the error.

After this lecture, learners will be able to select among exceptions, error codes, and termination based on failure frequency, call-stack position, and system constraints.

Keywords: exceptions, error codes, termination, noexcept, std::terminate, error handling strategy, C++

Key Takeaways:

• Importance of error handling in software design.

• The prominence of exceptions in C++ for error handling.

• Alternatives to exceptions and their usage scenarios.

• Advantages of exceptions in communicating errors.

• The significance of designing for irremediable program errors.

The assert macro (from ) tests a condition at runtime in debug builds; if false, the program terminates. In release builds, assert expressions are silently removed — making assert unsuitable for production error handling. static_assert evaluates a condition at compile time: it takes the condition and an optional string message; if false, compilation fails with that message displayed. This is ideal for platform assumptions (e.g., verifying sizeof(long int) == 8 before logic that depends on 64-bit longs).

A flexible runtime-assertion framework — suggested by Stroustrup — combines an error_action enum (ignore, throw, terminate, log), a configurable default action, and a template expect() function that branches on action and condition. The noexcept specifier on a function signature declares the function must not throw; if a throw propagates through it, std::terminate is called immediately. noexcept should be used only after careful design review, as evolving codebases frequently break the contract unintentionally.

After this lecture, learners will be able to use assert for debug-mode runtime checks, static_assert for compile-time assumptions, and noexcept to declare non-throwing function contracts.

Keywords: assert, static_assert, noexcept, precondition, compile-time assertion, debug build, std::terminate, C++

Key Takeaways:

• Understanding error handling in C++.

• Introduction to advanced features for better runtime error checks.

• Hands-on with the subscripting operator of the vector class.

• Importance of consistent coding practice.

• Introduction to the assert macro and its limitations.

Classes are the central feature of C++, present since the language's origins as "C with classes." Their purpose is to represent collections of related entities — data and operations — as named types that make program structure readable and maintainable. Rather than scattered integers and functions, an Employee or Payroll class communicates domain intent directly in code.

This section covers three fundamental class types: concrete classes (behave like built-in types, allocatable on stack), abstract classes (define interfaces through pure virtual functions, cannot be instantiated), and class hierarchies (structures of derived classes sharing inherited interfaces and implementations). The C++ standard library is built entirely from these patterns — std::vector, std::string, and STL algorithms are all class-based APIs. Understanding these three categories is prerequisite to reading any production-grade C++ codebase and to designing effective domain-specific libraries.

After this lecture, learners will be able to identify the three C++ class categories covered in this section and explain the overall purpose classes serve in program organization.

Keywords: concrete class, abstract class, class hierarchy, C++ classes, user-defined types, standard library, program organization

Key Takeaways:

• The historical significance of classes in C++.

• Practical application of classes for representing entities in code.

• Enhancing code readability and functionality using classes.

• Role of classes in public APIs.

• Introduction to three primary class types: concrete classes, abstract classes, and class hierarchies.

A concrete type is a class whose representation is part of its own definition — users can declare concrete-type objects as local variables, pass them by value, copy them, and access them directly without pointer indirection. The representation is embedded in the object (e.g., a pointer member plus a size integer), so the compiler knows the full size at compile time, enabling stack allocation.

This design brings significant advantages: no heap overhead, immediate full initialization enforced by the constructor (the object cannot be used before construction completes), and eligibility for copy and move semantics. Access to the underlying data is controlled through public and private member functions, protecting invariants. The primary cost is that any change to the class's representation forces recompilation of all translation units that use it. In contrast, abstract types whose representation lives on the heap behind a pointer do not impose this recompilation cost when implementation changes.

After this lecture, learners will be able to explain why concrete types enable stack allocation and direct use, and identify when recompilation cost makes abstract types preferable.

Keywords: concrete type, stack allocation, representation, copy semantics, move semantics, recompilation, abstract type, C++

Key Takeaways:

• Introduction to 'concrete types' in C++.

• Behavior similarity between concrete types and built-in types.

• Intrinsic representation as a defining characteristic of concrete types.

• Advantages of placing objects on function stack memory.

• Implications of modifications in concrete types necessitating recompilation.

A complex number class illustrates a well-formed concrete type: two private double members, three constructor overloads (both parts, real-only with default imaginary = 0, and a default constructor), and a copy constructor for initialization from another complex object. Member functions marked const (e.g., real(), imag()) guarantee they do not modify the object; the compiler enforces this at every call site.

Operators defined inside the class body are automatically inlined — the compiler substitutes the function body directly without a call overhead, useful for trivial operations (+=, -=). Non-trivial operators (+, -, *, /) defined outside the class incur a function call overhead but avoid excessive code bloat. Implementing operator!= in terms of operator== avoids duplicating comparison logic. Objects are constructed using the uniform brace initializer ({3.14}), invoking the matching constructor overload at compile time.

After this lecture, learners will be able to define a class with multiple constructors, const member functions, overloaded arithmetic operators, and inlined simple operations.

Keywords: constructor overload, const member function, operator overloading, inline function, copy constructor, complex number, concrete type, C++

Key Takeaways:

• Basics of complex number representation in C++.

• Introduction to constructors, including the copy constructor.

• Understanding of const functions and inlining in C++.

• Implementation of overloaded operators.

• Practical uses of the implemented class.

A destructor is named ~ClassName() with no return type or parameters, called automatically when an object's scope ends. Its purpose is the inverse of the constructor: where the constructor allocated heap memory with operator new, the destructor releases it with operator delete[]. This ensures every allocated object is cleaned up without manual intervention.

The handle-to-body pattern stores only a pointer and a size integer in the class object itself (both fixed-size), keeping the object stack-allocatable while actual data lives on the heap. An initializer_list constructor accepts a braced element list; the size member is initialized with static_cast(list.size()) to convert from the unsigned size_t returned by the standard library. The push_back member appends elements one at a time. Casts such as reinterpret_cast and const_cast bypass the type system and should be avoided unless strictly necessary.

After this lecture, learners will be able to write a destructor that deallocates heap memory, implement an initializer_list constructor, and explain the handle-to-body design pattern.

Keywords: destructor, operator delete, initializer_list, handle-to-body pattern, static_cast, push_back, heap memory, C++

Key Takeaways:

• Definition and role of containers in programming

• Memory management: constructors and destructors

• Vector class behavior and scope

• Class design and structure

• Vector initialization methods and typecasting

In this lecture, we explore the foundations and applications of abstract types in C++, emphasizing the importance of decoupling the interface from its representation. C++ offers a powerful mechanism for designers to insulate class implementations from the end-users. We dive deep into the intricacies of abstract types, such as how they hide memory allocation details, necessitating using pointers for representation access. Key C++ components such as the 'virtual' keyword and its utility in defining abstract types are discussed. We further examine "pure virtual functions" and how they lead to the creation of abstract classes using the '= 0' syntax.

The lecture then proceeds with practical implementations, illustrating the use of abstract types in actual code. We introduce the 'container' class as an example, exemplifying polymorphism and inheritance in C++. The demonstration includes two classes derived from the 'container' class, namely 'vector_container' and 'list_container,' to exemplify the implementation of abstract interfaces. The course culminates by stressing the benefits of inheritance and polymorphic types in maintaining flexible and efficient code structures.

Key Takeaways:

• Abstract types in C++ for interface and representation decoupling.

• The significance of the 'virtual' keyword.

• Introduction to pure virtual functions and abstract classes.

• Practical demonstration with 'container', 'vector_container', and 'list_container' classes.

• Emphasizing the advantages of inheritance and polymorphic types using abstract interfaces.

When a function accepts a base class reference and calls a virtual member, the compiler cannot determine at compile time which derived class's implementation to invoke — the object type is known only at runtime. C++ resolves this through the virtual function table (vtable): each class with at least one virtual function maintains a per-class table of function pointers, each entry pointing to the correct implementation for that class.

Every object with virtual functions carries a hidden pointer to its class's vtable. At a virtual call site, the runtime reads the vtable pointer from the object, looks up the function address by index, and dispatches to it. This adds one level of indirection compared to a direct call — imperceptible in most applications but measurable in tight inner loops of high-performance code. For extremely latency-sensitive systems, alternatives to virtual dispatch (e.g., templates and static polymorphism) eliminate vtable overhead.

After this lecture, learners will be able to explain vtable structure, describe how runtime dispatch resolves virtual calls, and identify the scenarios where vtable overhead is a design concern.

Keywords: vtable, virtual function table, runtime dispatch, virtual function, polymorphism, dynamic dispatch, overhead, C++

Key Takeaways:

• Function calls in C++ with the interface and derived class objects.

• Introduction and working of the virtual function table or B table.

• Graphical representation of B tables within class objects.

• The performance overhead of B tables in high-performance applications.

• Contextual use of virtual functions in C++.

Polymorphic objects in a class hierarchy should be allocated on the free store and accessed through pointers — unlike concrete types that can live on the stack. When code needs to determine or enforce a specific derived type at runtime, dynamic_cast provides two modes: applied to a pointer, it returns nullptr if the object is not the requested type; applied to a reference, it throws std::bad_cast on mismatch.

Raw new/delete patterns create memory leaks if an exception fires between allocation and deletion. std::unique_ptr eliminates this by wrapping the heap-allocated object in a scope-owned smart pointer: when the unique_ptr goes out of scope — normally or via exception — it automatically calls the destructor and releases memory. Returning unique_ptr from a factory function transfers ownership to the caller, making ownership explicit in the function signature.

After this lecture, learners will be able to use dynamic_cast for runtime type checking in hierarchies, replace raw new/delete with unique_ptr, and explain how unique_ptr prevents memory leaks during exception propagation.

Keywords: dynamic_cast, unique_ptr, polymorphic type, runtime type checking, std::bad_cast, memory safety, smart pointer, C++

Key Takeaways:

• Understanding class hierarchies in C++

• The significance of derivation in code structure

• Role of interfaces in class hierarchies

• Importance of destructors in derived classes

• The concept and application of abstract classes

A class hierarchy in C++ is built by deriving classes from a base: class Circle : public Shape declares that Circle inherits Shape's public interface. A derived class must override each pure virtual function in the chain. Classes further down the hierarchy (e.g., Emoji deriving from Circle) inherit both the interface and any implementations from intermediate classes.

Each class is responsible for destroying only the resources it allocates: if Emoji allocates heap objects (e.g., a vector of shape pointers), its destructor must delete them before the base destructor runs. When no dynamic allocation is present, the compiler-generated default destructor is sufficient. Constructor arguments are forwarded up the chain: Emoji's constructor invokes Circle's constructor with point and radius. The override keyword is recommended on all overriding member functions to prevent silent signature mismatches from creating unintended new functions instead of overrides.

After this lecture, learners will be able to build multi-level class hierarchies, chain constructors up the hierarchy, and write per-level destructors for owned resources.

Keywords: class hierarchy, inheritance, override, multi-level inheritance, constructor chaining, destructor, virtual function, C++

Key Takeaways:

• Importance of class hierarchies in C++.

• Interface-based inheritance and its advantages.

• Illustrative examples of class hierarchy implementation.

• Significance of resource management.

• Introduction to unique pointers in modern C++.

Every C++ class has up to seven special member functions: ordinary constructor, default constructor (no arguments), copy constructor (const X&), move constructor (X&&), copy assignment operator (X& operator=(const X&)), move assignment operator (X& operator=(X&&)), and destructor. These are generated by the compiler on demand — but declaring any copy or move operation prevents automatic generation of others.

The = default specifier explicitly requests a compiler-generated implementation; = delete suppresses it entirely (e.g., deleting copy constructor prevents memberwise copy of polymorphic base classes). The Rule of Zero: if none of the special operations are defined, the compiler generates all needed defaults — the cleanest design. Single-argument constructors can silently create implicit type conversions (e.g., vector v = 7); the explicit keyword prevents this. Default member initializers assign values directly in the class body, guaranteeing members are never uninitialized regardless of which constructor runs.

After this lecture, learners will be able to declare all seven special member functions, use = default and = delete to control compiler generation, apply the Rule of Zero, and use explicit to block implicit conversions.

Keywords: special member functions, copy constructor, move constructor, = default, = delete, Rule of Zero, explicit, default member initializer, C++

Key Takeaways:

• Fundamental operations: initialization, assignment, copy, move.

• Importance of aligning operations with the use case.

• Copy elision: compiler optimization.

• Rule of zero for class design.

• Challenges and considerations of argument constructors and implicit conversions.

Default member-wise copy of a class that owns a heap pointer produces a shallow copy: both objects' pointers reference the same memory block, causing aliased mutations and double-free errors. A copy constructor (X(const X& other)) corrects this by allocating new memory and copying elements individually, producing truly independent objects.

Returning large objects by value creates expensive intermediate copies. C++11 introduced move semantics: the move constructor (X(X&& other)) accepts an rvalue reference — bound to a value no one else needs — and transfers ownership by copying the pointer and nulling the source. std::move() casts an lvalue to rvalue to trigger move semantics explicitly. The copy assignment operator uses the this pointer (a built-in pointer to the current object) to return *this after copying. Copy elision allows the compiler to construct the result directly in the caller's target variable, eliminating even the move overhead.

After this lecture, learners will be able to implement copy constructors, copy assignment with this, move constructors using rvalue references, and apply std::move to trigger ownership transfer.

Keywords: copy constructor, copy assignment, move constructor, rvalue reference, std::move, shallow copy, ownership transfer, copy elision, C++11

Key Takeaways:

• Default object copying behavior in C++.

• The challenge of copying classes with embedded resource handles.

• Introduction to copy constructors and copy assignment operators.

• Efficient handling of large objects using move constructors and move assignment operators.

RAII (Resource Acquisition Is Initialization) is C++'s core resource management paradigm: a resource is acquired inside a constructor and released inside the corresponding destructor. Because destructors are called automatically when an object goes out of scope — including during stack unwinding on exception — RAII guarantees no acquired resource is ever leaked, regardless of how a scope exits.

A resource is anything that must be acquired and released: memory, file handles, sockets, database connections, thread handles. Wrapping a raw resource in a class object (a resource handle) binds its lifetime to the owner's lifetime. Smart pointers (unique_ptr, shared_ptr) automate this for heap memory. RAII is the foundation of all STL containers (std::vector, std::string), file streams (fstream), and C++ threading primitives. Garbage collection is extrinsic to C++ and cannot provide the same deterministic release timing; RAII is organic to the language and should always be preferred over GC libraries.

After this lecture, learners will be able to explain the RAII idiom, implement a resource handle class, and identify why smart pointers are the recommended alternative to manual new/delete.

Keywords: RAII, resource handle, smart pointer, unique_ptr, shared_ptr, destructor, memory safety, garbage collection, C++

Key Takeaways:

• Resource Management in C++

• Resource Handlers vs. Raw Pointers

• Importance of Smart Pointers

• Debunking Garbage Collection myths in C++

• Philosophy of RAII in C++

• Application of RAII in standard library classes.

Operator overloading assigns domain-specific meaning to standard operators for user-defined types — the same symbol, different argument types. Overloadable operators include binary arithmetic (+, -, , /, %), logical (&&, ||, !), relational (==, !=, <, >, <=, >=), assignment (=, +=, -=, etc.), increment/decrement (++, --), pointer (, ->), subscripting ([]), function call (()), comma (,), and bitwise shift (<<, >>). The dot operator (.) cannot be overloaded.

When defined as a class member, the first operand is implicitly *this — giving asymmetric access to members. For operators with symmetric operands (e.g., operator+, operator==), defining them as freestanding functions in the same namespace treats both arguments equally and enables move semantics on the return value, eliminating unnecessary copies. The return type should match the conventional meaning of the operator — using operator+ to perform multiplication is always incorrect.

After this lecture, learners will be able to identify which C++ operators are overloadable, define them as member or freestanding functions, and explain when each placement is appropriate.

Keywords: operator overloading, member function, freestanding function, operator+, operator==, symmetric operands, move semantics, C++

Key Takeaways:

• Operator overloading adds custom meanings to operators for user-defined types.

• Misinterpreting or inventing symbols can introduce errors.

• Various operators, including binary arithmetic, unary, and assignment, can be overloaded.

• The Dot operator is non-overridable.

• Use freestanding functions for symmetric operands to optimize performance.

Equality comparisons are coupled to copying: an object copied into another should always compare equal. When defining operator== for a user-defined type, all six comparison operators (==, !=, <, <=, >, >=) should be defined as a complete set — each can be expressed through == and <. Operators can be defined as class members (with an implicit first operand of *this) or as freestanding functions in the same namespace for symmetric operand treatment.

C++20 introduced the three-way comparison (spaceship) operator <=>: it returns a value less than zero if the left operand is less, zero if equal, and greater than zero if greater. When declared auto operator<=>(const X&) = default;, the compiler generates all six comparison operators from memberwise ordering. If the programmer defines <=> manually, operator== is not implicitly generated and must be defined separately. The ternary operator (?:) is a concise one-line conditional alternative to if-else for simple returns.

After this lecture, learners will be able to implement the full C++ comparison operator suite for a user-defined type, use the C++20 spaceship operator, and explain when the compiler does and does not auto-generate operator==.

Keywords: operator==, spaceship operator, three-way comparison, operator<=>, C++20, comparison operators, freestanding function, ternary operator

Key Takeaways:

• Importance of conventional operations in user-defined classes.

• Role of equality and ‘less than’ operators in representing other key operators.

• Introduction and application of the Spaceship operator in C++20.

• Benefits of defining precise operations for enhanced code performance.

Containers in C++ are expected to provide begin() and end() iterators that delimit the sequence; the range-based for loop relies on these internally. cbegin() and cend() return const iterators — any modification attempt through them produces a compile-time error. begin() and end() can be member functions or freestanding functions in the same namespace; standard library containers use both patterns.

The << and >> operators, overloaded on std::ostream and std::istream, enable custom I/O formatting for user-defined types. std::swap exchanges two objects efficiently; large types with variable data should provide a move-semantics-based custom swap to avoid unnecessary copies. std::unordered_map requires a hash function for key types; for user-defined keys the programmer must implement a std::hash specialization or provide a hash functor to enable O(1) average-case lookup. Iterator types must also implement ++, --, +=, -=, and subtraction operators for full compatibility with standard algorithms.

After this lecture, learners will be able to implement begin/end iterators for a container, overload stream operators for I/O, and explain why hash functions are required for unordered_map keys.

Keywords: iterator, begin, end, cbegin, cend, stream operator, swap, hash function, unordered_map, C++

Key Takeaways:

• Importance of following standard library container styles.

• The role of 'size_t' and its relation to standard library functions.

• Understanding iterators, specifically 'begin' and 'end.'

• The difference between calling by value and reference.

• Introduction to unordered maps and the principle of hashing.

A user-defined literal is declared with operator""_suffix — the operator"" keyword followed by the literal suffix: constexpr complex operator""_i(long double d) defines the _i suffix so 2.5_i produces complex{0, 2.5}. The argument type (long double, unsigned long long, const char*, etc.) selects which overload the compiler invokes; the return type defines the resulting value type. Declaring the operator constexpr moves the computation to compile time.

The C++ standard library provides built-in literal namespaces: std::literals::chrono_literals (h, min, s, ms, us, ns for time units), std::literals::string_literals (s suffix for std::string), std::literals::string_view_literals (sv for std::string_view), and std::literals::complex_literals (i for imaginary). Each must be activated with a using directive. User-defined literals embed domain semantics — units, type constraints — directly in literal values, improving readability and reducing the need for comments.

After this lecture, learners will be able to define a user-defined literal with operator""_suffix, specify correct argument and return types, and use the standard library chrono and string literal namespaces.

Keywords: user-defined literal, operator"", suffix, std::literals, chrono_literals, string_literals, constexpr, C++

Key Takeaways:

• Customization of user-defined types using classes and constructors.

• Significance of literals for readability in domain-specific applications.

• Standard library inclusions: chrono header, string literals, and more.

• Introduction and application of complex literals in scientific computations.

• Importance of literals in code readability and domain translation.

A C++ template allows a class or function to be parameterized over a type or value: template class vectorproduces a generic container whose element type is determined by the caller. The compiler generates a separate, type-specific concrete class for every unique type argument — a process called instantiation. Because instantiation happens at compile time, templates carry zero runtime overhead.

Generalizing the hand-written vector to vector replaces every occurrence of double in the class body and member function definitions with T; each member function definition also requires the templateprefix. Instantiating vector generates code identical to a hand-written vector. For nested templates, two consecutive >> terminate the template argument list — a whitespace requirement lifted in C++11 but visible in older compilers. The standard library is built entirely from templates; learners should exhaust standard library types before writing custom ones.

After this lecture, learners will be able to convert a concrete class to a template class, explain the instantiation process, and understand why template code incurs no runtime performance cost.

Key Takeaways:

• Understanding of templates in C++.

• Introduction to generic programming.

• Deep dive into vector class as an example of templates.

• Overview of instantiation in templates.

• Importance of the C++ standard library.

A C++20 concept is a predicate that constrains a template type argument: template restricts T to types that satisfy the concept at instantiation — producing a clear error if the passed type does not qualify, rather than a cryptic deep-instantiation failure. A template with constrained arguments is called a constrained template. The standard library defines concepts such as std::copyable, which verifies a type supports copy operations.

Beyond type arguments, templates can accept value arguments (non-type template parameters). A buffer class with template<typename T, int N> accepts the buffer size as a compile-time integer, enabling stack-allocatable fixed-size containers that vary in both element type and capacity. Value arguments must be constant expressions. One known limitation: passing a string literal directly as a template value argument fails until C++23; the workaround is to first store it in a character array and pass that instead.

After this lecture, learners will be able to apply a C++20 concept as a template argument constraint, define non-type template parameters, and explain why concept-constrained templates produce better error messages than unconstrained ones.

Keywords: C++20 concepts, concept, constrained template, non-type template parameter, copyable, template argument, template, C++

Key Takeaways:

• Understanding template specificity in C++.

• Introduction to constraints and the concept of 'concept'.

• Utility of value arguments in templates.

• The use-case of buffer class in C++ templates.

• Handling string literals in template arguments as of C++23.

Template argument deduction allows the compiler to infer template type parameters from initializer values, eliminating explicit type annotations. Deduction succeeds when the type is unambiguously inferable: vector v{1, 2, 3} correctly deduces vector. Deduction fails when the only constructor argument carries no type information — a single integer size like vector(5) gives no element type — requiring the programmer to specify the type explicitly.

A common pitfall: initializing a vector with string literals without annotations deduces vector<const char*> instead of vectorstd::string. Appending the s suffix to only one element creates a type mismatch error; the fix is to specify the template argument explicitly or apply the suffix consistently. For iterator-range constructors, the compiler cannot distinguish a pair of iterators from a pair of values — creating ambiguity. Deduction guides are programmer-provided hints that map a constructor argument pattern to the intended template instantiation, resolving such ambiguity without requiring explicit caller annotation.

After this lecture, learners will be able to identify when template argument deduction fails, correct errors with explicit type arguments, and write deduction guides for iterator-range constructors.

Keywords: template argument deduction, CTAD, deduction guide, const char*, std::string, iterator-range constructor, explicit type argument, vector, C++

Key Takeaways:

• Template argument deduction in C++.

• Instantiation using class templates like standard pair.

• Compiler's ability in type deduction based on syntax.

• Challenges in type deduction with vectors and their solutions.

• Introduction and application of deduction guides.

• Use of iterator-based constructors with the vector class.

A function template is declared with template<typename Sequence, typename Value> before the function signature; the compiler instantiates a concrete function for each unique argument type combination at the call site. Template argument deduction allows callers to omit type arguments when the compiler can infer them from the supplied arguments. Function templates cannot be virtual: the vtable is fixed at class definition time and cannot enumerate all possible template instantiations.

A functor (function object) is a class that overloads operator(), making instances callable like functions. A less_than functor stores a threshold at construction and returns a boolean from operator()(T x). Functors are inlined by the compiler — their small size means no call overhead — and passed as predicates to algorithms like count_if. This combines compile-time type safety with runtime flexibility: the same functor works across std::vector, std::list, std::string, and any other container type without code duplication.

After this lecture, learners will be able to define a function template, explain why template functions cannot be virtual, and implement a functor class for use as a predicate in STL algorithms.

Key Takeaways:

• Introduction to parameterized operations.

• Differences and applications of function templates, function objects, and lambda expressions.

• Deep dive into generic algorithms and their interaction with different container types.

• Insights into function objects and their benefits in terms of efficiency and performance.

A lambda expression defines an anonymous function object inline at its point of use: captures{body}. The capture list controls which enclosing-scope variables are accessible inside the lambda: [&] captures all local variables by reference, [=] captures all by value (copy), [x] captures only x by value, [&x] captures only x by reference, [] captures nothing. Inside a member function, [this] captures the current object by reference; [*this] captures a copy.

Lambda functions are first-class objects: they can be stored in variables and passed as arguments to other functions. A lambda passed to for_each is applied to every element of a container, replacing a separate named functor with inline logic. Using auto as a parameter type makes a lambda generic — equivalent to a function template. Generic lambdas can be further constrained with C++20 concepts. Lambdas also enable safe initialization: returning a value from a lambda guarantees an object is never left in an uninitialized state across a switch-case.

After this lecture, learners will be able to write C++ lambda expressions with any capture mode, pass them to STL algorithms, and create generic lambdas using auto parameters.

Keywords: lambda expression, capture list, [&], [=], [this], generic lambda, for_each, closure, auto parameter, C++

Key Takeaways:

• Introduction to lambda expressions in C++.

• Syntax and semantics of lambda functions.

• Use of lambdas for various tasks, including initialization.

• Emphasizing code safety, readability, and harnessing the compiler's power.

A variable template is a compile-time value parameterized by type: template constexpr bool assignable = ...; can be used inside other templates to query type properties. An alias template introduces a type synonym with using: using string_map = map<string, Value>; fixes one template parameter while leaving others free, enabling concise domain-specific type names and improving readability.

if constexpr is a compile-time conditional: the compiler evaluates the condition at compile time based on types and emits code only for the true branch, discarding the false branch entirely. This eliminates runtime branch prediction overhead and is the idiomatic tool for type-dependent behavior inside templates — compared to a runtime if, which requires both branches to compile for all instantiations. The requires keyword expresses compile-time type constraints on template arguments, complementing C++20 concepts. static_assert and constexpr expressions appear frequently alongside these mechanisms. Abusing preprocessor tricks to work around these features produces fragile production code.

After this lecture, learners will be able to define variable templates, create alias templates with using, and apply if constexpr for compile-time conditional code generation inside templates.

Keywords: variable template, alias template, using, if constexpr, requires, compile-time, template specialization, static_assert, C++

Key Takeaways:

• Variable templates and their dependency on the type

• Use of 'constexpr' and 'static asserts' in template design

• Introduction of aliases for domain-specific readability

• Compile-time decision-making for enhanced code performance

• Importance of correct language use over shortcuts