cpp-course/README.md

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+
• GCC 16+ with C++26 and contracts support
• CLion (recommended) or any CMake-aware IDE
• Internet access on first configure (Google Test is fetched automatically)

Install GCC 16 on macOS (Homebrew):

brew install gcc@16

Quick Start (CLion)

1. Open this folder in CLion.
2. Settings → Build, Execution, Deployment → CMake
3. Enable profile default (display name GCC 16 + C++26 from CMakePresets.json).
4. Disable old profiles that use Apple Clang (e.g. custom profiles without the preset toolchain).
5. Click Reload CMake Project.

If configure fails with "This project requires GCC 16+", CLion is still using Apple Clang. Enable the default preset or set the toolchain C++ compiler to g++-16.

If configure fails with "generator does not match", delete the build folder (cmake-build-debug-gcc-16-cpp26) and reload CMake.

6. Pick an exercise target (e.g. 02_control_flow_loops) and run tests.

Quick Start (Terminal)

cmake --preset default
cmake --build cmake-build-debug-gcc-16-cpp26
ctest --test-dir cmake-build-debug-gcc-16-cpp26 --output-on-failure

Run a single exercise:

cmake --build cmake-build-debug-gcc-16-cpp26 --target 02_control_flow_loops
./cmake-build-debug-gcc-16-cpp26/modules/02_control_flow/02_control_flow_loops

Manual configure (without presets):

cmake -S . -B cmake-build-debug-gcc-16-cpp26 \
  -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/gcc-16.cmake \
  -DCOURSE_ENABLE_CONTRACTS=ON
cmake --build cmake-build-debug-gcc-16-cpp26

Project Structure

cppc/
├── CMakeLists.txt              # Root project + Google Test
├── CMakePresets.json           # GCC 16 + C++26 preset
├── cmake/
│   ├── CourseExercise.cmake    # add_course_exercise() helper
│   ├── CourseOptions.cmake     # Warnings, standards, contracts
│   └── toolchains/gcc-16.cmake # GCC 16 toolchain file
├── support/                    # Contract violation handler
└── modules/
    ├── 01_fundamentals/
    ├── 02_control_flow/
    └── ...                     # 14 modules total

Each module contains:

• README.md — learning goals and exercise list
• include/ — function and class declarations
• 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+

Example:

cmake --preset default -DCOURSE_WARNINGS_AS_ERRORS=ON

C++26 Contracts

On GCC 16+, the build enables:

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

Example:

#include <contracts>

[[nodiscard]] auto factorial(const int n) -> long long pre(n >= 0);

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

CLion Tips

• Use the GCC 16 toolchain, not Apple Clang.
• Disable Clangd and Clang-Tidy inspections — they use the Clang frontend and do not support GCC C++26 contracts.
• Cppcheck plugin: disable inline analysis for this project (see Cppcheck below).
• Use Run | Run… and filter by module prefix (e.g. 02_control_flow).
• Enable Google Test integration to see individual tests in the tree view.

Cppcheck

Cppcheck does not understand GCC C++26 contracts (pre(...)) or GCC 16 libstdc++ when the CLion plugin analyzes headers in isolation. That produces false IDE errors such as:

• Include file: <contracts> not found
• failed to evaluate #elif condition in libstdc++ headers
• parse errors on pre(...)

Recommended: disable the plugin, use the CMake target

1. Settings → Editor → Inspections → C/C++ → Cppcheck → disable
2. Configure and build once:

   cmake --preset default
   cmake --build build
   

3. Run Cppcheck from CLion or terminal:

   cmake --build build --target cppcheck_modules
   

This uses compile_commands.json from your GCC 16 build and suppresses known false positives (cppcheck/suppressions.txt).

If you keep the plugin anyway

Settings → Cppcheck configuration → Options:

--language=c++ --std=c++26 --max-configs=1 --suppress=missingIncludeSystem --suppress=syntaxError

Expect remaining false positives on contract syntax. The plugin is not a good fit for this codebase.

Notes on C++26

All exercises build with C++26. Module READMEs describe the language feature each exercise teaches (C++11, C++17, etc.), but the toolchain baseline is C++26 throughout.

Happy learning!