C++ Language Course

Lesson 1 • Input, Output, and Basic Debugging

Introduces std::cin and std::cout for console I/O and basic debugging with print statements and compiler diagnostics. Builds habits for iterative development.

Lesson 2 • Compilation and Linking Pipeline

Explains preprocessing, compilation, assembly, and linking as distinct stages. Students trace how source files become executable binaries.

Lesson 3 • Setting Up the Development Environment

Installs and configures compilers, editors, and build tools on major platforms. Ensures every student has a reproducible workspace before writing code.

Lesson 4 • Structure of a C++ Program

Dissects the anatomy of a minimal C++ source file, including headers, the main function, and namespaces. Connects syntax rules to the compilation model.

Lesson 1 • Arithmetic and Bitwise Operators

Explores arithmetic, modulo, increment, and bitwise operators with precedence rules. Students apply operators to solve numeric and bit-manipulation problems.

Lesson 2 • Variable Declaration and Initialization

Distinguishes default, value, copy, and direct initialization forms. Emphasizes uniform brace initialization to prevent narrowing conversions.

Lesson 3 • Expressions, Statements, and Undefined Behavior

Defines sequence points, value categories, and common sources of undefined behavior. Builds disciplined coding habits from the start.

Lesson 4 • Type Conversions and Casting

Explains implicit promotion, narrowing, and explicit C++ casts. Students learn to convert types safely without undefined behavior.

Lesson 1 • Recursion and Stack Considerations

Applies recursion to classic problems and analyzes stack depth and tail-call patterns. Students balance elegance with practical stack limitations.

Lesson 2 • Conditional Statements

Covers if-else chains, switch-case, and the ternary operator with fall-through rules. Students select the right construct for each decision scenario.

Lesson 3 • Loops and Iteration

Introduces for, while, do-while, and range-based for loops with break and continue. Students choose loops based on iteration pattern and termination condition.

Lesson 4 • Function Overloading and Name Mangling

Explains how the compiler resolves overloaded function calls and generates mangled names. Students write overloads that are unambiguous and maintainable.

Lesson 1 • Smart Pointers and Ownership

Introduces unique_ptr, shared_ptr, and weak_ptr as RAII wrappers that automate memory management. Students replace raw owning pointers with safe alternatives.

Lesson 2 • References and Their Semantics

Distinguishes lvalue references from pointers and introduces rvalue references for move semantics. Students use references to write efficient, alias-safe code.

Lesson 3 • Common Memory Errors and Sanitizers

Identifies dangling pointers, buffer overflows, use-after-free, and double-delete errors. Students use AddressSanitizer and Valgrind to detect and fix bugs.

Lesson 4 • Pointers and Address Arithmetic

Introduces pointer declaration, dereferencing, null pointers, and pointer arithmetic. Connects low-level addressing to array traversal and performance.

Lesson 1 • Polymorphism and Virtual Functions

Explains virtual dispatch, vtables, pure virtual functions, and abstract classes. Students write extensible code that follows the open-closed principle.

Lesson 2 • Classes, Structs, and Encapsulation

Defines class and struct syntax, access specifiers, and member functions. Students encapsulate data to enforce invariants and hide implementation details.

Lesson 3 • Constructors, Destructors, and the Rule of Five

Covers default, parameterized, copy, and move constructors alongside destructors. Students apply the Rule of Five to manage resources correctly.

Lesson 4 • Operator Overloading

Overloads arithmetic, comparison, stream, and subscript operators for user-defined types. Students follow conventions that make overloaded operators intuitive.

Lesson 1 • Class Templates

Defines class templates with member functions, partial specialization, and default parameters. Students build generic containers modeled on standard library patterns.

Lesson 2 • Template Metaprogramming Basics

Uses type traits, if constexpr, and compile-time computation to specialize behavior. Students optimize code paths without runtime overhead.

Lesson 3 • Variadic Templates and Parameter Packs

Expands parameter packs with fold expressions to handle arbitrary argument counts. Students implement forwarding wrappers and type-safe variadic utilities.

Lesson 4 • Function Templates

Introduces function template syntax, type deduction, and explicit instantiation. Students replace duplicated type-specific functions with a single generic version.

Lesson 1 • Utilities: Optional, Variant, and Span

Uses std::optional, std::variant, std::any, and std::span to express nullable, sum, and view types. Students eliminate null pointer bugs and unsafe unions.

Lesson 2 • Standard Algorithms

Applies sorting, searching, transforming, and partitioning algorithms from <algorithm>. Students replace hand-written loops with expressive, tested library calls.

Lesson 3 • Strings, String Views, and Formatting

Covers std::string operations, std::string_view for non-owning access, and std::format for type-safe output. Students handle text efficiently without unnecessary copies.

Lesson 4 • Iterators and Ranges

Explains iterator categories, range-based algorithms, and C++20 ranges and views. Students compose lazy pipelines that process data without intermediate copies.

Lesson 1 • Move Semantics and Value Categories

Deepens understanding of rvalue references, std::move, and move-only types. Students eliminate unnecessary copies in performance-critical code paths.

Lesson 2 • Lambdas and Functional Patterns

Defines lambda syntax, capture modes, generic lambdas, and std::function. Students compose higher-order functions and callbacks with minimal boilerplate.

Lesson 3 • Error Handling Strategies

Compares exceptions, error codes, std::expected, and assertions for communicating failures. Students choose strategies that balance safety, performance, and clarity.

Lesson 4 • Profiling, Optimization, and Undefined Behavior

Profiles with perf and gprof, applies compiler optimizations, and eliminates undefined behavior using sanitizers. Students tune code based on measured data.