# C++ advanced: _under the hood_ You've written classes, managed resources with RAII, and leaned on the standard containers.[1](#ref-1) Now we go underneath. C++'s power comes from three ideas working together: **generics** (write one algorithm for every type), **moves** (transfer resources instead of copying them), and **concurrency** (do several things at once, safely). The whole standard library is built on these. As always, every feature below links to cppreference.com[2](#ref-2) or the C++ Core Guidelines.[3](#ref-3) You should be comfortable with Parts 1 and 2 first.[1](#ref-1)[4](#ref-4) Type each example. The project at the end uses _all_ of it. ## 01Templates: write once, work for any type A **template** is a recipe the compiler uses to generate code for whatever type you plug in. A _function template_ deduces its type from the arguments:[5](#ref-5) ``` template T max_of(T a, T b) { return (a > b) ? a : b; } int i = max_of(3, 7); // T deduced as int double d = max_of(2.5, 1.8); // T deduced as double ``` A _class template_ parameterises a whole type, `std::vector` is one. You can constrain templates with **concepts** (C++20) so errors are readable instead of pages of template gibberish:[6](#ref-6) ``` template requires std::integral // T must be an integer type T half(T x) { return x / 2; } std::cout << half(10); // OK: int is integral // half(3.0); // error: double is not integral ``` The Core Guidelines treat templates as the default way to express "the same logic, many types", prefer them over copying code or reaching for macros.[3](#ref-3) ## 02The library Before writing a loop by hand, check whether `` already does it. These are generic, tested, and usually faster than a hand-rolled loop. They operate on _iterator pairs_, the half-open range `[begin, end)`.[7](#ref-7) ``` #include #include std::vector v = {5, 2, 9, 1, 5}; std::sort(v.begin(), v.end()); // 1 2 5 5 9 auto it = std::find(v.begin(), v.end(), 9); // iterator to 9 bool has = (it != v.end()); int sum = 0; std::for_each(v.begin(), v.end(), [&](int x) { sum += x; }); ``` Iterators are what make templates and algorithms compose: an algorithm written for `vector` works for `array`, `map`, or even a raw pointer range, because they all speak the same iterator "language." Prefer the named algorithm over a raw loop, it states your _intent_.[3](#ref-3) ## 03Lambdas: functions on the spot A **lambda** is an unnamed function you write inline, ideal as the "what to do" argument to an algorithm. The `[…]` is the _capture list_: `[&]` captures variables by reference, `[=]` by value.[8](#ref-8) ``` std::sort(v.begin(), v.end(), [](int a, int b) { return a > b; }); // descending int threshold = 4; auto count = std::count_if(v.begin(), v.end(), [threshold](int x) { return x > threshold; }); // captures by value ``` By default a lambda can't modify captured-by-value variables; add `mutable` to allow it. To store a lambda in a variable, give it type `std::function`.[8](#ref-8) Lambdas are the modern replacement for many hand-written functors, and they're how you make algorithms expressive. ## 04Move semantics: transfer, don't copy Here's the key advanced idea. A copy duplicates data; a **move** takes ownership of it. When you return a big object or pass a temporary, C++ can "steal" its contents instead of cloning them, dramatically faster for strings, vectors, and containers.[9](#ref-9) An **rvalue reference** (`&&`) binds to temporaries. `std::move(x)` is a cast that says "I'm done with x, please take its guts."[10](#ref-10) ``` std::vector make_big() { std::vector v(1 << 20); // a million ints return v; // moved, not copied } std::vector a = make_big(); // the data is transferred std::vector b = std::move(a); // a is now empty; b owns the data ``` Understanding lvalues vs rvalues, and when the compiler chooses a move constructor over a copy constructor, is what separates advanced C++ from intermediate.[11](#ref-11) Pair it with `std::forward` in generic code to preserve whether an argument was an lvalue or rvalue ("perfect forwarding").[12](#ref-12) ## 05The rule of zero (and five) In Part 2 you learned RAII: tie a resource to an object's lifetime so it's cleaned up automatically.[13](#ref-13) The modern conclusion is the **rule of zero**: if your class only holds smart pointers, containers, and strings, all of which already manage themselves, then _you write no destructor, copy, or move code at all_. The compiler generates correct ones.[3](#ref-3) ``` struct Document { // rule of zero std::string title; std::vector data; std::unique_ptr note; // owns a heap object }; // copies, moves, and cleanup: all correct, for free ``` Only when you _directly_ own a raw resource (a file handle, a `new`ed pointer, a lock) do you fall back to the **rule of five**: define (or `= default`/`= delete`) the destructor, copy/move constructors, and copy/move assignment, as a set.[14](#ref-14) In practice: prefer the rule of zero; reach for `std::unique_ptr` so you almost never need the rule of five at all.[3](#ref-3) ## 06Concurrency with std:thread C++11 gave us portable threads in the standard library. A `std::thread` runs a function concurrently with the rest of your program.[15](#ref-15) You must `join()` (wait for it to finish) or `detach()` (let it run free) before it's destroyed, RAII saves you here too, via `std::jthread` in C++20, which joins automatically. ``` #include #include void work(int id) { std::cout << "thread " << id << " running\n"; } std::thread t1{work, 1}; std::thread t2{work, 2}; t1.join(); // wait for t1 t2.join(); // wait for t2 ``` ## 07Sharing data safely: races and atomics Threads sharing a variable without coordination produce **data races**: undefined behaviour. The simplest fix for a single counter is `std::atomic`, which makes reads/writes indivisible:[16](#ref-16) ``` #include std::atomic counter{0}; void bump() { for (int i = 0; i < 1000; i++) counter++; } std::thread a{bump}, b{bump}; a.join(); b.join(); std::cout << counter << std::endl; // reliably 2000 ``` For richer shared state you'd use a `std::mutex` (lock with `std::lock_guard`) so only one thread enters a critical section at a time. The Core Guidelines are strict: never share writable state between threads without a synchronisation mechanism, and prefer the highest-level tool that works (atomics > mutex > hand-rolled flags).[3](#ref-3) ## 08Project: a parallel word-frequency counter Let's combine everything: templates, algorithms, lambdas, RAII, and threads. We'll read a file, split it into chunks, count word frequencies in parallel with `std::async` (which manages threads for us), then merge the results. ``` #include #include #include #include #include