Modern C++ Cheat Sheet

1.1 Variables & Basic Types

// value initialization
int  i{};           // 0
double d{3.14};     // brace (uniform) init – avoids narrowing
auto  name = "Ada"; // type deduced as const char*

• auto deduces most types, use auto* or auto& to deduce ptr/ref.
• decltype(expr) yields the type of expr.
• constexpr variables are evaluated at compile-time when possible.

1.2 Namespaces & using

namespace math::geometry {
    double tau() { return 6.283; }
}
using math::geometry::tau;   // selective
using namespace std::string_literals; // literal suffixes

1.3 Input/Output (<iostream>)

#include <iostream>
int main(){
    std::cout << "enter age: ";
    int age{};
    if (std::cin >> age){
        std::cout << "in months: " << age*12 << '\n';
    }
}

2.1 Conditionals

if (auto id = get_user_id(); id > 0) { … }
switch (const ch = std::tolower(c); ch) {
  case 'y': [[fallthrough]];
  case 'n': break;
  default:  std::cerr << "invalid";  
}

2.2 Loops

for (size_t i=0; i<v.size(); ++i) { … }
for (auto& e : v) { e *= 2; }        // range-for
while (auto line = read(); !line.empty()) { … } // C++17 init-stmt

2.3 Pattern Matching – std::visit & if constexpr

std::variant<int, std::string> v = 12;
std::visit([](auto& val){
    if constexpr (std::is_same_v<decltype(val), int>)
        std::cout << "int: " << val;
    else
        std::cout << "string: " << val;
}, v);

3.1 Function Basics

[[nodiscard]] int add(int a, int b = 0){ return a + b; }

• [[nodiscard]] warns if result is ignored.
• Default arguments appear in declarations only.

3.2 Overloading & Inline Namespaces

double area(double r);        // circle
double area(double w, double h); // rectangle

3.3 Lambdas

auto square = [](auto x){ return x*x; };

int total = std::accumulate(v.begin(), v.end(), 0,
             [](int s, int n){ return s+n; });

auto stateful = [count = 0]() mutable { return ++count; };

3.4 Trailing Return & Concepts (C++20)

template<std::integral I>
auto gcd(I a, I b) -> I { … }

4.1 Declaring a Class

class Point {
    double x_, y_;
public:
    Point(double x=0,double y=0):x_{x},y_{y}{}            // ctor
    double x() const noexcept { return x_; }               // getter
    void   translate(double dx,double dy){ x_+=dx; y_+=dy; }
    [[nodiscard]] double length() const { return std::hypot(x_,y_); }
};

4.2 Special Member Functions (Rule of Zero)

• ~T() – destructor
• T(const T&), T& operator=(const T&)
• T(T&&), T& operator=(T&&)
• Prefer RAII + STL to avoid explicit resource management.

4.3 Inheritance, virtual & override

struct Shape {
    virtual ~Shape() = default;
    virtual double area() const = 0;
};
struct Circle : Shape {
    double r{};
    explicit Circle(double r):r{r}{}
    double area() const override { return std::numbers::pi * r*r; }
};

4.4 Polymorphic Use

std::unique_ptr<Shape> s = std::make_unique<Circle>(2.0);
std::cout << s->area();  // dynamic dispatch

5.1 Function Templates

template<typename T>
T max(T a, T b){ return (a > b) ? a : b; }

5.2 Class Templates & Partial Specialization

template<class T>
class Stack {
    std::vector<T> data_;
public:
    void push(const T& v){ data_.push_back(v); }
    T    pop(){ T v = data_.back(); data_.pop_back(); return v; }
};

5.3 Concepts & Requires Clauses (C++20)

template<typename T>
concept Hashable = requires(T a){ { std::hash<T>{}(a) } -> std::convertible_to<size_t>; };

template<Hashable K, typename V>
using HashMap = std::unordered_map<K,V>;

5.4 Fold Expressions (variadic templates)

template<typename... Ts>
auto sum(Ts... xs){ return (xs + ... ); }

6.1 Containers

• std::vector – contiguous, fast push_back/iteration.
• std::deque – double-ended queue.
• std::list, std::forward_list.
• std::map / std::unordered_map.

std::vector<int> a{1,2,3};
a.push_back(4);          // O(1) amortized
for (auto n : a) std::cout << n;

6.2 Algorithms (<algorithm>)

std::ranges::sort(a);                       // C++20 ranges
auto pos = std::ranges::find(a, 3);
std::ranges::transform(a, a.begin(), square);

6.3 Iterators & Ranges

auto odds = a | std::views::filter([](int n){return n%2;})
               | std::views::transform([](int n){return n*3;});
for(int n: odds) std::cout << n;

6.4 String View, Format, Filesystem

#include <format>
std::string s = std::format("coords: ({}, {})", p.x(), p.y());

#include <filesystem>
for(auto& e : std::filesystem::directory_iterator(".")) std::cout << e.path();

7.1 Smart Pointers

auto sp  = std::make_shared<Widget>();  // shared ownership
auto up  = std::make_unique<Widget>(); // exclusive
std::weak_ptr<Widget> wp = sp;         // non-owning

7.2 new & delete

Use std::make_unique/make_shared instead of raw new. Direct delete is error-prone.

7.3 RAII Patterns

std::lock_guard lg{mtx};   // locks in ctor, unlocks in dtor

8.1 Exceptions

try {
    if(!file) throw std::runtime_error("cannot closed");
} catch(const std::exception& ex){
    std::cerr << ex.what();
}

8.2 Alternative – std::expected (C++23)

std::expected<std::string,std::error_code> read_file(std::string_view path);
auto content = read_file("data.txt");
if (!content){ std::cerr << content.error().message(); }

9.1 std::thread

std::thread t([]{
    heavy_task();
});
t.join();

9.2 Futures & Async

auto fut = std::async(std::launch::async, compute);
std::cout << fut.get();

9.3 Atomic & Mutex

std::atomic<int> counter{};
std::mutex mtx;

9.4 Coroutines (C++20)

task<void> run(){
    for(int i=0;i<3;++i){
        co_await sleep_for(1s);
        std::cout << i;
    }
}

10.1 Creating a Module

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

10.2 Importing

import math;
int v = math::add(1,2);

Modules speed-up builds and improve encapsulation compared to headers.

11.1 g++ & clang++

g++ -std=c++23 -O2 -Wall main.cpp -o main

11.2 CMake (≥3.27)

cmake_minimum_required(VERSION 3.27)
project(MyApp VERSION 1.0 LANGUAGES CXX)
add_executable(myapp main.cpp)
target_compile_features(myapp PUBLIC cxx_std_23)

• std::string s = std::to_string(num);
• std::erase_if(vec, pred); (C++20) – remove by predicate.
• std::clamp(x, lo, hi);
• std::views::iota(0,10) – lazy range.

13.1 Operator Precedence (high→low)

::   .*  ->*       // scope / ptr-to-member
++ -- () []         // postfix
++ -- + - ! ~       // unary
* / %               // multiplicative
+ -                 // additive
<< >>              // shifts
< ≤ > ≥             // relational
== !=               // equality
&                   // bitwise AND
^                   // XOR
|                   // OR
&&                 // logical AND
||                  // logical OR
?:                  // conditional
= += …              // assignment
,                   // comma

13.2 Keyword Glossary

alignas, concept, constexpr, co_await, delete, export,
explicit, friend, inline, mutable, noexcept, override,
requires, static_cast, thread_local, typename, volatile …