C++ Course

Lesson 1 • Variables, Types, and Literals

Introduces fundamental data types, variable declaration, and literal values. Builds the vocabulary needed for all future data manipulation.

Lesson 2 • Setting Up the Development Environment

Install compilers, IDEs, and build tools for C++ development. Provides the technical foundation every subsequent chapter depends on.

Lesson 3 • Operators and Expressions

Explores arithmetic, relational, logical, and bitwise operators. Operator precedence rules are applied to write correct expressions.

Lesson 4 • Basic Syntax and Program Structure

Covers the anatomy of a C++ source file, including headers, main function, and statements. Connects syntax rules to readable, compilable code.

Lesson 1 • Loops and Iteration

Introduces for, while, and do-while loops alongside loop control statements. Repetition patterns underpin algorithms in later chapters.

Lesson 2 • Scope, Lifetime, and Storage Classes

Explains local, global, and static variable scope and object lifetime. Prevents common bugs caused by misunderstood variable visibility.

Lesson 3 • Recursion and Function Overloading

Introduces recursive problem-solving and multiple function signatures with the same name. Prepares students for complex algorithmic patterns.

Lesson 4 • Function Declaration and Definition

Teaches how to declare, define, and call functions with parameters and return types. Functions are the primary unit of code reuse in C++.

Lesson 1 • Dynamic Memory Allocation

Teaches heap allocation with new and deallocation with delete. Proper resource management here prevents memory leaks in all future programs.

Lesson 2 • Arrays and C-Style Strings

Covers fixed-size arrays, multidimensional arrays, and null-terminated strings. Establishes the low-level data structures that pointers build upon.

Lesson 3 • References and Const Correctness

Distinguishes references from pointers and enforces const usage for safety. Const correctness is a professional C++ coding standard.

Lesson 4 • Smart Pointers Overview

Introduces unique_ptr, shared_ptr, and weak_ptr as safer alternatives to raw pointers. Bridges manual memory management to modern C++ idioms.

Lesson 1 • Polymorphism and Virtual Functions

Implements runtime polymorphism via virtual functions and abstract classes. Enables flexible, extensible designs central to large C++ codebases.

Lesson 2 • Inheritance and Class Hierarchies

Models is-a relationships using single and multiple inheritance. Establishes the hierarchy structure required for polymorphism.

Lesson 3 • Operator Overloading

Enables custom types to use standard operators naturally and expressively. Reinforces encapsulation by keeping logic inside the class.

Lesson 4 • Constructors, Destructors, and Initialization

Teaches object lifecycle management through constructors and destructors. Proper initialization prevents undefined behavior in complex programs.

Lesson 1 • String Handling with std::string

Covers std::string operations, manipulation, and conversion utilities. Replaces unsafe C-style strings with a safe, feature-rich alternative.

Lesson 2 • STL Algorithms

Applies sorting, searching, transforming, and accumulating algorithms from <algorithm>. Replaces error-prone manual loops with expressive one-liners.

Lesson 3 • Associative and Unordered Containers

Introduces map, set, unordered_map, and unordered_set for key-based access. Enables fast lookup patterns used in real-world applications.

Lesson 4 • Sequence Containers

Covers vector, list, deque, and array for ordered data storage. Choosing the right container directly impacts program performance.

Lesson 1 • Concepts and Constraints in C++20

Applies C++20 concepts to constrain template parameters with readable requirements. Produces clearer error messages and self-documenting interfaces.

Lesson 2 • Template Metaprogramming Basics

Introduces compile-time computation using type traits and constexpr. Enables zero-cost abstractions and compile-time validation.

Lesson 3 • Function Templates

Introduces template syntax for writing generic functions with type parameters. Eliminates code duplication while preserving full type safety.

Lesson 4 • Class Templates

Extends templates to classes, enabling generic containers and utilities. Underpins the STL containers studied in the previous chapter.

Lesson 1 • Structured Bindings and std::optional

Introduces structured bindings for tuple-like decomposition and optional for nullable values. Reduces boilerplate and expresses intent clearly.

Lesson 2 • std::variant and std::any

Covers type-safe unions with std::variant and type-erased storage with std::any. Replaces unsafe C unions and void pointers in modern code.

Lesson 3 • Concurrency Fundamentals with std::thread

Introduces thread creation, synchronization primitives, and data race prevention. Prepares students for multi-threaded application development.

Lesson 4 • Move Semantics and Rvalue References

Explains rvalue references, move constructors, and move assignment for performance. Eliminates unnecessary copies in resource-intensive programs.

Lesson 1 • Profiling and Performance Analysis

Applies profiling tools to identify hotspots and measure execution time. Data-driven optimization avoids premature and misguided tuning.

Lesson 2 • Unit Testing in C++

Introduces test frameworks, test case design, and test-driven development (TDD) workflow. Automated tests verify correctness as code evolves.

Lesson 3 • Assertions and Defensive Programming

Uses assert, static_assert, and precondition checks to catch bugs early. Defensive techniques reduce debugging time in large codebases.

Lesson 4 • Optimization Techniques

Covers cache-friendly data layouts, algorithmic improvements, and compiler hints. Applies profiling findings to achieve measurable speedups.