Is C++ hard to learn?

The basics are comparable to any other language. The difficulty is breadth: forty years of accumulated features, several ways to do most things, and a long history of advice that is now outdated. Learn modern C++ from the start, ignore raw new and delete, and the curve flattens considerably.

Which C++ standard should I target?

C++17 is the safe baseline, supported everywhere including older toolchains. C++20 is production ready on current GCC, Clang and MSVC and worth targeting for new projects. C++23 support is close to complete but still uneven in library corners.

What is the difference between struct and class in C++?

Only the default access level. Members of a struct are public by default, members of a class are private. Everything else is identical. Convention reserves struct for plain data.

When should I use pointers instead of references in C++?

Use a reference when the thing always exists and never changes. Use a pointer when it can be null, when it needs to be reassigned, or when you are walking memory. Use a smart pointer whenever ownership is involved.

What is undefined behaviour in C++?

Undefined behaviour is a program state the standard places no requirements on. The compiler is allowed to assume it never happens and optimizes on that assumption, so the result is not a predictable wrong answer but a different program. Common causes are reading past the end of an array, using memory after it is freed, signed integer overflow, and data races. Build with -fsanitize=address,undefined to catch most of it.

Is std::regex slow in C++?

Yes. std::regex compiles the pattern at runtime and is significantly slower than equivalent facilities in other languages. For simple checks use string operations such as starts_with, ends_with or find. For heavy pattern work use a dedicated library like RE2 or CTRE, which compiles patterns at compile time.

C++98 through C++23

C++ Cheat Sheet

Every construct worth memorizing, in one page. Search it, filter it by the standard your compiler actually supports, and copy what you need.

Search the C++ cheat sheet /

standard

show

columns

available in C++17 also shows everything older

563snippets

15sections

69topics

6standards

// no match

Nothing here matches that. Try a shorter term, or widen the standard filter.

// nothing in this section

This section has no snippets at that standard.

Basics

Program skeleton, types, I/O and initialization. Everything you write on line one.

Program Structure

core language

Minimal program that compiles and runs

#include <iostream>

int main() {
    std::cout << "Hello, world!\n";
    return 0;
}

core

stdout

Hello, world!

main returns 0 implicitly, the return is optional

int main() {
    // no return needed, 0 is assumed
}

core

main with command line arguments

int main(int argc, char* argv[]) {
    for (int i = 0; i < argc; ++i)
        std::cout << argv[i] << "\n";
}

core

Line comment and block comment

// single line comment
/* block comment
   spanning lines */

core

Namespace declaration and access

namespace geo {
    double area(double r) { return 3.14159 * r * r; }
}

double a = geo::area(2.0);

core

Pull one name in instead of the whole namespace

using std::cout;   // good
// using namespace std;  // avoid in headers
cout << "no prefix needed\n";

core

Nested namespace shorthand

namespace app::core::io {
    void flush();
}

C++17

Anonymous namespace gives internal linkage

namespace {
    int helper_counter = 0;  // visible only in this file
}

core

Console Output

core language

Print with the stream operator

std::cout << "value: " << 42 << "\n";

core

stdout

value: 42

Chain mixed types in one statement

std::string name = "Ada";
int age = 36;
std::cout << name << " is " << age << "\n";

core

stdout

Ada is 36

Newline vs endl, endl also flushes the buffer

std::cout << "fast\n";        // preferred in loops
std::cout << "flushed" << std::endl;

core

Write to standard error

std::cerr << "could not open file\n";

core

Type safe formatting

#include <format>
std::cout << std::format("{} scored {:.2f}\n", "Ada", 9.5);

GCC 13 / Clang 17 / MSVC 19.29C++20

stdout

Ada scored 9.50

Print straight to stdout, no stream needed

#include <print>
std::print("{} + {} = {}\n", 2, 3, 5);

GCC 14 / Clang 18 / MSVC 19.37C++23

stdout

2 + 3 = 5

C style printf still works

#include <cstdio>
std::printf("%s is %d\n", "Ada", 36);

core

Console Input

core language

Read a single value

int n;
std::cin >> n;

core

Read several values in one go

int a, b;
std::cin >> a >> b;

core

Read a whole line including spaces

std::string line;
std::getline(std::cin, line);

core

Clear the newline left behind by >> before getline

int n;
std::cin >> n;
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
std::string rest;
std::getline(std::cin, rest);

core

Mixing >> and getline without ignore is the classic beginner bug.

Loop until input runs out or fails

int x;
while (std::cin >> x) {
    std::cout << x * 2 << "\n";
}

core

Recover from a failed read

if (!(std::cin >> n)) {
    std::cin.clear();
    std::cin.ignore(1000, '\n');
}

core

Variables and Constants

core language

Declare and initialize

int count = 10;
double ratio = 0.75;
bool ready = true;
char grade = 'A';

core

Let the compiler deduce the type

auto total = 42;          // int
auto price = 19.99;       // double
auto name = std::string{"Ada"};

C++11

Runtime constant, cannot be reassigned

const int max_users = 100;
// max_users = 200;  // compile error

core

Compile time constant, usable in array sizes and templates

constexpr int buffer_size = 1024;
int buffer[buffer_size];

C++11

Must be evaluated at compile time, no exceptions

consteval int square(int n) { return n * n; }
constexpr int nine = square(3);

C++20

Guarantee constant initialization without making it const

constinit static int tick = 0;  // no static init order fiasco

C++20

Function local value that survives between calls

int next_id() {
    static int id = 0;
    return ++id;
}

core

result

1, then 2, then 3

Share one definition across translation units

// in a header
inline constexpr double pi = 3.14159265358979;

C++17

Declare a variable defined in another file

extern int global_counter;  // definition lives elsewhere

core

Fundamental Types

core language

Integer family with typical sizes

short      a;   // at least 16 bits
int        b;   // usually 32 bits
long       c;   // 32 or 64 bits
long long  d;   // at least 64 bits

core

Unsigned variants hold no negatives

unsigned int   u = 4000000000u;
unsigned char  byte_val = 255;

core

Fixed width integers, portable across platforms

#include <cstdint>
std::int32_t  id     = 42;
std::uint64_t hash   = 0xDEADBEEF;
std::int8_t   offset = -8;

C++11

Floating point precision tiers

float       f = 3.14f;    // ~7 digits
double      d = 3.14;     // ~15 digits
long double l = 3.14L;

core

Boolean and character types

bool     flag = true;
char     c    = 'x';
char8_t  u8   = u8'x';   // C++20
wchar_t  w    = L'x';

core

The unsigned type for sizes and indices

std::size_t n = vec.size();
for (std::size_t i = 0; i < n; ++i) { }

core

Query the size of a type or object in bytes

std::cout << sizeof(int) << " " << sizeof(double) << "\n";

core

stdout

4 8

Ask the library for type limits

#include <limits>
int hi = std::numeric_limits<int>::max();
int lo = std::numeric_limits<int>::min();

core

result

2147483647 -2147483648

Nothing type, used for functions that return no value

void log(const std::string& msg) { std::cout << msg << "\n"; }

core

Literals and Initialization

core language

Brace initialization, warns on narrowing

int    n{42};
double d{3.14};
// int bad{3.14};  // error: narrowing

C++11

Value initialize to zero or empty

int         n{};        // 0
std::string s{};        // ""
std::vector<int> v{};   // empty

C++11

Fill a container from a brace list

std::vector<int> nums{1, 2, 3, 4, 5};
std::map<std::string,int> ages{{"Ada", 36}, {"Alan", 41}};

C++11

Digit separators keep long numbers readable

long population = 1'400'000'000;
int mask = 0b1010'1010;

C++14

Number bases

int dec = 42;
int oct = 052;
int hex = 0x2A;
int bin = 0b101010;   // C++14

core

Raw string literal ignores escapes

std::string path = R"(C:\Users\ada\file.txt)";
std::string json = R"({"key": "value"})";

C++11

String and character literal suffixes

using namespace std::string_literals;
auto s1 = "text"s;          // std::string
auto s2 = "text"sv;         // std::string_view (C++17)

C++14

Null pointer literal, never use 0 or NULL

int* p = nullptr;
if (p == nullptr) { /* empty */ }

C++11

Casting and Conversion

core language

Safe compile time conversion between related types

double d = 3.99;
int n = static_cast<int>(d);   // 3

core

Downcast in a polymorphic hierarchy, returns nullptr on failure

Base* b = get_shape();
if (auto* c = dynamic_cast<Circle*>(b)) {
    c->radius();
}

core

Strip const, only when you own the original object

const int ci = 10;
int* p = const_cast<int*>(&ci);

core

Writing through the result is undefined behaviour if the object is truly const.

Reinterpret the bit pattern, the sharpest tool here

std::uint32_t bits = 0x3F800000;
float* f = reinterpret_cast<float*>(&bits);

core

Bit level copy without breaking aliasing rules

#include <bit>
float f = std::bit_cast<float>(std::uint32_t{0x3F800000});

C++20

result

String to number and back

int    n = std::stoi("42");
double d = std::stod("3.14");
std::string s = std::to_string(99);

C++11

Fast, no throw, locale independent parsing

#include <charconv>
int value{};
auto [ptr, ec] = std::from_chars(text.data(), text.data() + text.size(), value);
if (ec == std::errc{}) { /* parsed */ }

C++17

Control Flow

Branching, looping and the newer init forms that keep scopes tight.

Conditionals

core language

if, else if, else

if (score >= 90) {
    grade = 'A';
} else if (score >= 80) {
    grade = 'B';
} else {
    grade = 'F';
}

core

Declare the variable inside the if, scope ends with the branch

if (auto it = m.find(key); it != m.end()) {
    use(it->second);
}  // it is gone here

C++17

Ternary conditional expression

int max = (a > b) ? a : b;

core

switch on integers, enums and chars

switch (cmd) {
    case 'a': add();  break;
    case 'd': del();  break;
    default:  help();
}

core

Mark intentional fallthrough so the compiler stops warning

switch (n) {
    case 1:
        prepare();
        [[fallthrough]];
    case 2:
        run();
        break;
}

C++17

switch with initializer

switch (auto v = poll(); v.kind) {
    case Kind::Key:  handle_key(v);  break;
    case Kind::Quit: return;
}

C++17

Branch removed at compile time, the dead side is never instantiated

template <typename T>
void show(T value) {
    if constexpr (std::is_pointer_v<T>)
        std::cout << *value;
    else
        std::cout << value;
}

C++17

Loops

core language

Classic counting loop

for (int i = 0; i < 10; ++i) {
    std::cout << i << " ";
}

core

stdout

0 1 2 3 4 5 6 7 8 9

Range based loop, read only

for (const auto& item : items) {
    std::cout << item << "\n";
}

C++11

Range based loop that modifies elements

for (auto& x : nums) {
    x *= 2;
}

C++11

Unpack pairs while iterating a map

for (const auto& [key, value] : scores) {
    std::cout << key << ": " << value << "\n";
}

C++17

Range based loop with initializer

for (auto conn = open(); const auto& row : conn.rows()) {
    process(row);
}

C++20

while loop, condition checked first

while (queue.has_next()) {
    handle(queue.pop());
}

core

do while runs the body at least once

do {
    std::cin >> choice;
} while (choice < 1 || choice > 5);

core

Skip an iteration or leave the loop

for (int n : values) {
    if (n < 0) continue;   // next iteration
    if (n > 99) break;     // exit loop
    total += n;
}

core

Infinite loop idiom

for (;;) {
    if (should_stop()) break;
}

core

Operators

core language

Arithmetic and remainder

int sum = a + b;
int rem = a % b;      // integer remainder
double q = 7 / 2.0;   // 3.5, one operand must be floating point

core

7 / 2 with two ints gives 3, not 3.5.

Increment and decrement, prefix is preferred on iterators

int a = ++i;   // increment then read
int b = i++;   // read then increment

core

Compound assignment

total += 5;
count *= 2;
flags |= MASK;

core

Comparison operators

a == b   a != b
a <  b   a <= b
a >  b   a >= b

core

Logical operators short circuit

if (ptr != nullptr && ptr->ready()) { }   // right side skipped if left is false

core

Three way comparison generates all six relational operators

auto cmp = a <=> b;
if (cmp < 0)      { /* a < b */ }
else if (cmp > 0) { /* a > b */ }
else              { /* equal */ }

GCC 10 / Clang 10 / MSVC 19.28C++20

Bitwise operators

int band = a & b;
int bor  = a | b;
int bxor = a ^ b;
int bnot = ~a;
int shl  = a << 2;
int shr  = a >> 2;

core

Standard bit helpers

#include <bit>
int  ones = std::popcount(0b1011u);   // 3
bool p2   = std::has_single_bit(16u);  // true

C++20

Jumps and Attributes

notes

Break out of nested loops with goto, one of its few defensible uses

for (int i = 0; i < n; ++i)
    for (int j = 0; j < m; ++j)
        if (grid[i][j] == target) goto found;
found:
    report(i, j);

core

Hint the optimizer about the hot path

if (data != nullptr) [[likely]] {
    process(data);
} else [[unlikely]] {
    recover();
}

C++20

Warn when a return value is ignored

[[nodiscard]] bool save(const Doc& d);
// save(doc);  // warning: return value discarded

C++17

Silence unused parameter warnings

void handler([[maybe_unused]] int code) { }

C++17

Mark a function that never returns

[[noreturn]] void fail(const char* msg) {
    std::cerr << msg;
    std::abort();
}

C++11

Mark an API as deprecated with a reason

[[deprecated("use save_v2 instead")]] void save();

C++14

Functions

Overloads, defaults, lambdas and the callable wrappers that glue code together.

Declaring Functions

core language

Definition with parameters and a return type

int add(int a, int b) {
    return a + b;
}

core

Declaration first, definition later or in another file

int add(int a, int b);       // header

int add(int a, int b) {      // source
    return a + b;
}

core

Pass big objects by const reference, not by value

void print(const std::string& text);   // no copy
void tweak(std::string& text);         // caller sees changes
void take(std::string text);           // copy or move

core

Default arguments, rightmost first

void connect(const std::string& host, int port = 8080, bool tls = true);
connect("api.example.com");

core

Overload on parameter types

double area(double r);
double area(double w, double h);
double area(const Polygon& p);

core

Trailing return type, useful when the type depends on the parameters

template <typename A, typename B>
auto add(A a, B b) -> decltype(a + b) {
    return a + b;
}

C++11

Deduced return type

auto midpoint(double a, double b) {
    return (a + b) / 2;
}

C++14

Promise not to throw, enables better codegen

int size() const noexcept { return n_; }

C++11

Compile time evaluation when the arguments allow it

constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}
constexpr int f5 = factorial(5);   // computed by the compiler

C++11

result

Lambdas

modern c++

Anonymous function stored in a variable

auto add = [](int a, int b) { return a + b; };
int sum = add(2, 3);

C++11

result

Capture nothing, everything by value, everything by reference

int factor = 3;
auto a = [](int x)       { return x * 2; };       // no capture
auto b = [=](int x)      { return x * factor; };  // copy
auto c = [&](int x)      { return x * factor; };  // reference

C++11

Capture specific variables

auto scale = [factor, &log](int x) {
    log("scaling");
    return x * factor;
};

C++11

Modify a captured copy

int calls = 0;
auto tick = [calls]() mutable { return ++calls; };

C++11

Generic lambda accepts any type

auto twice = [](auto x) { return x + x; };
twice(3);       // 6
twice("ab"s);   // "abab"

C++14

Move something into the lambda

auto owner = [data = std::move(big_vector)]() {
    return data.size();
};

C++14

Explicit template parameters on a lambda

auto first = []<typename T>(const std::vector<T>& v) { return v.front(); };

C++20

Capture the enclosing object

auto handler = [this] { return this->state_; };   // captures the pointer
auto copy    = [*this] { return state_; };        // copies the object (C++17)

C++11

Call the lambda immediately to initialize a const value

const auto config = [] {
    Config c;
    c.load("app.ini");
    return c;
}();

C++11

Callables and Dispatch

modern c++

Plain function pointer

int add(int a, int b) { return a + b; }
int (*op)(int, int) = add;
int r = op(2, 3);

core

Type erased callable wrapper, holds functions, lambdas and functors

#include <functional>
std::function<int(int,int)> op = [](int a, int b) { return a * b; };
op = add;   // reassign to a free function

C++11

Store a table of handlers

std::map<std::string, std::function<void()>> commands{
    {"save", []{ save(); }},
    {"quit", []{ quit(); }}
};
commands["save"]();

C++11

Bind arguments ahead of time, though lambdas usually read better

using namespace std::placeholders;
auto add5 = std::bind(add, 5, _1);
add5(10);   // 15

C++11

result

Function object, a class with operator()

struct Multiplier {
    int factor;
    int operator()(int x) const { return x * factor; }
};
Multiplier times3{3};
times3(7);

core

result

Accept any callable without type erasure overhead

template <typename F>
void repeat(int n, F fn) {
    for (int i = 0; i < n; ++i) fn(i);
}

core

Forward arguments preserving value category

template <typename... Args>
void emplace_log(Args&&... args) {
    store.emplace_back(std::forward<Args>(args)...);
}

C++11

Variadic and Recursion

core language

Recursive function

int fib(int n) {
    return n < 2 ? n : fib(n - 1) + fib(n - 2);
}

core

result

fib(10) = 55

Variadic template with a fold expression

template <typename... Ts>
auto sum(Ts... values) {
    return (values + ...);
}
sum(1, 2, 3, 4);

C++17

result

Print every argument

template <typename... Ts>
void print_all(const Ts&... args) {
    ((std::cout << args << " "), ...);
    std::cout << "\n";
}
print_all(1, "two", 3.0);

C++17

stdout

1 two 3

Count the pack

template <typename... Ts>
constexpr std::size_t arity() { return sizeof...(Ts); }

C++11

Pointers & Memory

Raw pointers, references, ownership and the smart pointers that make leaks avoidable.

Pointers and References

core language

Declare a pointer, take an address, read through it

int value = 42;
int* ptr = &value;
std::cout << *ptr;    // 42
*ptr = 99;            // value is now 99

core

stdout

Always initialize, never leave a pointer wild

int* p = nullptr;
if (p) { use(*p); }   // guard before dereferencing

C++11

const in three positions means three different things

const int* a;         // pointer to const int, cannot write *a
int* const b = &n;    // const pointer, cannot repoint b
const int* const c = &n;  // both

core

References are aliases and cannot be rebound

int n = 5;
int& ref = n;
ref = 10;             // n is now 10
// int& bad;          // error: must be initialized

core

Const reference binds to temporaries too

void log(const std::string& s);
log("literal");       // temporary lives for the call

core

Pointer arithmetic walks an array

int arr[5]{1,2,3,4,5};
int* p = arr;
std::cout << *(p + 2);   // 3
++p;                     // now points at arr[1]

core

stdout

Pointer to pointer

int   n   = 1;
int*  p   = &n;
int** pp  = &p;
**pp = 7;

core

Function that fills an output parameter

bool try_parse(const std::string& in, int* out) {
    if (!out) return false;
    *out = std::stoi(in);
    return true;
}

core

Dynamic Allocation

handle with care

Allocate and free a single object

int* p = new int(42);
delete p;
p = nullptr;

core

Allocate and free an array, note the brackets

int* arr = new int[100];
delete[] arr;

core

Mismatching new with delete[] or new[] with delete is undefined behaviour.

Allocation failure throws by default

try {
    auto* big = new int[1'000'000'000];
} catch (const std::bad_alloc& e) {
    std::cerr << "out of memory\n";
}

core

Non throwing allocation returns nullptr

int* p = new (std::nothrow) int[huge];
if (!p) { recover(); }

core

Construct into memory you already own

#include <new>
alignas(Widget) unsigned char buf[sizeof(Widget)];
Widget* w = new (buf) Widget{};
w->~Widget();   // manual destructor call

core

Prefer containers and smart pointers over raw new

// instead of: int* a = new int[n];
std::vector<int> a(n);
// instead of: Widget* w = new Widget;
auto w = std::make_unique<Widget>();

C++14

Smart Pointers

modern c++

Exclusive ownership, freed automatically

#include <memory>
auto ptr = std::make_unique<Widget>(args...);
ptr->render();

C++14

unique_ptr cannot be copied, only moved

auto a = std::make_unique<int>(5);
// auto b = a;              // error
auto b = std::move(a);      // a is now empty

C++14

Shared ownership with reference counting

auto sp = std::make_shared<Session>();
auto sp2 = sp;                     // count is 2
std::cout << sp.use_count();

C++11

stdout

Break reference cycles with a non owning observer

std::weak_ptr<Node> parent;
if (auto p = parent.lock()) {
    p->notify();
}

C++11

unique_ptr to an array

auto buf = std::make_unique<char[]>(1024);
buf[0] = 'x';

C++14

Custom deleter for C resources

auto closer = [](std::FILE* f) { if (f) std::fclose(f); };
std::unique_ptr<std::FILE, decltype(closer)> file(std::fopen("a.txt", "r"), closer);

C++11

Inspect and manage the held pointer

Widget* raw = ptr.get();   // borrow, do not delete
ptr.reset();               // destroy now
ptr.reset(new Widget);     // replace
Widget* r = ptr.release(); // give up ownership

C++11

Return a smart pointer from a factory

std::unique_ptr<Shape> make_shape(Kind k) {
    if (k == Kind::Circle) return std::make_unique<Circle>();
    return std::make_unique<Square>();
}

C++14

Move Semantics and Ownership

modern c++

Cast to an rvalue so the move constructor is chosen

std::string a = "large payload";
std::string b = std::move(a);
// a is valid but unspecified, treat it as empty

C++11

Rvalue reference parameter takes ownership

void consume(std::vector<int>&& data) {
    storage_ = std::move(data);
}
consume(std::vector<int>{1,2,3});

C++11

Perfect forwarding keeps lvalue or rvalue nature intact

template <typename T>
void wrapper(T&& arg) {
    inner(std::forward<T>(arg));
}

C++11

RAII, the resource is released by the destructor

class FileHandle {
    std::FILE* f_;
public:
    explicit FileHandle(const char* path) : f_(std::fopen(path, "r")) {}
    ~FileHandle() { if (f_) std::fclose(f_); }
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
};

core

Swap two objects cheaply

std::swap(a, b);
vec.swap(other);   // container member swap is O(1)

core

Shrink a vector to fit its contents

std::vector<int> v(1000);
v.resize(10);
v.shrink_to_fit();

C++11

Arrays and Raw Memory

core language

C style array, size fixed at compile time

int arr[5]{1, 2, 3, 4, 5};
std::size_t n = sizeof(arr) / sizeof(arr[0]);

core

result

Prefer std::array, it knows its own size

#include <array>
std::array<int,5> arr{1,2,3,4,5};
arr.size();
arr.at(2);   // bounds checked

C++11

Two dimensional array and its modern equivalent

int grid[3][4]{};
std::array<std::array<int,4>,3> better{};

core

Non owning view over any contiguous range

#include <span>
void sum(std::span<const int> data) {
    std::accumulate(data.begin(), data.end(), 0);
}
sum(vec);      // works
sum(c_array);  // also works

GCC 10 / Clang 7 / MSVC 19.26C++20

Raw byte type that is not a character

#include <cstddef>
std::byte b{0xFF};
b = b & std::byte{0x0F};

C++17

Control alignment

struct alignas(64) CacheLine {
    std::atomic<int> counter;
};
static_assert(alignof(CacheLine) == 64);

C++11

Struct padding is real, member order matters

struct Bad  { char a; int b; char c; };  // often 12 bytes
struct Good { int b; char a; char c; };  // often 8 bytes

core

Order members from largest to smallest to cut padding.

Classes & OOP

Constructors, the rule of five, virtual dispatch and operator overloading.

Class Basics

core language

Class members are private by default, struct members are public

class Account {
    double balance_;      // private
public:
    void deposit(double amount);
};

struct Point {
    int x, y;             // public
};

core

Constructor with a member initializer list

class Rect {
    int w_, h_;
public:
    Rect(int w, int h) : w_(w), h_(h) {}
};

core

Initializer lists construct members directly, the body assigns after default construction.

Delegating constructor

class Rect {
public:
    Rect(int w, int h) : w_(w), h_(h) {}
    Rect() : Rect(1, 1) {}     // reuse the other constructor
};

C++11

Default member initializers

class Config {
    int  retries_ = 3;
    bool verbose_ = false;
    std::string host_{"localhost"};
};

C++11

Block implicit conversion from a single argument

class Meters {
public:
    explicit Meters(double v) : v_(v) {}
};
// Meters m = 5.0;   // error, good
Meters m{5.0};       // fine

core

Destructor cleans up

class Buffer {
    char* data_;
public:
    ~Buffer() { delete[] data_; }
};

core

Const member functions promise not to modify state

class Vec {
public:
    double length() const { return std::sqrt(x_*x_ + y_*y_); }
};

core

Static members belong to the class, not the instance

class Counter {
    static inline int total_ = 0;   // C++17 inline static
public:
    Counter() { ++total_; }
    static int total() { return total_; }
};

C++17

mutable lets one member change inside a const function

class Cache {
    mutable bool dirty_ = true;
public:
    int value() const { dirty_ = false; return v_; }
};

core

this is a pointer to the current object

Rect& scale(int f) {
    w_ *= f; h_ *= f;
    return *this;     // enables chaining
}

core

Copy, Move and the Rule of Five

modern c++

The five special members

class Res {
public:
    Res(const Res&);                 // copy constructor
    Res& operator=(const Res&);      // copy assignment
    Res(Res&&) noexcept;             // move constructor
    Res& operator=(Res&&) noexcept;  // move assignment
    ~Res();                          // destructor
};

C++11

Declare one of these and you usually need all five.

Deep copy constructor

Buffer(const Buffer& other)
    : size_(other.size_), data_(new char[other.size_]) {
    std::copy(other.data_, other.data_ + size_, data_);
}

core

Move constructor steals and blanks the source

Buffer(Buffer&& other) noexcept
    : size_(other.size_), data_(other.data_) {
    other.data_ = nullptr;
    other.size_ = 0;
}

C++11

Copy assignment with self assignment guard

Buffer& operator=(const Buffer& other) {
    if (this == &other) return *this;
    Buffer tmp(other);
    swap(tmp);
    return *this;
}

core

Ask for the compiler generated version

class Value {
public:
    Value() = default;
    Value(const Value&) = default;
    Value& operator=(const Value&) = default;
};

C++11

Forbid copying entirely

class Unique {
public:
    Unique(const Unique&) = delete;
    Unique& operator=(const Unique&) = delete;
};

C++11

Rule of zero, own nothing raw and write none of them

class Session {
    std::string id_;
    std::vector<Event> log_;
    std::unique_ptr<Socket> sock_;
    // no special members needed at all
};

C++11

Inheritance and Polymorphism

core language

Public inheritance models an is a relationship

class Animal {
public:
    virtual ~Animal() = default;
    virtual void speak() const = 0;
};

class Dog : public Animal {
public:
    void speak() const override { std::cout << "Woof\n"; }
};

core

Virtual functions dispatch on the runtime type

std::unique_ptr<Animal> a = std::make_unique<Dog>();
a->speak();   // Woof

core

result

Woof

override catches signature mistakes at compile time

void speak() const override;   // error if the base has no matching virtual

core

final stops further overriding or derivation

class Cat final : public Animal {
    void speak() const final { }
};

C++11

Pure virtual makes the class abstract

class Shape {
public:
    virtual double area() const = 0;   // no default implementation
    virtual ~Shape() = default;
};

core

A base with virtual functions needs a virtual destructor

class Base {
public:
    virtual ~Base() = default;   // otherwise deleting through Base* leaks
};

core

Deleting a derived object through a base pointer without a virtual destructor is undefined behaviour.

Call the base constructor and base implementation

class Derived : public Base {
public:
    Derived(int n) : Base(n) {}
    void draw() const override {
        Base::draw();
        extra();
    }
};

core

Protected members are visible to derived classes

class Base {
protected:
    int shared_state_;
};

core

Virtual inheritance solves the diamond problem

class Stream { };
class Input  : virtual public Stream { };
class Output : virtual public Stream { };
class IO     : public Input, public Output { };   // one Stream subobject

core

Check the dynamic type safely

if (auto* d = dynamic_cast<Dog*>(animal_ptr)) {
    d->fetch();
}

core

Operator Overloading

core language

Arithmetic operator as a free function

Vec2 operator+(const Vec2& a, const Vec2& b) {
    return Vec2{a.x + b.x, a.y + b.y};
}

core

Stream insertion must be a free function

std::ostream& operator<<(std::ostream& os, const Vec2& v) {
    return os << "(" << v.x << ", " << v.y << ")";
}
std::cout << Vec2{1,2};

core

stdout

(1, 2)

Subscript in const and non const flavours

int&       operator[](std::size_t i)       { return data_[i]; }
const int& operator[](std::size_t i) const { return data_[i]; }

core

Default equality generates == and !=

struct Point {
    int x, y;
    bool operator==(const Point&) const = default;
};

C++20

Default spaceship generates all ordering operators

struct Version {
    int major, minor, patch;
    auto operator<=>(const Version&) const = default;
};
Version{1,2,0} < Version{1,3,0};   // true

GCC 10 / Clang 10 / MSVC 19.28C++20

result

true

Compound assignment returns a reference

Vec2& operator+=(const Vec2& rhs) {
    x += rhs.x; y += rhs.y;
    return *this;
}

core

Prefix and postfix increment

Iter& operator++()    { ++pos_; return *this; }        // prefix
Iter  operator++(int) { Iter t = *this; ++pos_; return t; }  // postfix

core

Call operator turns the object into a callable

struct Adder {
    int base;
    int operator()(int x) const { return base + x; }
};

core

Conversion operator, mark it explicit for bool

class Handle {
public:
    explicit operator bool() const { return fd_ >= 0; }
};
if (handle) { }

core

friend grants access to private members

class Money {
    long cents_;
    friend std::ostream& operator<<(std::ostream&, const Money&);
};

core

Enums, Unions and Aggregates

core language

Scoped enum, no implicit conversion to int

enum class Color { Red, Green, Blue };
Color c = Color::Red;
// int n = c;   // error, good
int n = static_cast<int>(c);

C++11

Choose the underlying type

enum class Status : std::uint8_t { Ok = 0, Warn = 1, Fail = 2 };

C++11

Old style unscoped enum leaks its names

enum Level { Low, Mid, High };   // Low is now a global name

core

Aggregate initialization

struct Config { std::string host; int port; bool tls; };
Config c{"localhost", 8080, true};

core

Designated initializers name the fields

Config c{.host = "localhost", .port = 8080, .tls = true};

C++20

Union stores one member at a time

union Value {
    int    i;
    float  f;
    char   bytes[4];
};

core

Prefer variant, it remembers which member is active

#include <variant>
std::variant<int, std::string> v = 42;
v = "now a string";
std::cout << std::get<std::string>(v);

C++17

Nested class

class Tree {
    struct Node {
        int value;
        Node* left;
        Node* right;
    };
};

core

Compile time assertion

static_assert(sizeof(void*) == 8, "64 bit build required");

C++11

STL Containers

Every container, what it costs, and the utility types that ride along with them.

Sequence Containers

standard library

Dynamic array, the default choice

std::vector<int> v{1, 2, 3};

index O(1)C++11

Add and remove at the back

v.push_back(4);
v.emplace_back(5);      // constructs in place
v.pop_back();

amortized O(1)C++11

Access elements

v[0];          // no bounds check
v.at(0);       // throws std::out_of_range
v.front(); v.back();
v.data();      // raw pointer to the buffer

O(1)core

Size, capacity and reserving ahead

v.size();
v.capacity();
v.reserve(1000);   // one allocation instead of many
v.empty();
v.clear();

reserve O(n)core

Insert and erase at a position

v.insert(v.begin() + 2, 99);
v.erase(v.begin() + 2);
v.erase(v.begin() + 1, v.begin() + 3);

O(n)core

Fixed size array with no heap allocation

std::array<double,3> a{1.0, 2.0, 3.0};
a.size();   // always 3

index O(1)C++11

Double ended queue, fast push at both ends

std::deque<int> d;
d.push_front(1);
d.push_back(2);

push both ends O(1)core

Doubly linked list, stable references, no random access

std::list<int> l{1,2,3};
l.push_front(0);
l.splice(l.end(), other);

insert O(1)core

Singly linked list, the leanest node container

std::forward_list<int> fl{1,2,3};
fl.push_front(0);

insert front O(1)C++11

Associative Containers

standard library

Sorted key to value map

std::map<std::string,int> ages{{"Ada", 36}};
ages["Alan"] = 41;

O(log n)core

Hash map, average constant time lookup

std::unordered_map<std::string,int> counts;
++counts["word"];

avg O(1)C++11

Look up without inserting

if (auto it = m.find(key); it != m.end()) {
    use(it->second);
}
if (m.contains(key)) { }   // C++20

O(log n)C++17

operator[] inserts a default value when the key is missing

int n = m["missing"];   // creates the entry with value 0

core

Use find or at when you do not want insertion.

Insert without overwriting, and insert or assign

m.insert({key, value});
m.emplace(key, value);
m.try_emplace(key, value);        // C++17, no temp built on collision
m.insert_or_assign(key, value);   // C++17

C++17

Sorted unique keys

std::set<int> s{3, 1, 2};
s.insert(4);
s.erase(1);
s.count(2);

O(log n)core

Hash set

std::unordered_set<std::string> seen;
auto [it, inserted] = seen.insert("token");

avg O(1)C++11

Allow duplicate keys

std::multimap<std::string,int> log;
std::multiset<int> samples;
auto range = log.equal_range("error");

O(log n)core

Custom comparator changes the ordering

std::set<int, std::greater<int>> desc{1,2,3};   // 3 2 1

core

Custom hash for your own key type

struct PointHash {
    std::size_t operator()(const Point& p) const noexcept {
        return std::hash<int>{}(p.x) ^ (std::hash<int>{}(p.y) << 1);
    }
};
std::unordered_set<Point, PointHash> pts;

C++11

Container Adaptors

standard library

Last in first out

std::stack<int> st;
st.push(1);
st.top();
st.pop();

O(1)core

First in first out

std::queue<int> q;
q.push(1);
q.front();
q.pop();

O(1)core

Max heap by default

std::priority_queue<int> pq;
pq.push(5); pq.push(1);
pq.top();   // 5

push O(log n)core

Min heap

std::priority_queue<int, std::vector<int>, std::greater<int>> minpq;

push O(log n)core

Heap of pairs sorted by first element

using Task = std::pair<int, std::string>;
std::priority_queue<Task, std::vector<Task>, std::greater<>> tasks;
tasks.push({1, "urgent"});

C++14

Strings

standard library

Create and grow a string

std::string s = "hello";
s += " world";
s.append("!");
s.push_back('?');

core

Length, access and emptiness

s.size(); s.length();
s[0]; s.at(0);
s.front(); s.back();
s.empty();

O(1)core

Substring and find

std::string sub = s.substr(6, 5);
std::size_t pos = s.find("world");
if (pos != std::string::npos) { }

find O(n*m)core

Replace, insert and erase

s.replace(0, 5, "howdy");
s.insert(0, ">> ");
s.erase(0, 3);

core

Compare and check edges

s == other;
s.compare(other);
s.starts_with("he");   // C++20
s.ends_with("ld");     // C++20

C++20

Split on a delimiter

std::vector<std::string> parts;
std::stringstream ss(csv);
for (std::string field; std::getline(ss, field, ','); )
    parts.push_back(field);

core

Trim whitespace

s.erase(0, s.find_first_not_of(" \t\n"));
s.erase(s.find_last_not_of(" \t\n") + 1);

core

Non owning view, no allocation, no copy

#include <string_view>
void log(std::string_view msg);   // accepts string and const char*
log("literal");
log(std_string);

C++17

Never store a string_view that outlives the buffer it points at.

Case conversion

#include <algorithm>
#include <cctype>
std::transform(s.begin(), s.end(), s.begin(),
               [](unsigned char c){ return std::tolower(c); });

core

Repeat and fill

std::string line(40, '-');
std::string pad(4, ' ');

core

result

----------------------------------------

Utility Types

standard library

Two values in one object

std::pair<int,std::string> p{1, "one"};
p.first; p.second;
auto q = std::make_pair(2, "two");

core

Any number of values

std::tuple<int,std::string,double> t{1, "a", 2.5};
std::get<0>(t);
std::get<std::string>(t);   // C++14, by type

C++11

Unpack into named variables

auto [id, name, score] = t;
auto [it, inserted] = my_map.insert({k, v});

C++17

A value that may be absent

#include <optional>
std::optional<int> find_age(const std::string& name);
if (auto age = find_age("Ada")) {
    std::cout << *age;
}
int a = age.value_or(0);

C++17

One of several types, type safe union

std::variant<int,std::string,double> v = 3.14;
std::visit([](auto&& x){ std::cout << x; }, v);
if (std::holds_alternative<double>(v)) { }

C++17

Any single copyable value

#include <any>
std::any a = 42;
a = std::string{"text"};
auto s = std::any_cast<std::string>(a);

C++17

Reference wrapper lets you store references in containers

std::vector<std::reference_wrapper<Widget>> refs;
refs.push_back(std::ref(w));

C++11

Bitset for compact flag storage

#include <bitset>
std::bitset<8> flags{0b1010'1010};
flags.set(0);
flags.test(3);
flags.count();

core

Fixed point in time and durations

#include <chrono>
using namespace std::chrono;
auto start = steady_clock::now();
auto ms = duration_cast<milliseconds>(steady_clock::now() - start);

C++11

Algorithms & Iterators

The header that replaces most hand written loops, plus ranges.

Sorting and Ordering

standard library

Sort ascending

std::sort(v.begin(), v.end());

O(n log n)core

Sort with a custom comparator

std::sort(v.begin(), v.end(),
          [](const Item& a, const Item& b){ return a.score > b.score; });

O(n log n)C++11

Keep equal elements in their original order

std::stable_sort(v.begin(), v.end());

O(n log n)core

Sort only the first k elements

std::partial_sort(v.begin(), v.begin() + 10, v.end());

O(n log k)core

Place the nth element as if fully sorted

std::nth_element(v.begin(), v.begin() + n/2, v.end());
int median = v[n/2];

avg O(n)core

Reverse and rotate

std::reverse(v.begin(), v.end());
std::rotate(v.begin(), v.begin() + 3, v.end());

O(n)core

Split by a predicate

auto mid = std::partition(v.begin(), v.end(),
                          [](int x){ return x % 2 == 0; });

O(n)core

Check sortedness

bool ok = std::is_sorted(v.begin(), v.end());

O(n)C++11

Shuffle with a real generator

#include <random>
std::mt19937 gen{std::random_device{}()};
std::shuffle(v.begin(), v.end(), gen);

O(n)C++11

Searching and Counting

standard library

Linear search for a value

auto it = std::find(v.begin(), v.end(), 42);
if (it != v.end()) { }

O(n)core

Search with a predicate

auto it = std::find_if(v.begin(), v.end(),
                       [](int x){ return x > 100; });

O(n)core

Binary search on a sorted range

bool found = std::binary_search(v.begin(), v.end(), 42);

O(log n)core

First position not less than the value

auto lo = std::lower_bound(v.begin(), v.end(), 42);
auto hi = std::upper_bound(v.begin(), v.end(), 42);
auto [a, b] = std::equal_range(v.begin(), v.end(), 42);

O(log n)core

Count matches

int n  = std::count(v.begin(), v.end(), 42);
int m  = std::count_if(v.begin(), v.end(), [](int x){ return x < 0; });

O(n)core

Quantifiers over a range

std::all_of(v.begin(), v.end(),  [](int x){ return x > 0; });
std::any_of(v.begin(), v.end(),  [](int x){ return x == 0; });
std::none_of(v.begin(), v.end(), [](int x){ return x < 0; });

O(n)C++11

Smallest, largest and both at once

auto lo = std::min_element(v.begin(), v.end());
auto hi = std::max_element(v.begin(), v.end());
auto [a, b] = std::minmax_element(v.begin(), v.end());

O(n)C++11

Find a subsequence

auto it = std::search(hay.begin(), hay.end(), needle.begin(), needle.end());

O(n*m)core

Compare two ranges

bool same = std::equal(a.begin(), a.end(), b.begin(), b.end());

O(n)core

Modifying and Numeric

standard library

Copy a range

std::copy(src.begin(), src.end(), dst.begin());
std::copy_if(src.begin(), src.end(), std::back_inserter(dst),
             [](int x){ return x > 0; });

O(n)core

Apply a function to every element

std::transform(v.begin(), v.end(), out.begin(),
               [](int x){ return x * x; });

O(n)core

Combine two ranges element by element

std::transform(a.begin(), a.end(), b.begin(), out.begin(), std::plus<>{});

O(n)core

Fill and generate

std::fill(v.begin(), v.end(), 0);
std::generate(v.begin(), v.end(), [n = 0]() mutable { return n++; });

O(n)core

Sequential numbers

#include <numeric>
std::vector<int> v(10);
std::iota(v.begin(), v.end(), 1);   // 1..10

O(n)C++11

result

1 2 3 4 5 6 7 8 9 10

Remove and erase, the classic two step idiom

v.erase(std::remove(v.begin(), v.end(), 0), v.end());
v.erase(std::remove_if(v.begin(), v.end(),
        [](int x){ return x < 0; }), v.end());

O(n)core

std::remove only shifts elements, it never changes the container size.

One call erase

std::erase(v, 0);
std::erase_if(v, [](int x){ return x < 0; });

O(n)C++20

Drop consecutive duplicates, sort first for global uniqueness

std::sort(v.begin(), v.end());
v.erase(std::unique(v.begin(), v.end()), v.end());

O(n log n)core

Sum and fold

int total = std::accumulate(v.begin(), v.end(), 0);
std::string joined = std::accumulate(words.begin(), words.end(), std::string{});

O(n)core

Dot product and adjacent differences

int dot = std::inner_product(a.begin(), a.end(), b.begin(), 0);
std::adjacent_difference(v.begin(), v.end(), out.begin());
std::partial_sum(v.begin(), v.end(), out.begin());

O(n)core

Run an algorithm in parallel

#include <execution>
std::sort(std::execution::par, v.begin(), v.end());
std::transform(std::execution::par_unseq, v.begin(), v.end(), out.begin(), f);

C++17

Iterators

core language

Begin and end of any container

auto first = v.begin();
auto last  = v.end();      // one past the last element

core

Const and reverse iterators

v.cbegin(); v.cend();      // read only
v.rbegin(); v.rend();      // backwards
v.crbegin(); v.crend();

core

Free functions work on C arrays too

int arr[5]{};
std::sort(std::begin(arr), std::end(arr));

C++11

Manual iterator loop

for (auto it = v.begin(); it != v.end(); ++it) {
    std::cout << *it << " ";
}

core

Move an iterator

std::advance(it, 5);
auto n = std::next(it, 2);
auto p = std::prev(it);
auto d = std::distance(v.begin(), it);

C++11

Insert iterators turn copies into insertions

std::copy(src.begin(), src.end(), std::back_inserter(dst));
std::copy(src.begin(), src.end(), std::inserter(my_set, my_set.begin()));

core

Stream iterators

std::vector<int> nums{std::istream_iterator<int>{std::cin},
                      std::istream_iterator<int>{}};
std::copy(nums.begin(), nums.end(),
          std::ostream_iterator<int>{std::cout, " "});

core

Move iterator steals instead of copying

std::vector<std::string> dst(std::make_move_iterator(src.begin()),
                             std::make_move_iterator(src.end()));

C++11

Erasing invalidates iterators, use the return value

for (auto it = v.begin(); it != v.end(); ) {
    if (*it < 0) it = v.erase(it);
    else         ++it;
}

core

Incrementing an iterator you just erased is undefined behaviour.

Ranges

modern c++

Algorithms that take the container directly

#include <algorithm>
#include <ranges>
std::ranges::sort(v);
auto it = std::ranges::find(v, 42);

GCC 10 / Clang 15 / MSVC 19.29C++20

Sort by a member with a projection

std::ranges::sort(people, {}, &Person::age);

GCC 10 / Clang 15 / MSVC 19.29C++20

Filter and transform lazily

namespace rv = std::views;
auto result = v | rv::filter([](int x){ return x % 2 == 0; })
                | rv::transform([](int x){ return x * x; });
for (int x : result) std::cout << x << " ";

GCC 10 / Clang 15 / MSVC 19.29C++20

Take, drop and reverse

auto first5 = v | rv::take(5);
auto rest   = v | rv::drop(5);
auto backwards = v | rv::reverse;

GCC 10 / Clang 15 / MSVC 19.29C++20

Generate a lazy sequence

for (int i : rv::iota(1, 6)) std::cout << i << " ";

GCC 10 / Clang 15 / MSVC 19.29C++20

stdout

1 2 3 4 5

Split and join

auto words = text | rv::split(' ');
auto flat  = nested | rv::join;

GCC 10 / Clang 15 / MSVC 19.29C++20

Index and element together

for (auto [i, value] : v | rv::enumerate) {
    std::cout << i << ": " << value << "\n";
}

GCC 10 / Clang 15 / MSVC 19.29C++23

Materialize a view into a container

auto evens = v | rv::filter([](int x){ return x % 2 == 0; })
                | std::ranges::to<std::vector>();

GCC 14 / Clang 17 / MSVC 19.34C++23

Walk pairs of adjacent elements

for (auto [a, b] : v | rv::adjacent<2>) {
    std::cout << b - a << " ";
}

GCC 10 / Clang 15 / MSVC 19.29C++23

Text & Numbers

Format specs, regular expressions, randomness, dates and maths. The headers people reach for once and then look up forever.

Format Specification

modern c++

The whole grammar in one line

// {[index]:[[fill]align][sign][#][0][width][.precision][L][type]}
std::format("{:*>+10.3f}", 3.14159);

GCC 13 / Clang 17 / MSVC 19.29C++20

result

    +3.142

Positional and repeated arguments

std::format("{0} {1} {0}", "a", "b");

GCC 13 / Clang 17 / MSVC 19.29C++20

result

a b a

Align left, right and centre

std::format("[{:<8}]", "ab");
std::format("[{:>8}]", "ab");
std::format("[{:^8}]", "ab");

GCC 13 / Clang 17 / MSVC 19.29C++20

result

[ab      ]
[      ab]
[   ab   ]

Fill character goes before the alignment

std::format("{:.^11}", "mid");

GCC 13 / Clang 17 / MSVC 19.29C++20

result

....mid....

Width and precision from arguments

std::format("{:{}.{}f}", 3.14159, 10, 2);

GCC 13 / Clang 17 / MSVC 19.29C++20

result

      3.14

Number bases and the alternate form

std::format("{:b} {:o} {:x} {:X}", 42, 42, 255, 255);
std::format("{:#b} {:#x}", 5, 255);

GCC 13 / Clang 17 / MSVC 19.29C++20

result

101010 52 ff FF
0b101 0xff

Floating point presentations

std::format("{:f} {:e} {:g} {:a}", 1.5, 1.5, 1.5, 1.5);

GCC 13 / Clang 17 / MSVC 19.29C++20

result

1.500000 1.500000e+00 1.5 0x1.8p+0

Zero padding and explicit sign

std::format("{:08.2f}", 3.5);
std::format("{:+d} {: d}", 7, 7);

GCC 13 / Clang 17 / MSVC 19.29C++20

result

00003.50
+7  7

Escape a literal brace

std::format("{{{}}}", 42);

GCC 13 / Clang 17 / MSVC 19.29C++20

result

{42}

Format into an existing buffer

std::string out;
std::format_to(std::back_inserter(out), "{}-{}", 1, 2);
auto n = std::formatted_size("{}-{}", 1, 2);

GCC 13 / Clang 17 / MSVC 19.29C++20

Runtime format strings must be wrapped

std::string fmt = load_from_config();
std::vformat(fmt, std::make_format_args(value));

GCC 13 / Clang 17 / MSVC 19.29C++20

std::format checks the string at compile time, so a runtime string needs vformat.

Teach format about your own type

template <>
struct std::formatter<Point> : std::formatter<std::string> {
    auto format(const Point& p, auto& ctx) const {
        return std::formatter<std::string>::format(
            std::format("({}, {})", p.x, p.y), ctx);
    }
};
std::format("{}", Point{1,2});

GCC 13 / Clang 17 / MSVC 19.29C++20

result

(1, 2)

Regular Expressions

standard library

Build a regex, escape backslashes with a raw string

#include <regex>
std::regex re(R"(\d{4}-\d{2}-\d{2})");

core

Does the whole string match

bool ok = std::regex_match("2026-08-14", re);

core

result

true

Is there a match anywhere in the string

bool found = std::regex_search(text, re);

core

Capture groups

std::smatch m;
if (std::regex_search(text, m, re)) {
    m[0];        // whole match
    m[1];        // first group
    m.position(1);
    m.str(1);
}

core

Iterate every match

auto begin = std::sregex_iterator(text.begin(), text.end(), re);
auto end   = std::sregex_iterator();
for (auto it = begin; it != end; ++it)
    std::cout << it->str() << "\n";

core

Replace with a backreference

std::string out = std::regex_replace(text, std::regex("(\\w+)@(\\w+)"), "$2 at $1");

core

Split on a separator using a token iterator

std::regex sep(R"(\s*,\s*)");
std::sregex_token_iterator it(s.begin(), s.end(), sep, -1);
std::vector<std::string> parts(it, std::sregex_token_iterator());

core

Case insensitive and other flags

std::regex re("hello", std::regex::icase);
std::regex ecma("a+", std::regex::ECMAScript);   // default
std::regex posix("a+", std::regex::extended);
std::regex fast("a+", std::regex::optimize);

core

Common patterns worth keeping

R"(^\w+([.-]?\w+)*@\w+([.-]?\w+)*\.\w{2,}$)"   // email
R"(^\+?[0-9\s\-()]{7,}$)"                        // loose phone
R"(^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$)"         // hex colour
R"(^\d{1,3}(\.\d{1,3}){3}$)"                     // IPv4 shape

core

std::regex is slow, know when to skip it

if (s.starts_with("http://")) { }        // far faster than a regex
if (s.find(',') != std::string::npos) { }

C++20

std::regex compiles at runtime and is known to be slow. For hot paths use plain string operations or a dedicated library.

Randomness

standard library

Seed a generator once, reuse it

#include <random>
std::mt19937 gen{std::random_device{}()};

C++11

Deterministic seed for reproducible tests

std::mt19937 gen{12345};

C++11

Integer in an inclusive range

std::uniform_int_distribution<int> dice{1, 6};
int roll = dice(gen);

C++11

Real number in a half open range

std::uniform_real_distribution<double> unit{0.0, 1.0};
double x = unit(gen);

C++11

Other distributions

std::normal_distribution<double>    bell{0.0, 1.0};
std::bernoulli_distribution        coin{0.5};
std::poisson_distribution<int>     events{4.0};
std::discrete_distribution<int>    weighted{{10, 30, 60}};

C++11

Pick a random element

std::uniform_int_distribution<std::size_t> pick{0, v.size() - 1};
auto& item = v[pick(gen)];

C++11

Shuffle a container

std::shuffle(v.begin(), v.end(), gen);

C++11

Sample without replacement

std::vector<int> out;
std::sample(v.begin(), v.end(), std::back_inserter(out), 5, gen);

C++17

Never use rand() in new code

// int r = rand() % 6 + 1;   // biased, poor quality, not thread safe

core

rand() has a small period and modulo introduces bias. The random header exists for a reason.

Dates and Durations

modern c++

Measure elapsed time

#include <chrono>
using namespace std::chrono;
auto t0 = steady_clock::now();
work();
auto ms = duration_cast<milliseconds>(steady_clock::now() - t0).count();

C++11

Duration literals read cleanly

using namespace std::chrono_literals;
auto timeout = 250ms;
auto hour    = 1h;
auto total   = 1h + 30min;

C++14

Convert between durations

auto secs = duration_cast<seconds>(1500ms);      // 1, truncates
duration<double> exact = 1500ms;                 // 1.5

C++11

Wall clock time

auto now = system_clock::now();
std::time_t t = system_clock::to_time_t(now);

C++11

Calendar types

auto today = year_month_day{floor<days>(system_clock::now())};
auto d = 2026y/August/14;
int  y = int(d.year());
bool leap = d.year().is_leap();

C++20

Format a time point

std::cout << std::format("{:%Y-%m-%d %H:%M:%S}", system_clock::now());

GCC 13 / Clang 17 / MSVC 19.29C++20

Time zones

auto zt = zoned_time{"Europe/Bucharest", system_clock::now()};
std::cout << std::format("{:%Z %H:%M}", zt);

newest of the new, check your libraryC++20

Sleep for a duration

std::this_thread::sleep_for(250ms);
std::this_thread::sleep_until(deadline);

C++11

A reusable scoped timer

struct Timer {
    std::chrono::steady_clock::time_point t0{std::chrono::steady_clock::now()};
    ~Timer() {
        auto us = std::chrono::duration_cast<std::chrono::microseconds>(
            std::chrono::steady_clock::now() - t0).count();
        std::cout << us << " us\n";
    }
};

C++11

Maths and Numerics

standard library

Common functions

#include <cmath>
std::abs(-3);      std::pow(2, 10);
std::sqrt(16.0);   std::cbrt(27.0);
std::floor(2.7);   std::ceil(2.1);   std::round(2.5);
std::log(x);       std::log2(x);     std::exp(x);

core

Clamp, min and max

std::min(a, b);
std::max(a, b);
std::clamp(value, low, high);

C++17

Midpoint without overflow

#include <numeric>
int m = std::midpoint(a, b);
double l = std::lerp(start, end, 0.25);

C++20

Greatest common divisor and least common multiple

std::gcd(12, 18);
std::lcm(4, 6);

C++17

result

6
12

Safe comparison across signedness

#include <utility>
std::cmp_less(-1, 1u);        // true, unlike -1 < 1u
std::cmp_greater_equal(a, b);
std::in_range<int>(big_value);

C++20

Overflow aware arithmetic

if (a > std::numeric_limits<int>::max() - b) { /* would overflow */ }

// or use a builtin where available
int r;
if (__builtin_add_overflow(a, b, &r)) { /* overflowed */ }

core

Floating point checks

std::isnan(x);
std::isinf(x);
std::isfinite(x);
std::numeric_limits<double>::epsilon();

core

Mathematical constants

#include <numbers>
std::numbers::pi;
std::numbers::e;
std::numbers::sqrt2;
std::numbers::phi;

C++20

Complex numbers

#include <complex>
std::complex<double> z{1.0, 2.0};
std::abs(z); std::arg(z); std::conj(z);

core

Library Header Map

notes

Input and output

<iostream>    cin, cout, cerr
<fstream>     ifstream, ofstream, fstream
<sstream>     istringstream, ostringstream
<iomanip>     setw, setprecision, fixed
<format>      format, format_to      (C++20)
<print>       print, println          (C++23)
<filesystem>  path, directory_iterator (C++17)

core

Containers

<vector> <array> <deque> <list> <forward_list>
<map> <set> <unordered_map> <unordered_set>
<stack> <queue> <bitset>
<span>        span                    (C++20)
<mdspan>      mdspan                  (C++23)
<flat_map>    flat_map, flat_set      (C++23)

core

Algorithms and iteration

<algorithm>   sort, find, transform, copy
<numeric>     accumulate, iota, gcd, midpoint
<iterator>    back_inserter, next, distance
<ranges>      views, ranges::sort     (C++20)
<execution>   execution::par          (C++17)

core

Strings and text

<string>      string, stoi, to_string
<string_view> string_view            (C++17)
<charconv>    from_chars, to_chars    (C++17)
<regex>       regex, smatch
<cctype>      isdigit, tolower

core

Memory and utilities

<memory>      unique_ptr, shared_ptr, make_unique
<utility>     move, forward, pair, swap, cmp_less
<tuple>       tuple, tie, apply
<optional>    optional                (C++17)
<variant>     variant, visit          (C++17)
<any>         any                     (C++17)
<expected>    expected                (C++23)
<functional>  function, bind, hash, greater

core

Types, traits and numbers

<type_traits> is_same, decay, enable_if
<concepts>    integral, same_as       (C++20)
<limits>      numeric_limits
<cstdint>     int32_t, uint64_t
<cmath>       sqrt, pow, floor
<numbers>     pi, e                   (C++20)
<bit>         bit_cast, popcount      (C++20)
<random>      mt19937, distributions

core

Concurrency and time

<thread>      thread, jthread, this_thread
<mutex>       mutex, lock_guard, scoped_lock
<shared_mutex> shared_mutex           (C++17)
<atomic>      atomic, atomic_flag
<future>      async, future, promise
<condition_variable>  condition_variable
<semaphore> <latch> <barrier>         (C++20)
<chrono>      duration, steady_clock

core

Errors and diagnostics

<stdexcept>   runtime_error, out_of_range
<exception>   exception, terminate
<system_error> error_code
<cassert>     assert
<stacktrace>  stacktrace              (C++23)
<source_location> source_location     (C++20)

core

Templates

Generic code, constraints and the type traits that drive compile time decisions.

Function and Class Templates

core language

Generic function

template <typename T>
T max_of(T a, T b) {
    return a > b ? a : b;
}
max_of(3, 7);
max_of(2.5, 1.5);

core

Several type parameters

template <typename K, typename V>
void insert(std::map<K,V>& m, K key, V value) {
    m.emplace(std::move(key), std::move(value));
}

core

Non type template parameter

template <typename T, std::size_t N>
class FixedBuffer {
    T data_[N];
public:
    constexpr std::size_t size() const { return N; }
};
FixedBuffer<int, 16> buf;

core

Class template

template <typename T>
class Stack {
    std::vector<T> items_;
public:
    void push(T v) { items_.push_back(std::move(v)); }
    T pop() { T v = items_.back(); items_.pop_back(); return v; }
};
Stack<int> s;

core

Class template argument deduction, the angle brackets vanish

std::vector v{1, 2, 3};          // std::vector<int>
std::pair p{1, "one"};           // std::pair<int, const char*>
std::lock_guard lock{mutex_};

C++17

Default template argument

template <typename T, typename Alloc = std::allocator<T>>
class MyVector { };

core

Explicit specialization for one type

template <typename T>
std::string name() { return "unknown"; }

template <>
std::string name<int>() { return "int"; }

core

Partial specialization for a family of types

template <typename T>
struct Traits { static constexpr bool is_pointer = false; };

template <typename T>
struct Traits<T*> { static constexpr bool is_pointer = true; };

core

Member function template

class Logger {
public:
    template <typename T>
    void log(const T& value) { std::cout << value << "\n"; }
};

core

typename tells the compiler a dependent name is a type

template <typename C>
void f(const C& c) {
    typename C::value_type first = *c.begin();
}

core

Variadic Templates

modern c++

Accept any number of arguments

template <typename... Args>
void log(Args&&... args) {
    (std::cout << ... << args) << "\n";
}
log("x=", 1, " y=", 2);

C++17

stdout

x=1 y=2

Fold expressions in four directions

(args + ...);        // unary right fold
(... + args);        // unary left fold
(init + ... + args); // binary left fold
(args + ... + init); // binary right fold

C++17

Fold with a logical operator

template <typename... Ts>
bool all_positive(Ts... vs) { return ((vs > 0) && ...); }

C++17

result

true

Pack size

template <typename... Ts>
void f(Ts... args) {
    static_assert(sizeof...(Ts) > 0, "need at least one argument");
}

C++11

Recursive pack expansion, the pre C++17 approach

void print() { std::cout << "\n"; }

template <typename T, typename... Rest>
void print(T first, Rest... rest) {
    std::cout << first << " ";
    print(rest...);
}

C++11

Forward a whole pack

template <typename T, typename... Args>
std::unique_ptr<T> make(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

C++11

Concepts and Constraints

modern c++

Define a concept

#include <concepts>
template <typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

GCC 10 / Clang 10 / MSVC 19.28C++20

Constrain a template three equivalent ways

template <Numeric T>          T twice(T v) { return v * 2; }
template <typename T> requires Numeric<T>
                              T thrice(T v) { return v * 3; }
auto quad(Numeric auto v) { return v * 4; }

C++20

requires expression checks valid syntax

template <typename T>
concept Printable = requires(T v) {
    { std::cout << v } -> std::same_as<std::ostream&>;
};

GCC 10 / Clang 10 / MSVC 19.28C++20

Require member functions

template <typename T>
concept Container = requires(T c) {
    c.begin();
    c.end();
    typename T::value_type;
    { c.size() } -> std::convertible_to<std::size_t>;
};

GCC 10 / Clang 10 / MSVC 19.28C++20

Standard concepts you get for free

std::integral<T>
std::floating_point<T>
std::same_as<T, U>
std::convertible_to<From, To>
std::derived_from<D, B>
std::invocable<F, Args...>
std::ranges::range<R>

GCC 10 / Clang 10 / MSVC 19.28C++20

Pre concepts constraint with enable_if

template <typename T,
          typename = std::enable_if_t<std::is_integral_v<T>>>
T half(T v) { return v / 2; }

C++11

Constrain a class template

template <std::totally_ordered T>
class SortedList { };

GCC 10 / Clang 10 / MSVC 19.28C++20

Type Traits and Metaprogramming

modern c++

Ask questions about a type

#include <type_traits>
std::is_integral_v<T>
std::is_pointer_v<T>
std::is_same_v<T, int>
std::is_base_of_v<Base, T>
std::is_const_v<T>

C++17

Transform a type

std::remove_reference_t<T>
std::remove_cv_t<T>
std::decay_t<T>
std::add_pointer_t<T>
std::underlying_type_t<E>

C++14

Pick a type at compile time

using Chosen = std::conditional_t<sizeof(void*) == 8, std::int64_t, std::int32_t>;

C++14

Deduce the type of an expression

int a = 1; double b = 2.0;
decltype(a + b) sum = a + b;   // double
decltype(auto) f() { return (a); }   // int&, C++14

C++11

Pretend to have a value of a type in unevaluated context

template <typename T>
using ResultOf = decltype(std::declval<T>().compute());

C++11

Type alias, clearer than typedef

using Callback = std::function<void(int)>;
template <typename T>
using Ptr = std::unique_ptr<T>;

C++11

Curiously recurring template pattern for static polymorphism

template <typename Derived>
struct Shape {
    double area() const {
        return static_cast<const Derived*>(this)->area_impl();
    }
};
struct Circle : Shape<Circle> {
    double area_impl() const { return 3.14159 * r * r; }
    double r;
};

core

Compile time branching inside one function

template <typename T>
auto describe(T v) {
    if constexpr (std::is_integral_v<T>) return "integer";
    else if constexpr (std::is_floating_point_v<T>) return "real";
    else return "other";
}

C++17

Overload set from lambdas for variant visiting

template <class... Ts> struct overload : Ts... { using Ts::operator()...; };
template <class... Ts> overload(Ts...) -> overload<Ts...>;

std::visit(overload{
    [](int i)                { std::cout << "int " << i; },
    [](const std::string& s) { std::cout << "str " << s; }
}, my_variant);

C++17

Modern C++

What each standard added, so you know what you can reach for on a given toolchain.

C++11 and C++14

modern c++

auto, range for and nullptr

auto v = std::vector<int>{1,2,3};
for (auto& x : v) x *= 2;
int* p = nullptr;

C++11

Lambdas and move semantics

auto f = [](int x){ return x + 1; };
auto moved = std::move(source);

C++11

Smart pointers replace owning raw pointers

auto a = std::unique_ptr<Widget>(new Widget);   // C++11
auto b = std::make_unique<Widget>();            // C++14

C++14

Scoped enums, override and final

enum class Mode { Fast, Safe };
void run() override;
class Leaf final { };

C++11

Uniform initialization and initializer lists

std::vector<int> v{1,2,3};
Widget w{1, "a", true};

C++11

Threads land in the standard library

#include <thread>
std::thread t{worker};
t.join();

C++11

Generic lambdas and binary literals

auto add = [](auto a, auto b){ return a + b; };
int mask = 0b1100'0011;

C++14

Deduced return types and variable templates

auto square(int n) { return n * n; }
template <typename T> constexpr T pi_v = T(3.1415926535);

C++14

C++17

modern c++

Structured bindings

auto [key, value] = *m.begin();
auto [ok, msg] = validate(input);

C++17

if and switch with initializer

if (auto it = m.find(k); it != m.end()) { }

C++17

if constexpr removes the untaken branch

if constexpr (std::is_pointer_v<T>) { }

C++17

optional, variant and any

std::optional<int> maybe;
std::variant<int,std::string> either;
std::any anything;

C++17

string_view for cheap read only strings

void log(std::string_view msg);

C++17

Filesystem library

#include <filesystem>
namespace fs = std::filesystem;
for (const auto& e : fs::directory_iterator("."))
    std::cout << e.path() << "\n";

C++17

Class template argument deduction and inline variables

std::pair p{1, 2};
inline constexpr int limit = 10;

C++17

Parallel algorithms and nested namespaces

std::sort(std::execution::par, v.begin(), v.end());
namespace a::b::c { }

C++17

C++20

modern c++

Concepts constrain templates readably

template <std::integral T> T twice(T v) { return v * 2; }

GCC 10 / Clang 10 / MSVC 19.28C++20

Ranges and views compose pipelines

auto r = v | std::views::filter(is_even) | std::views::take(3);

GCC 10 / Clang 15 / MSVC 19.29C++20

Formatting without streams

std::string s = std::format("{:>8.2f}", 3.14159);

GCC 13 / Clang 17 / MSVC 19.29C++20

result

    3.14

Three way comparison

auto operator<=>(const Point&) const = default;

GCC 10 / Clang 10 / MSVC 19.28C++20

Designated initializers

Config c{.host = "local", .port = 80};

C++20

Coroutines

Generator<int> counter(int n) {
    for (int i = 0; i < n; ++i) co_yield i;
}

GCC 10 / Clang 14 / MSVC 19.28C++20

Modules replace headers

// math.ixx
export module math;
export int add(int a, int b) { return a + b; }

// main.cpp
import math;

partial everywhere: GCC 15 / Clang 16 / MSVC 19.28C++20

span, jthread, constinit and calendar types

std::span<int> view{arr};
std::jthread t{worker};        // joins on destruction
using namespace std::chrono;
auto today = year_month_day{floor<days>(system_clock::now())};

GCC 10 / Clang 18 / MSVC 19.28C++20

contains, starts_with and erase_if

map.contains(key);
str.starts_with("pre");
std::erase_if(v, pred);

C++20

C++23

modern c++

Expected carries a value or an error

#include <expected>
std::expected<int, std::string> parse(std::string_view s);
auto r = parse("42");
if (r) use(*r); else std::cerr << r.error();

GCC 12 / Clang 16 / MSVC 19.33C++23

Print without iostream

#include <print>
std::println("total: {}", 42);

GCC 14 / Clang 18 / MSVC 19.37C++23

stdout

total: 42

Deducing this simplifies const and ref overloads

struct Widget {
    template <typename Self>
    auto&& data(this Self&& self) { return std::forward<Self>(self).data_; }
};

GCC 14 / Clang 18 / MSVC 19.32C++23

Convert any range into a container

auto v = rng | std::ranges::to<std::vector>();

GCC 14 / Clang 17 / MSVC 19.34C++23

New views

v | std::views::enumerate;
v | std::views::zip(other);
v | std::views::chunk(3);
v | std::views::slide(2);

GCC 10 / Clang 15 / MSVC 19.29C++23

Multidimensional subscript and mdspan

#include <mdspan>
std::mdspan grid{data.data(), 3, 4};
grid[1, 2] = 7;

GCC 14 / Clang 18 / MSVC 19.39C++23

Flat associative containers backed by vectors

std::flat_map<std::string,int> fm;   // cache friendly, slower insert

newest of the new, check your libraryC++23

Stacktrace on demand

#include <stacktrace>
std::cout << std::stacktrace::current();

GCC 12 / MSVC 19.34 / libc++ pendingC++23

Concurrency

Threads, locks, atomics and futures. The parts that punish guesswork.

Threads

modern c++

Start a thread and wait for it

#include <thread>
void work(int id) { std::cout << "worker " << id << "\n"; }

std::thread t{work, 1};
t.join();

C++11

Thread from a lambda

std::thread t{[&counter]{
    for (int i = 0; i < 1000; ++i) ++counter;
}};
t.join();

C++11

Auto joining thread with cancellation support

std::jthread t{[](std::stop_token st){
    while (!st.stop_requested()) tick();
}};
// destructor requests stop and joins

GCC 10 / Clang 18 / MSVC 19.28C++20

Detach only when you truly do not need the result

std::thread{background_task}.detach();

C++11

A detached thread that outlives main is undefined behaviour.

How many threads make sense here

unsigned n = std::thread::hardware_concurrency();

C++11

Identify and pause a thread

std::this_thread::get_id();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::this_thread::yield();

C++11

Keep a pool of workers

std::vector<std::jthread> pool;
for (unsigned i = 0; i < n; ++i)
    pool.emplace_back(worker, i);
// all join when pool goes out of scope

GCC 10 / Clang 18 / MSVC 19.28C++20

Synchronization

handle with care

Mutex with an RAII lock

#include <mutex>
std::mutex m;
{
    std::lock_guard<std::mutex> lock{m};
    shared_data.push_back(x);
}   // unlocked here

C++11

Lock guard with class template argument deduction

std::lock_guard lock{m};   // no explicit type needed

C++17

Unique lock can unlock early and move

std::unique_lock lock{m};
process();
lock.unlock();
expensive_io();

C++11

Lock several mutexes without deadlock

std::scoped_lock lock{m1, m2};   // deadlock free ordering

C++17

Try to lock without blocking

if (m.try_lock()) {
    // work
    m.unlock();
}

C++11

Many readers, one writer

#include <shared_mutex>
std::shared_mutex sm;
{ std::shared_lock r{sm}; read(); }     // concurrent readers
{ std::unique_lock w{sm}; write(); }    // exclusive writer

C++17

Condition variable, always wait with a predicate

std::condition_variable cv;
bool ready = false;

// consumer
std::unique_lock lock{m};
cv.wait(lock, []{ return ready; });

// producer
{ std::lock_guard g{m}; ready = true; }
cv.notify_one();

C++11

Waiting without a predicate leaves you exposed to spurious wakeups.

Run something exactly once

std::once_flag flag;
std::call_once(flag, []{ initialize(); });

C++11

Counting semaphore, latch and barrier

#include <semaphore>
std::counting_semaphore<4> slots{4};
slots.acquire();
slots.release();

std::latch done{n};
done.count_down();
done.wait();

C++20

Atomics and Futures

modern c++

Atomic counter needs no mutex

#include <atomic>
std::atomic<int> counter{0};
++counter;
counter.fetch_add(5);
int v = counter.load();

C++11

Compare and exchange loop

int expected = current.load();
while (!current.compare_exchange_weak(expected, expected + 1)) {
    // expected was updated with the real value, retry
}

C++11

Relax the memory ordering when you can prove it is safe

counter.fetch_add(1, std::memory_order_relaxed);
flag.store(true, std::memory_order_release);
flag.load(std::memory_order_acquire);

C++11

Atomic flag, the lock free primitive

std::atomic_flag lock = ATOMIC_FLAG_INIT;
while (lock.test_and_set(std::memory_order_acquire)) { }
lock.clear(std::memory_order_release);

C++11

Run asynchronously and collect the result later

#include <future>
auto fut = std::async(std::launch::async, compute, 42);
int result = fut.get();   // blocks until ready

C++11

Promise and future pair up producer and consumer

std::promise<int> p;
auto f = p.get_future();
std::thread t{[&p]{ p.set_value(compute()); }};
int v = f.get();
t.join();

C++11

Package a task for later execution

std::packaged_task<int()> task{compute};
auto f = task.get_future();
std::thread{std::move(task)}.detach();
f.get();

C++11

Poll a future without blocking

if (f.wait_for(std::chrono::milliseconds(0)) == std::future_status::ready) {
    use(f.get());
}

C++11

Share one result with many consumers

std::shared_future<int> sf = fut.share();
// every thread can call sf.get()

C++11

Errors & I/O

Exceptions, the alternatives to them, and reading and writing real files.

Exceptions

core language

Throw and catch

try {
    if (denominator == 0)
        throw std::runtime_error("division by zero");
    result = numerator / denominator;
} catch (const std::runtime_error& e) {
    std::cerr << e.what() << "\n";
}

core

stdout

division by zero

Always catch by const reference

catch (const std::exception& e) { }   // no slicing, no copy

core

Order catch blocks from most derived to most general

try { risky(); }
catch (const std::out_of_range& e) { }
catch (const std::logic_error& e)  { }
catch (const std::exception& e)    { }
catch (...)                        { }   // last resort

core

Standard exception hierarchy

std::exception
  std::logic_error
    std::invalid_argument
    std::domain_error
    std::length_error
    std::out_of_range
  std::runtime_error
    std::range_error
    std::overflow_error
    std::underflow_error
  std::bad_alloc
  std::bad_cast

core

Custom exception type

class ConfigError : public std::runtime_error {
public:
    explicit ConfigError(const std::string& what)
        : std::runtime_error(what) {}
};

core

Rethrow the current exception

catch (const std::exception&) {
    log_failure();
    throw;      // preserves the original type
}

core

noexcept means terminate on throw, so only promise what you can keep

void cleanup() noexcept { }
bool b = noexcept(cleanup());   // true

core

RAII makes cleanup automatic during unwinding

void process() {
    std::lock_guard lock{m};       // released even if this throws
    auto buf = std::make_unique<char[]>(1024);
    may_throw();
}

core

Nested exceptions keep the cause

try { low_level(); }
catch (...) { std::throw_with_nested(std::runtime_error("while loading config")); }

C++11

Errors Without Exceptions

modern c++

Return an optional when absence is normal

std::optional<Config> load(const std::string& path);
if (auto cfg = load("app.ini")) use(*cfg);

C++17

Return a value or an error, both typed

std::expected<int, ParseError> to_int(std::string_view s);
auto r = to_int(text);
if (!r) return handle(r.error());

GCC 12 / Clang 16 / MSVC 19.33C++23

Chain expected operations

auto result = read_file(path)
    .and_then(parse)
    .transform(normalize)
    .or_else(use_defaults);

C++23

Error codes from the system layer

#include <system_error>
std::error_code ec;
auto size = std::filesystem::file_size(p, ec);
if (ec) std::cerr << ec.message() << "\n";

C++11

Assertions for programmer errors, not user input

#include <cassert>
assert(index < size && "index out of range");   // removed when NDEBUG is set

core

Compile time check

static_assert(std::is_trivially_copyable_v<Packet>);

C++11

Streams and Files

core language

Write a text file

#include <fstream>
std::ofstream out{"log.txt"};
if (!out) return;
out << "line one\n";
// closed by the destructor

core

Append instead of truncating

std::ofstream out{"log.txt", std::ios::app};

core

Read a file line by line

std::ifstream in{"data.txt"};
for (std::string line; std::getline(in, line); ) {
    process(line);
}

core

Read the whole file into a string

std::ifstream in{"data.txt"};
std::string content{std::istreambuf_iterator<char>{in},
                    std::istreambuf_iterator<char>{}};

core

Binary read and write

std::ofstream out{"data.bin", std::ios::binary};
out.write(reinterpret_cast<const char*>(&value), sizeof(value));

std::ifstream in{"data.bin", std::ios::binary};
in.read(reinterpret_cast<char*>(&value), sizeof(value));

core

Parse from a string

#include <sstream>
std::istringstream iss{"12 34 hello"};
int a, b; std::string word;
iss >> a >> b >> word;

core

Build a string with a stream

std::ostringstream oss;
oss << "id=" << id << " name=" << name;
std::string s = oss.str();

core

Format numeric output

#include <iomanip>
std::cout << std::fixed << std::setprecision(2) << 3.14159 << "\n";
std::cout << std::setw(8) << std::right << 42 << "\n";
std::cout << std::boolalpha << true << "\n";

core

stdout

3.14
      42
true

Check stream state

if (in.eof())  { }   // hit end of file
if (in.fail()) { }   // format error
if (in.bad())  { }   // unrecoverable
in.clear();          // reset flags

core

Filesystem operations

namespace fs = std::filesystem;
fs::exists(p);
fs::create_directories("a/b/c");
fs::file_size(p);
fs::remove(p);
fs::copy(src, dst);
for (const auto& e : fs::recursive_directory_iterator(root))
    if (e.is_regular_file()) count++;

C++17

Idioms & Patterns

The shapes experienced C++ code keeps taking, and the two or three that are usually a mistake.

Core Idioms

modern c++

Pimpl hides the implementation and stabilizes your ABI

// widget.h
class Widget {
public:
    Widget();
    ~Widget();                       // must be out of line
    Widget(Widget&&) noexcept;
    Widget& operator=(Widget&&) noexcept;
    void draw();
private:
    struct Impl;
    std::unique_ptr<Impl> p_;
};

// widget.cpp
struct Widget::Impl { int state; };
Widget::Widget() : p_(std::make_unique<Impl>()) {}
Widget::~Widget() = default;         // Impl is complete here

C++11

The destructor must be defined in the source file. unique_ptr needs a complete type to destroy.

Copy and swap gives you assignment and exception safety in one

Buffer& operator=(Buffer other) {   // by value, copy already made
    swap(*this, other);
    return *this;
}
friend void swap(Buffer& a, Buffer& b) noexcept {
    using std::swap;
    swap(a.data_, b.data_);
    swap(a.size_, b.size_);
}

core

Type erasure holds anything that satisfies an interface

class Drawable {
    struct Base {
        virtual ~Base() = default;
        virtual void draw() const = 0;
    };
    template <typename T>
    struct Model : Base {
        T obj;
        explicit Model(T o) : obj(std::move(o)) {}
        void draw() const override { obj.draw(); }
    };
    std::unique_ptr<Base> self_;
public:
    template <typename T>
    Drawable(T obj) : self_(std::make_unique<Model<T>>(std::move(obj))) {}
    void draw() const { self_->draw(); }
};

C++14

Tag dispatch picks an overload from a type

struct fast_tag {}; struct safe_tag {};

void impl(Data& d, fast_tag) { /* no checks */ }
void impl(Data& d, safe_tag) { /* validated */ }

template <typename Tag = safe_tag>
void process(Data& d) { impl(d, Tag{}); }

core

Strong types stop you passing metres where you meant seconds

template <typename T, typename Tag>
class Strong {
    T v_;
public:
    explicit Strong(T v) : v_(std::move(v)) {}
    const T& get() const { return v_; }
};
using UserId  = Strong<int, struct UserIdTag>;
using OrderId = Strong<int, struct OrderIdTag>;
// void f(UserId);  f(OrderId{1});  // will not compile

C++11

Non copyable base

struct NonCopyable {
    NonCopyable() = default;
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
};
class Connection : private NonCopyable { };

C++11

Scope guard runs cleanup on any exit path

template <typename F>
struct ScopeExit {
    F f;
    ~ScopeExit() { f(); }
};
template <typename F> ScopeExit(F) -> ScopeExit<F>;

{
    auto fd = ::open(path, O_RDONLY);
    ScopeExit guard{[&]{ ::close(fd); }};
    read_everything(fd);
}   // closed no matter how we leave

C++17

Hidden friend keeps operators out of overload resolution elsewhere

class Money {
    long cents_;
    friend bool operator==(const Money& a, const Money& b) {
        return a.cents_ == b.cents_;
    }
};

core

Classic Patterns

core language

Factory returning an interface

std::unique_ptr<Shape> make_shape(std::string_view kind) {
    if (kind == "circle") return std::make_unique<Circle>();
    if (kind == "square") return std::make_unique<Square>();
    return nullptr;
}

C++14

Registry driven factory, no if chain to maintain

using Maker = std::function<std::unique_ptr<Shape>()>;
inline std::map<std::string, Maker>& registry() {
    static std::map<std::string, Maker> r;
    return r;
}
inline bool register_shape(std::string name, Maker m) {
    registry().emplace(std::move(name), std::move(m));
    return true;
}
static const bool circle_reg =
    register_shape("circle", []{ return std::make_unique<Circle>(); });

C++11

Meyers singleton, thread safe since C++11

class Config {
public:
    static Config& instance() {
        static Config c;      // initialized once, thread safe
        return c;
    }
    Config(const Config&) = delete;
    Config& operator=(const Config&) = delete;
private:
    Config() = default;
};

C++11

Singletons hide dependencies and make tests awkward. Prefer passing the object in.

Observer with weak references so listeners can die

class Subject {
    std::vector<std::weak_ptr<Listener>> obs_;
public:
    void subscribe(std::shared_ptr<Listener> l) { obs_.push_back(std::move(l)); }
    void notify(const Event& e) {
        std::erase_if(obs_, [](auto& w){ return w.expired(); });
        for (auto& w : obs_)
            if (auto l = w.lock()) l->on_event(e);
    }
};

C++20

Builder for objects with many optional fields

class RequestBuilder {
    Request r_;
public:
    RequestBuilder& url(std::string u)  { r_.url = std::move(u); return *this; }
    RequestBuilder& method(Verb v)      { r_.verb = v;           return *this; }
    RequestBuilder& timeout(int ms)     { r_.timeout = ms;       return *this; }
    Request build() && { return std::move(r_); }
};
auto req = RequestBuilder{}.url("/api").method(Verb::Get).build();

C++11

Visitor without virtual functions, using variant

using Node = std::variant<Literal, Add, Mul>;

int eval(const Node& n) {
    return std::visit(overload{
        [](const Literal& l) { return l.value; },
        [](const Add& a)     { return eval(*a.lhs) + eval(*a.rhs); },
        [](const Mul& m)     { return eval(*m.lhs) * eval(*m.rhs); }
    }, n);
}

C++17

State machine as a variant of states

using State = std::variant<Idle, Running, Done>;

State step(State s, Event e) {
    return std::visit([&](auto&& cur) -> State {
        return cur.on(e);
    }, s);
}

C++17

Policy based design swaps behaviour at compile time

template <typename LockPolicy>
class Queue : private LockPolicy {
public:
    void push(int v) {
        typename LockPolicy::Guard g{*this};
        data_.push_back(v);
    }
private:
    std::vector<int> data_;
};
Queue<NoLock>    single_threaded;
Queue<MutexLock> shared;

core

Coroutines

modern c++

A coroutine is any function containing co_await, co_yield or co_return

Task<int> fetch() {
    auto page = co_await http_get("/api");
    co_return page.size();
}

GCC 10 / Clang 14 / MSVC 19.28C++20

The generator promise, the minimum you need to write

#include <coroutine>
template <typename T>
struct Generator {
    struct promise_type {
        T value;
        Generator get_return_object() {
            return Generator{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        std::suspend_always yield_value(T v) { value = std::move(v); return {}; }
        void return_void() {}
        void unhandled_exception() { throw; }
    };
    std::coroutine_handle<promise_type> h;
    explicit Generator(std::coroutine_handle<promise_type> hh) : h(hh) {}
    ~Generator() { if (h) h.destroy(); }
    Generator(Generator&& o) noexcept : h(std::exchange(o.h, {})) {}
    bool next() { h.resume(); return !h.done(); }
    T value() const { return h.promise().value; }
};

GCC 10 / Clang 14 / MSVC 19.28C++20

Produce a lazy sequence

Generator<int> fib() {
    int a = 0, b = 1;
    while (true) {
        co_yield a;
        auto next = a + b;
        a = b; b = next;
    }
}

auto g = fib();
for (int i = 0; i < 8 && g.next(); ++i)
    std::cout << g.value() << " ";

GCC 10 / Clang 14 / MSVC 19.28C++20

stdout

0 1 1 2 3 5 8 13

The three suspend points a promise controls

std::suspend_always initial_suspend();  // lazy: nothing runs until resumed
std::suspend_never  initial_suspend();  // eager: body runs immediately
std::suspend_always final_suspend();    // keep the frame so you can read results
// final_suspend must be noexcept

GCC 10 / Clang 14 / MSVC 19.28C++20

An awaitable needs three members

struct Sleep {
    std::chrono::milliseconds d;
    bool await_ready() const { return d.count() <= 0; }
    void await_suspend(std::coroutine_handle<> h) const {
        schedule_after(d, h);      // resume later
    }
    void await_resume() const {}
};
co_await Sleep{100ms};

GCC 10 / Clang 14 / MSVC 19.28C++20

Symmetric transfer to continue another coroutine

std::coroutine_handle<> await_suspend(std::coroutine_handle<> h) noexcept {
    return continuation ? continuation : std::noop_coroutine();
}

GCC 10 / Clang 14 / MSVC 19.28C++20

Generator arrives in the standard library in C++23

#include <generator>
std::generator<int> squares(int n) {
    for (int i = 1; i <= n; ++i) co_yield i * i;
}
for (int v : squares(4)) std::cout << v << " ";

newest of the new, check your libraryC++23

stdout

1 4 9 16

This removes most of the boilerplate above, once your library ships it.

Modules

modern c++

Declare and export a module

// math.ixx  (or .cppm, depending on the toolchain)
export module math;

export int add(int a, int b) { return a + b; }
int helper() { return 0; }        // not exported, invisible outside

partial everywhere: GCC 15 / Clang 16 / MSVC 19.28C++20

Import it, no header, no include guard

// main.cpp
import math;
import std;                       // C++23 standard library module

int main() { return add(2, 3); }

partial everywhere: GCC 15 / Clang 16 / MSVC 19.28C++20

Export a whole block

export module geometry;

export {
    struct Point { double x, y; };
    double distance(Point a, Point b);
}

partial everywhere: GCC 15 / Clang 16 / MSVC 19.28C++20

Split a module into interface and implementation

// geometry.ixx
export module geometry;
export double distance(Point a, Point b);

// geometry_impl.cpp
module geometry;                  // implementation unit
double distance(Point a, Point b) { return std::hypot(a.x-b.x, a.y-b.y); }

partial everywhere: GCC 15 / Clang 16 / MSVC 19.28C++20

Partitions keep large modules organized

// geometry-shapes.ixx
export module geometry:shapes;
export struct Circle { double r; };

// geometry.ixx
export module geometry;
export import :shapes;

partial everywhere: GCC 15 / Clang 16 / MSVC 19.28C++20

Bring a legacy header into the module world

module;                          // global module fragment
#include <cmath>                  // old style header goes here
export module geometry;

partial everywhere: GCC 15 / Clang 16 / MSVC 19.28C++20

Building modules by hand is still toolchain specific

# GCC
g++ -std=c++20 -fmodules-ts -c math.ixx

# Clang
clang++ -std=c++20 --precompile math.cppm -o math.pcm

# CMake 3.28 and newer
target_sources(app PUBLIC FILE_SET CXX_MODULES FILES math.ixx)

partial everywhere: GCC 15 / Clang 16 / MSVC 19.28C++20

Module support is real but uneven. Check your exact compiler and build system before committing a project to it.

C Interop and ABI

handle with care

Stop name mangling so C can link against it

extern "C" void process(int* data, int n);

extern "C" {
    #include <legacy_api.h>
}

core

A header that works from both languages

#ifdef __cplusplus
extern "C" {
#endif

void process(int* data, int n);

#ifdef __cplusplus
}
#endif

core

Never let an exception cross a C boundary

extern "C" int safe_entry(const char* path) noexcept {
    try {
        do_work(path);
        return 0;
    } catch (const std::exception&) {
        return -1;
    } catch (...) {
        return -2;
    }
}

C++11

Pass C++ objects across as opaque handles

extern "C" {
    typedef struct EngineHandle EngineHandle;
    EngineHandle* engine_create();
    void engine_destroy(EngineHandle*);
}

EngineHandle* engine_create() {
    return reinterpret_cast<EngineHandle*>(new Engine{});
}
void engine_destroy(EngineHandle* h) {
    delete reinterpret_cast<Engine*>(h);
}

core

Standard layout types are safe to share with C

struct Packet { int id; double value; };
static_assert(std::is_standard_layout_v<Packet>);
static_assert(std::is_trivially_copyable_v<Packet>);

C++17

What breaks a shared library ABI

// Adding or reordering data members
// Adding, removing or reordering virtual functions
// Changing a function signature, return type or default argument
// Changing inline function bodies that callers already inlined
// Changing the size or alignment of any exported type

core

Pimpl and pure abstract interfaces are the two standard ways to keep an ABI stable.

Control what a shared library exports

// GCC and Clang
#define API __attribute__((visibility("default")))
// build with -fvisibility=hidden

// MSVC
#define API __declspec(dllexport)

class API Engine { };

core

Never mix allocators across a library boundary

// allocate and free on the same side
extern "C" Buffer* buffer_create();
extern "C" void     buffer_free(Buffer*);

core

new in the library and delete in the caller is a crash waiting for a different runtime build.

Undefined Behaviour

The list that explains most C++ bugs that only appear in release builds. If your program does any of this, the compiler is allowed to do anything at all.

What Undefined Behaviour Means

handle with care

The compiler assumes UB never happens, and optimizes on that assumption

int f(int* p) {
    int v = *p;              // dereferenced, so p cannot be null
    if (p == nullptr)        // ...therefore this branch is dead
        return -1;           // and the optimizer deletes it
    return v;
}

core

This is why UB does not produce a predictable wrong answer. It produces a different program.

Three categories that are often confused

undefined       anything may happen, including time travel past the error
unspecified     a valid choice is made, you are not told which
                (argument evaluation order before C++17)
implementation  a valid choice is made and documented
                (sizeof(int), char signedness)

core

A release build can behave differently from a debug build

// -O0 often "works": the bug is masked by padding and predictable layout
// -O2 does not: the optimizer acts on assumptions your code violates

core

If a bug disappears under -O0 or under a debugger, suspect UB rather than the compiler.

Memory and Lifetime

handle with care

Reading or writing past the end of an array

int a[5];
a[5] = 1;                    // UB, valid indices are 0 to 4
v[v.size()] = 1;             // UB, use at() to get a throw instead

core

Using memory after it is freed

delete p;
p->value = 1;                // UB

auto it = v.begin();
v.push_back(x);              // may reallocate
*it;                         // UB

core

Returning a reference or pointer to a local

const std::string& bad() {
    std::string local = "oops";
    return local;            // destroyed on return, UB to read
}

core

Dereferencing null or an uninitialized pointer

int* p;                      // indeterminate
*p = 1;                      // UB

int* q = nullptr;
*q;                          // UB

core

Deleting twice, or with the wrong form

delete p; delete p;          // UB

int* a = new int[10];
delete a;                    // UB, needs delete[]

core

Reading an uninitialized variable

int n;
if (n > 0) { }               // UB

int m{};                     // 0, always safe

core

A dangling string_view or span

std::string_view sv = std::string{"temp"};   // temporary dies immediately
std::span<int> sp = make_vector();           // same problem

C++17

Breaking strict aliasing

float f = 1.0f;
int n = *reinterpret_cast<int*>(&f);   // UB

int m = std::bit_cast<int>(f);         // well defined, C++20

C++20

Misaligned access

char buf[16];
auto* d = reinterpret_cast<double*>(buf + 1);   // UB if unaligned
*d = 1.0;

core

Arithmetic and Logic

handle with care

Signed integer overflow

int n = std::numeric_limits<int>::max();
++n;                         // UB

unsigned u = UINT_MAX;
++u;                         // defined, wraps to 0

core

Division or remainder by zero

int a = 1 / 0;               // UB
int b = 1 % 0;               // UB
double d = 1.0 / 0.0;        // not UB, gives infinity

core

Shifting too far or shifting a negative count

int x = 1 << 32;             // UB on a 32 bit int
int y = 1 << -1;             // UB

core

Converting a value that does not fit

double d = 1e300;
int n = static_cast<int>(d);   // UB, out of range

core

Falling off the end of a value returning function

int f(int x) {
    if (x > 0) return 1;
    // no return: UB if x <= 0
}

core

Compilers warn about this with -Wreturn-type. Treat that warning as an error.

Infinite loop with no side effects

while (true) { }             // UB in C++ unless it has observable behaviour
while (true) { std::this_thread::yield(); }   // fine

core

Objects and Concurrency

handle with care

Deleting through a base pointer with no virtual destructor

Base* b = new Derived;
delete b;                    // UB unless ~Base is virtual

core

Calling a virtual function during construction or destruction

Base::Base() { init(); }     // calls Base::init, never the override
// pure virtual call during construction is UB

core

Data race, two threads and at least one writer

int counter = 0;
// thread A: ++counter;
// thread B: ++counter;      // UB without atomic or a mutex

core

Using a moved from object beyond a reset or destroy

auto b = std::move(a);
a.size();                    // legal, value unspecified
a[0];                        // not legal, no element is guaranteed

C++11

Modifying a const object

const int ci = 10;
int* p = const_cast<int*>(&ci);
*p = 20;                     // UB

core

Two unsequenced modifications of the same object

int i = 0;
i = i++ + 1;                 // UB before C++17, confusing after
f(i++, i++);                 // unsequenced, do not do this

core

Recursion deep enough to exhaust the stack

void f(int n) { f(n + 1); }  // stack overflow is UB, not an exception

core

Finding It Before Users Do

modern c++

Address sanitizer catches memory errors

g++ -fsanitize=address -g -O1 main.cpp -o app
./app

# finds: heap and stack overflow, use after free,
#        use after return, double free, leaks

core

Undefined behaviour sanitizer catches the arithmetic and cast cases

g++ -fsanitize=undefined -g main.cpp -o app

# finds: signed overflow, bad shifts, misalignment,
#        null dereference, invalid enum and bool values

core

Thread sanitizer catches data races

g++ -fsanitize=thread -g main.cpp -o app

core

Thread sanitizer cannot be combined with address sanitizer. Build twice.

Memory sanitizer catches reads of uninitialized memory

clang++ -fsanitize=memory -fno-omit-frame-pointer -g main.cpp

core

Harden the standard library in debug builds

# libstdc++
g++ -D_GLIBCXX_ASSERTIONS -D_GLIBCXX_DEBUG main.cpp

# libc++
clang++ -D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG main.cpp

# MSVC
cl /RTC1 /D_ITERATOR_DEBUG_LEVEL=2 main.cpp

core

This turns out of range vector access from silent UB into a clear abort.

Static analysis finds what runtime tools miss

clang-tidy src/*.cpp -checks=bugprone-*,cert-*,clang-analyzer-*
cppcheck --enable=all src/
g++ -fanalyzer main.cpp

core

Turn the warnings that matter into errors

g++ -Wall -Wextra -Wpedantic \
    -Wshadow -Wconversion -Wsign-conversion \
    -Wnon-virtual-dtor -Wold-style-cast -Wcast-align \
    -Wunused -Woverloaded-virtual -Wnull-dereference \
    -Wdouble-promotion -Wformat=2 -Werror

core

Run the fast checks on every build

# a reasonable default for a development build
set(CMAKE_CXX_FLAGS_DEBUG
    "-g -O1 -fsanitize=address,undefined -fno-omit-frame-pointer")

core

Build & Tooling

Preprocessor, compiler flags, CMake and the debug tools worth memorizing.

Preprocessor

core language

Include library and project headers

#include <vector>      // standard library
#include "widget.h"    // your project

core

Stop a header being included twice

#pragma once            // supported everywhere in practice

// or the portable form:
#ifndef WIDGET_H
#define WIDGET_H
// ...
#endif

core

Object like and function like macros

#define MAX_USERS 100
#define SQUARE(x) ((x) * (x))

core

Prefer constexpr and inline functions. Macros ignore scope and types.

Conditional compilation

#ifdef DEBUG
    std::cout << "debug build\n";
#endif

#if defined(_WIN32)
    // windows only
#elif defined(__linux__)
    // linux only
#endif

core

Check the language standard in use

#if __cplusplus >= 202002L
    // C++20 or newer
#endif

core

Feature test macros are more precise than version checks

#if __cpp_lib_format >= 201907L
    #include <format>
#endif

C++20

Useful predefined macros

__FILE__   __LINE__   __func__
__DATE__   __TIME__
__GNUC__   _MSC_VER   __clang__

core

Stringify and paste tokens

#define STR(x) #x
#define CAT(a, b) a##b
STR(hello)   // "hello"
CAT(my, var) // myvar

core

Compiling

core language

Compile and run in one line

g++ main.cpp -o app && ./app

core

Pick the language standard

g++ -std=c++23 main.cpp -o app
clang++ -std=c++20 main.cpp -o app

core

Turn warnings on, they are free bug reports

g++ -std=c++23 -Wall -Wextra -Wpedantic -Wshadow -Wconversion main.cpp

core

Treat warnings as errors in continuous integration

g++ -Wall -Wextra -Werror main.cpp

core

Optimization levels

g++ -O0 main.cpp   # no optimization, fastest build
g++ -O2 main.cpp   # the usual release choice
g++ -O3 main.cpp   # more aggressive
g++ -Os main.cpp   # optimize for size

core

Build with debug symbols

g++ -g -O0 main.cpp -o app

core

Compile several files and link

g++ -c main.cpp -o main.o
g++ -c widget.cpp -o widget.o
g++ main.o widget.o -o app

core

Link a library and add include paths

g++ main.cpp -I./include -L./lib -lmylib -lpthread

core

Sanitizers catch what the compiler cannot

g++ -fsanitize=address,undefined -g main.cpp -o app
g++ -fsanitize=thread -g main.cpp -o app

core

Address and thread sanitizers cannot be combined in one build.

See the preprocessed output or the assembly

g++ -E main.cpp        # after preprocessing
g++ -S main.cpp        # assembly output

core

CMake and Tooling

core language

Minimal CMakeLists.txt

cmake_minimum_required(VERSION 3.20)
project(myapp LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_executable(myapp src/main.cpp src/widget.cpp)

core

Configure and build

cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j
./build/myapp

core

Add a library target and link it

add_library(core STATIC src/core.cpp)
target_include_directories(core PUBLIC include)
target_link_libraries(myapp PRIVATE core)

core

Request features and warnings per target

target_compile_features(myapp PRIVATE cxx_std_23)
target_compile_options(myapp PRIVATE -Wall -Wextra)

core

Find and use an installed dependency

find_package(Threads REQUIRED)
target_link_libraries(myapp PRIVATE Threads::Threads)

core

Fetch a dependency at configure time

include(FetchContent)
FetchContent_Declare(fmt
    GIT_REPOSITORY https://github.com/fmtlib/fmt.git
    GIT_TAG 10.2.1)
FetchContent_MakeAvailable(fmt)
target_link_libraries(myapp PRIVATE fmt::fmt)

core

Debug with gdb

gdb ./app
(gdb) break main.cpp:42
(gdb) run
(gdb) next / step / continue
(gdb) print variable
(gdb) backtrace

core

Check for leaks with valgrind

valgrind --leak-check=full --show-leak-kinds=all ./app

core

Format and lint

clang-format -i src/*.cpp
clang-tidy src/main.cpp -- -std=c++23

core

Common Pitfalls

handle with care

Integer division truncates

double bad  = 5 / 2;        // 2.0, both operands are int
double good = 5 / 2.0;      // 2.5

core

Comparing signed and unsigned

int i = -1;
unsigned u = 1;
if (i < u) { }   // false, i converts to a huge unsigned value

core

Enable -Wsign-compare and use std::cmp_less from C++20.

Dangling reference to a temporary

const std::string& bad() {
    std::string local = "oops";
    return local;        // destroyed on return
}

core

Iterator invalidation after push_back

auto it = v.begin();
v.push_back(1);      // may reallocate
// *it is now dangling

core

string_view outliving its buffer

std::string_view sv = std::string{"temporary"};   // dangles immediately

C++17

Uninitialized locals hold garbage

int n;              // indeterminate value
int m{};            // 0, always prefer this

core

Comparing floating point with ==

if (a == b) { }                                  // fragile
if (std::abs(a - b) < 1e-9) { }                  // better

core

Object slicing when passing by value

void draw(Shape s);       // slices any Derived down to Shape
void draw(const Shape& s);// keeps the dynamic type

core

Moved from objects are valid but unspecified

auto b = std::move(a);
// a.size() is legal to call, the answer is not guaranteed

C++11

By Bogdan Sandu · Updated August 14, 2026

What is C++

C++ is a compiled, statically typed, general-purpose language that extends C with object-oriented and generic programming support.

Bjarne Stroustrup began building it at Bell Labs in 1979 under the name "C with Classes," renaming it C++ in 1983.

Three compilers dominate production builds today: GCC 15.3 (released June 12, 2026), Clang 22.1.3 (released April 7, 2026), and Microsoft's MSVC, bundled with Visual Studio.

TechRepublic's August 2026 TIOBE Index puts C++ at No. 3 among all programming languages, with an 8.62% share, just ahead of Java's 8.25%.

Usage figures back that ranking. 23.5% of developers in the 2025 Stack Overflow Developer Survey reported working with C++ in the past year, rising to 44.6% among people currently learning to code.

The language still anchors a large share of modern software development, particularly where raw speed and hardware control matter more than rapid iteration.

C++ Standard Versions

C++98, the language's first ISO standard, arrived in 1998. Six standards followed it, each layering new capability onto the language without breaking most existing code:

Standard	Ratified	Key Addition
C++11	2011	auto, lambdas, smart pointers
C++14	2014	generic lambdas, relaxed constexpr
C++17	2017	structured bindings, std::optional
C++20	2020	concepts, coroutines, modules
C++23	2024 (ISO/IEC 14882:2024)	multidimensional subscript operator
C++26	2026	reflection, contracts

WG21 technically finalized C++26 in London on March 28, 2026. Committee chair Herb Sutter described its compile-time reflection feature as "a whole new language."

Adoption of the newest standard is already measurable. Stack Overflow's rising-technology tag for c++23 was used by 7.3% of all 2025 survey respondents, ahead of several newer frameworks tracked that same year.

Where C++ Is Used

Four industries account for most production C++ code.

Game engines, most visibly Epic Games' Unreal Engine
Operating system kernels and device drivers
Embedded and aerospace firmware, including flight software
Low-latency trading systems in finance

A growing fifth category has emerged. TIOBE's own August 2026 commentary notes that a meaningful share of the infrastructure running AI models in production is written in C++, prized for the same low-overhead execution that made it standard in game engines decades earlier.

Data Types and Variables in C++

C++ requires every variable to carry a fixed type, decided either explicitly or through inference at compile time.

That type determines how many bytes the compiler reserves and which operations are legal on the value.

Primitive Types and Sizes

Type	Typical Size (64-bit)	Example Value
int	4 bytes	42
double	8 bytes	3.14159
char	1 byte	'A'
bool	1 byte	true

Modifiers change these defaults. signed and unsigned attach to the base types alongside short and long, so unsigned long stores far larger values than a plain int.

Java's own primitive type table borrows this int, double, char split almost unchanged, though Java dropped the unsigned modifiers entirely in favor of the smaller set covered in its own syntax reference.

Variable Declaration Syntax

Copy initialization: int x = 5; assigns through the = operator.

Direct initialization: int x(5); calls the constructor directly.

Brace initialization: int x{5}; blocks narrowing conversions the other two forms allow silently.

auto, added in C++11, infers the type from the right-hand side, so auto x = 5; makes x an int without the word ever appearing.

Google's public C++ Style Guide requires every variable to be initialized at the point of declaration, a rule it enforces across its own production codebase.

Operators in C++

C++ groups its operators into four functional categories.

Arithmetic: + - * / %
Relational and logical: == != && ||
Bitwise: & | ^ ~ << >>
Assignment: = += -= *=

id Software's Quake engine, written largely in C, leaned on a bitwise trick called the fast inverse square root to speed up lighting math, a technique C++ game engines still cite as a case study in bit-level operator use.

Operator Precedence Table

Precedence	Operators	Associativity
Highest	`() [] -> .`	Left to right
Middle	`* / % + -`	Left to right
Lower	`&& \|\|`	Left to right
Lowest	`= += -=`	Right to left

Precedence beats intuition here. Mixed expressions without parentheses resolve strictly by this order, which is why a * b + c never evaluates as a * (b + c).

Control Flow Statements in C++

Control flow statements decide which lines of a C++ program execute, and how many times.

Every branch and loop in the language reduces to one of a handful of keywords.

Conditional Statements

NASA's Jet Propulsion Laboratory enforces a coding standard, based on Gerard Holzmann's "Power of Ten" rules, that governs the C and C++ running its Mars rovers.

if, else if, and else evaluate boolean expressions in order and execute the first branch that matches.

switch-case compares a single value against multiple constant labels, falling through to the next case unless a break stops it.

The Curiosity rover runs on roughly 2.5 million lines of flight code, all written under rules that forbid unbounded branching paths (RankRed, 2026).

Loop Structures

Four loop forms cover every iteration case in C++.

for (init; condition; increment) for counted iteration
while (condition) for open-ended iteration
do-while for loops that must run at least once
Range-based for (C++11) for iterating containers directly

JPL's institutional standard requires every loop to carry a statically provable upper bound, the same rule cited above, so unbounded while(true) constructs are rejected outright in flight software.

break exits a loop early, continue skips to the next iteration, and goto jumps to a labeled line, though most C++ style guides ban goto for the clarity reasons JPL formalized decades ago.

Functions in C++

A function in C++ groups reusable code behind a name, a return type, and a parameter list.

The signature, not just the name, determines which function a given call resolves to.

Function Overloading

Multiple functions can share one name in C++ as long as their parameter lists differ in type, order, or count.

The compiler picks the correct overload at compile time by matching argument types against each candidate signature, a process called overload resolution.

print(int) and print(double) coexist safely. Adding print(std::string) later joins the same overload set without conflict.

Return type alone never distinguishes overloads. Two functions differing only in return type fail to compile.

Lambda Expressions

C++11 introduced lambdas: anonymous, inline functions written as [capture](parameters) { body }.

Capture modes control what a lambda can see from its surrounding scope.

[] captures nothing
[&] captures everything by reference
[=] captures everything by value
[x] captures only x, by value

The C++ Core Guidelines, maintained by Stroustrup and Herb Sutter, recommend passing lambdas as templates or std::function rather than raw function pointers to preserve capture behavior.

Arrays and Strings in C++

C++ offers two ways to store sequences of characters, and two ways to store sequences of any other fixed type.

C-Style Arrays

int values[5]; reserves five contiguous ints, indexed from values[0] through values[4].

Multidimensional arrays stack this pattern: int grid[3][3]; declares a 3-by-3 block in row-major order.

Out-of-bounds access compiles without error and reads or writes whatever memory sits past the array, a common source of the bugs the language's critics point to.

std::array and std::vector wrap this same memory layout with bounds-checked access through .at(), trading a small performance cost for safety.

std::string vs C-Style Strings

C-style strings:

Stored as char arrays
Terminated by a null character, '\0'
Manipulated through pointer-based functions like strlen and strcpy

std::string:

Manages its own memory and resizes automatically
Exposes methods including length(), substr(), find(), and append()
Overloads + for concatenation, unlike C-style strings

Meta's open-source Folly library ships a custom fbstring that outperforms the standard std::string on short strings by avoiding a heap allocation entirely.

Pointers and References in C++

A pointer stores a memory address. A reference is an alias for an existing variable.

Both let a function or expression work with data without copying it, but they behave differently once declared.

Pointer Syntax and Arithmetic

int* p declares a pointer to an int. *p dereferences it to read or write the value it points to, and &x takes the address of x.

Pointer arithmetic moves by element size, not by byte, so p + 1 on an int* jumps four bytes ahead on a typical 64-bit build.

Microsoft reports that roughly 70% of the vulnerabilities it assigns a CVE to each year trace back to memory safety issues, and unchecked pointer arithmetic is a leading contributor (Microsoft, via CISA, 2023).

const correctness narrows that risk. const int* p points to a value that can't change through p, while int* const p is a pointer that can't be repointed.

References vs Pointers

Three differences decide which one a given piece of code needs.

Nullability: a pointer can be nullptr, a reference must bind to a real object at creation
Reassignment: a pointer can be redirected later, a reference is locked to its original target for life
Syntax: pointers need * to dereference, references behave like the original variable with no extra symbol

Function parameters favor references for this reason. void update(int& x) modifies the caller's variable without the null-check overhead a pointer parameter carries.

Object-Oriented Programming in C++

C++ implements object-oriented programming, one of the core software development principles behind maintainable large-scale codebases, through classes that bundle data and the functions that operate on it into a single type.

Every object built from a class carries its own copy of the data members, while member functions operate on whichever object called them.

Constructors and Destructors

A constructor runs automatically when an object is created, most often to set initial values for its data members.

Qt's widget hierarchy leans on this pattern constantly. Every QWidget subclass initializes its layout and child widgets inside the constructor before the object becomes usable.

Initialization lists run before the constructor body and are the only way to initialize const members or references, since Type(int x) : member(x) {} sets the member before the body ever executes.

A destructor runs automatically when an object goes out of scope or is deleted, releasing whatever resources the constructor acquired. ~ClassName() never takes arguments and never returns a value.

Inheritance and Polymorphism

Concept	Mechanism	Resolved
Inheritance	class Derived : public Base	Compile time
Virtual function	virtual return_type name()	Runtime, via vtable
Pure virtual	virtual void name() = 0;	Forces override, blocks instantiation

A base class pointer or reference calling a virtual function executes the derived class's version, the mechanism behind runtime polymorphism.

LLVM's compiler internals lean on the same override pattern. Its abstract syntax tree classes dispatch through a common base Value class shared by every instruction type.

Standard Template Library Containers and Algorithms

The Standard Template Library organizes reusable data structures and functions around three cooperating parts: containers, algorithms, and iterators.

A container holds data, an algorithm processes it, and an iterator connects the two without either side needing to know the other's implementation details.

Container Types

Category	Examples	Best For
Sequence	vector, deque, list, array	Ordered, position-based access
Associative	map, set, multimap	Sorted key lookup
Unordered	unordered_map, unordered_set	Fast average-case lookup
Adapter	stack, queue, priority_queue	Restricted access patterns

std::vector handles random access and end-insertion in constant time, but inserting mid-sequence costs linear time, per cppreference's own complexity guarantees for the type.

Common STL Algorithms

Four algorithms from the <algorithm> header cover most everyday tasks.

std::sort reorders a range using a comparison function
std::find returns an iterator to the first matching element
std::count tallies elements matching a condition
std::accumulate, from <numeric>, reduces a range to a single value

container.begin() and container.end() return iterators marking the start and one-past-the-end position. rbegin() and rend() do the same in reverse, letting identical algorithm calls traverse a container backward.

Bloomberg's BDE library, open sourced from the same C++ codebase running its trading terminal, extends this iterator-based design with its own container set built to interoperate with the standard one.

Memory Management in C++

C++ gives developers direct control over when memory is allocated and released, unlike languages with automatic garbage collection.

That control is also where most of the language's most serious bugs originate.

Manual Allocation with new and delete

new requests memory from the heap and returns a pointer to it. delete releases that memory back to the system.

Every new needs exactly one matching delete. Calling delete twice on the same pointer, a double-free, corrupts the heap's internal bookkeeping.

Forgetting delete entirely creates a memory leak: the memory stays reserved for the life of the program even though nothing can reach it anymore.

Dangling pointers compound the risk. A pointer that still holds the address of freed memory looks valid to the compiler right up until something dereferences it.

Smart Pointer Types

Type	Ownership	Header
unique_ptr	Single owner, non-copyable	<memory>
shared_ptr	Shared, reference-counted	<memory>
weak_ptr	Non-owning observer of a shared_ptr	<memory>

All three, added in C++11, wrap a raw pointer and call delete automatically when the last owner goes out of scope, an application of the broader RAII principle.

MITRE's 2024 CWE Top 25 ranked use-after-free (CWE-416) at No. 4 among the most dangerous software weaknesses, with 1,172 reported CVEs tied to the exact failure mode smart pointers are designed to prevent (MITRE, 2024).

Mozilla's Firefox codebase relies on its own reference-counted smart pointer types, RefPtr and nsCOMPtr, to manage the same ownership problem across its C++ layers.

make_unique and make_shared construct the pointer and its managed object in a single call, keeping a raw new expression out of application code entirely.

Exception Handling in C++

try, catch, and throw let a program separate normal logic from error-handling logic.

Code inside a try block runs normally until a throw statement transfers control to a matching catch block.

std::exception is the base class for the standard library's built-in exception types, including std::runtime_error and std::out_of_range.

Custom exception types typically inherit from std::exception and override its virtual what() method to return a description string.

A single catch block can list multiple exception types, or use catch (...) to intercept anything a more specific handler missed.

Most C++ implementations use what a 2024 technical analysis called a zero-cost exception model: code in a try block carries no runtime overhead as long as no exception is actually thrown.

That claim isn't universal. A 2022 ISO working paper, P2544R0, measured slowdowns near 25% on the non-throwing path under high-concurrency workloads, tracing the cost to a global mutex the unwinder locks to protect its tables. The two findings describe different conditions rather than contradicting each other: true zero-cost holds for single-threaded, rarely-throwing code, while the mutex contention shows up specifically under heavy concurrent throw rates.

LLVM's own coding standards disable C++ exceptions across its codebase entirely, citing binary size and predictable control flow over the performance question itself.

noexcept, added in C++11, tells the compiler a function will never throw, permitting optimizations the compiler can't safely make otherwise.

Input and Output Operations in C++

C++ handles input and output through streams, objects that read or write a sequence of characters regardless of whether the destination is a console, a file, or a string.

Console I/O

fmt::print, the library that became the basis for C++23's std::print, benchmarked roughly 20% faster than printf from Apple's libc, according to the library's own author.

std::cin and std::cout read from and write to the console using the >> and << operators, chaining multiple values in a single statement.

std::print and std::println, added in C++23, close the gap between cout's type safety and printf's speed by writing directly to the underlying file stream instead of routing through iostream's formatting layer.

getline(std::cin, line) reads an entire line, including spaces, which the >> operator on its own stops at.

File I/O

Three stream classes handle file access, each from <fstream>.

ifstream opens a file for reading only
ofstream opens a file for writing only, truncating existing content by default
fstream opens a file for both reading and writing

iomanip provides formatting controls that work on both console and file streams. setw() pads a field, setprecision() limits decimal places, and fixed forces standard decimal notation instead of scientific.

Every open file stream closes automatically when it goes out of scope, another application of the RAII pattern already covered under smart pointers.

Preprocessor Directives and Header Files in C++

The preprocessor runs before compilation, transforming source code through directives that all begin with #.

#include pulls the contents of a header file into the current source file, most commonly for standard headers like <iostream>, <vector>, <string>, and <algorithm>.

#define creates a macro, substituting text before the compiler ever sees it, which is why macro bugs rarely surface as ordinary syntax errors.

Header guards prevent a header from being included twice in the same translation unit.

#ifndef HEADER_H, #define HEADER_H, and #endif form the traditional pattern
#pragma once achieves the same result in one line, supported by every major compiler despite never being formally standardized

C++20 modules offer an alternative to both approaches, importing compiled interfaces instead of reprocessing text on every build. Alibaba Cloud's Hologres team reported roughly a 42% improvement in compilation efficiency after migrating its codebase to modules (Alibaba Cloud, 2025).

Conditional compilation, through #ifdef and #ifndef, compiles different code paths depending on which macros are defined, commonly used to isolate platform-specific code.

Modern C++ Syntax Shortcuts

C++11 through C++23 added syntax that shortens common patterns without changing what the underlying code does.

auto, already covered under variable declaration, extends the same type inference to function return types and lambda parameters.

Range-based for loops, already covered under control flow, iterate a container directly: for (auto& item : container) replaces manual index tracking entirely.

Structured bindings, added in C++17, unpack a pair, tuple, or struct into named variables in one line: auto [key, value] = *map.begin();

nullptr, added in C++11, replaced the older NULL macro with a proper pointer-typed keyword, closing a long-standing source of overload-resolution bugs where NULL silently converts to an integer.

constexpr tells the compiler to evaluate a function or variable at compile time whenever its inputs allow it, moving work out of the running program entirely.

FAQ on C++

What does the ++ in C++ mean?

++ is C's increment operator, meaning "one more than." Bjarne Stroustrup chose the name in 1983 to signal that C++ extends the original C programming language with new features like classes, rather than replacing it outright.

What is the difference between C and C++?

C is a procedural language. C++ adds object-oriented programming, templates, and exception handling on top of it, though most valid C code still compiles as valid C++ with stricter type checking applied.

What is the difference between a struct and a class in C++?

Both group data and functions into one type. The only default difference is access level: struct members are public by default, class members are private, which is why developers typically reach for struct with plain data.

Does C++ have garbage collection?

No. C++ relies on manual memory management and RAII instead of automatic garbage collection. Destructors and smart pointers like unique_ptr and shared_ptr release memory deterministically, without the pause times a garbage collector introduces.

What is undefined behavior in C++?

Undefined behavior is code the C++ standard places no requirements on, like reading past an array's bounds. The compiler can do anything: crash, produce wrong output, or appear to work fine until conditions change.

What is the Rule of Three in C++?

If a class defines a custom destructor, copy constructor, or copy assignment operator, it usually needs all three. Each manages the same resource, so the compiler-generated versions of the other two are likely wrong.

What is move semantics in C++?

Move semantics, added in C++11, let a program transfer ownership of a resource instead of copying it. std::move casts an object to an rvalue reference, so containers like std::vector can relocate data without reallocating memory.

What is the difference between std::endl and \n in C++?

std::endl inserts a newline and flushes the stream's buffer immediately, which is slower under repeated calls. \n writes only the newline character, making it the faster default choice inside performance-sensitive loops.

Is C++ still worth learning?

Yes, particularly for systems programming, game engines, and embedded work where raw performance and hardware control matter. It also builds a mental model of memory and execution that transfers directly to languages like Rust or Java.

What is a header-only library in C++?

A header-only library ships its entire implementation inside header files, with no separate .cpp files to compile or link. Including the header via #include is enough, which trades longer compile times for simpler distribution.