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+
- **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:**

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

**Default toolchain:**

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

Run a single exercise:

```bash
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:

```bash
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:

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

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

```bash
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!