Modern C++ Course (Basics → C++26)

A hands-on C++ course with 56 Google Test exercises organized into 14 modules, from your first functions to modern standard-library features.

Requirements

• CMake 3.20+
• C++26-capable compiler
  • GCC 16+ recommended (required for pre/post contracts)
  • Apple Clang can build most exercises but does not support contracts yet
• CLion (recommended) or any CMake-aware IDE
• Internet access on first configure (Google Test is fetched automatically)

Quick Start (CLion)

1. Open this folder in CLion (File → Open…).
2. Select the gcc26-contracts CMake profile (see CMakePresets.json).
3. Reload CMake when prompted.
4. Pick an exercise target (e.g. 02_control_flow_loops) in the run configuration dropdown.
5. Implement the TODOs in the matching src/*.cpp file.
6. Run the test target until all assertions pass.

Quick Start (Terminal)

Recommended — GCC 16 with contracts:

cmake --preset gcc26-contracts
cmake --build build-gcc26
ctest --test-dir build-gcc26 --output-on-failure

Default toolchain:

cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
cmake --build build
ctest --test-dir build --output-on-failure

Run a single exercise:

cmake --build build-gcc26 --target 02_control_flow_loops
./build-gcc26/modules/02_control_flow/02_control_flow_loops

Project Structure

cppc/
├── CMakeLists.txt              # Root project + Google Test
├── cmake/
│   ├── CourseExercise.cmake    # add_course_exercise() helper
│   ├── CourseOptions.cmake     # Warnings, standards, contracts
│   └── toolchains/gcc-16.cmake # Optional GCC 16 toolchain file
├── CMakePresets.json           # CLion/CMake presets (gcc26-contracts)
├── support/                    # Shared contract violation handler
└── modules/
    ├── 01_fundamentals/        # Types, operators, I/O
    ├── 02_control_flow/       # if, switch, loops
    ├── 03_functions/           # Functions and recursion
    ├── 04_arrays_and_strings/  # Arrays, string, vector
    ├── 05_pointers_and_references/
    ├── 06_oop_basics/          # Classes, inheritance
    ├── 07_stl_containers/
    ├── 08_stl_algorithms/
    ├── 09_cpp11/               # C++11 features
    ├── 10_cpp14/
    ├── 11_cpp17/
    ├── 12_cpp20/               # Concepts, ranges, <=>
    ├── 13_cpp23/               # expected, mdspan, format
    └── 14_cpp26/               # Frontier / C++26 direction

Each module contains:

• README.md — learning goals and exercise list
• include/ — function and class declarations (your contract)
• src/ — your implementation (start here)
• test/ — Google Test files (do not edit unless extending)

How to Study

1. Read the module README.md.
2. Open the exercise header to understand the required API.
3. Implement TODOs in the corresponding src/ file.
4. Run that exercise’s test target in CLion or via CTest.
5. Move to the next exercise only when tests pass.

Course Map

Module	Topic	Exercises	Build standard
01	Fundamentals	4	C++26
02	Control flow	4	C++26
03	Functions	4	C++26
04	Arrays & strings	4	C++26
05	Pointers & references	4	C++26
06	OOP basics	4	C++26
07	STL containers	4	C++26
08	STL algorithms	4	C++26
09	C++11 features	4	C++26
10	C++14 features	4	C++26
11	C++17 features	4	C++26
12	C++20 features	4	C++26
13	C++23 features	4	C++26
14	C++26 frontier	4	C++26

CMake Options

Option	Default	Description
COURSE_BUILD_TESTS	ON	Build Google Test exercise targets
COURSE_WARNINGS_AS_ERRORS	OFF	Treat warnings as errors
COURSE_ENABLE_CONTRACTS	ON	Enable -fcontracts on GCC 16+ targets

Example:

cmake --preset gcc26-contracts -DCOURSE_WARNINGS_AS_ERRORS=ON

C++26 Contracts

Exercises compile as C++26. On GCC 16+, the build enables:

• -fcontracts
• -fcontract-semantic=enforce
• A shared handle_contract_violation handler in support/contract_handler.cpp

Use #include <contracts> and syntax like:

auto factorial(int n) -> long long
    pre(n >= 0)
{
    // ...
}

Apple Clang does not support contracts yet. Use the gcc26-contracts preset in CLion or:

cmake -S . -B build-gcc26 \
  -DCMAKE_CXX_COMPILER=/opt/homebrew/bin/g++-16 \
  -DCOURSE_ENABLE_CONTRACTS=ON

CLion Tips

• Use Run | Run… and filter by module prefix (e.g. 12_cpp20).
• Enable Google Test integration in CLion to see individual tests in the tree view.
• Set breakpoints in your src/ implementation while debugging failing tests.
• compile_commands.json is exported for clangd/clang-tidy if you use external tools.

Notes on C++26

All exercises now build with C++26. Module READMEs still describe the language feature each exercise teaches (C++11, C++17, etc.), but the toolchain baseline is unified at C++26 for a consistent modern environment.

Happy learning!