Препроцессор
                            // Комментарий до конца строки
                            /* Многострочный комментарий */
#include  <stdio.h>         // Вставить содержимое заголовка, поиск по стандартным путям заголовков
#include "myfile.h"         // Вставить содержимое заголовка, поиск начиная с текущего каталога
#define X some text         // Замена X на some text
#define F(a, b) a + b       // Замена F(1, 2) на 1 + 2
#define X \
 some text                  // Многострочное определение макроса
#undef X                    // Удаляет определение макроса
#if defined(X)              // Условная компиляция (#ifdef X)
#else                       // Опциональная ветвь else (эквивалент #ifndef X или #if !defined(X))
#endif                      // Завершает блоки #if, #ifdef

Литералы и переменные
255, 0377, 0xff, 0b1011     // Целые числа (десятичные, восьмиричные, шестнадцатиричные, двоичные)
2147483647L, 0x7fffffffl    // Целые числа long (64bit на 64-битных UNIX платформах, 32bit на остальных)
123.0, 1.23e2               // Действительные числа двойной точности (double)
'a', '\141', '\x61'         // Символы (литеральный, восьмиричный код, шестнадцатиричный код)
'\n', '\\', '\'', '\"'      // Литералы символа переноса строки, обратного слеша, одинарной кавычки, двойной кавычки
"string\n"                  // Массив символов, завершённый переносом строки и нулевым символом \0
"hello" "world"             // Конкатенация двух литералов
true, false                 // Булевы константы ИСТИНА и ЛОЖЬ
nullptr                     // Литерал указателя, указывает на нулевой (недопустимый) адрес
Объявления
int x;                      // Объявление переменной x типа int, т.е. целого числа (значение не определено)
int x = 255;                // Объявление переменной и инициализация значением 255
unsigned ing x = 255u;      // Объявление переменной типа беззнаковое целое число, инициализация значением 255.
char c = 'a';               // Объявление переменной, хранящей символ (однобайтовый, знаковый или беззнаковый)
unsigned char u = 255;      // Объявление переменной типа "беззнаковый символ"
signed char s = -1;         // Объявление переменной типа "знаковый символ"
float f;                    // Знаковое действительное число одинарной точности (обычно 4 байта)
double f;                   // Знаковое действительное число двойной точности (обычно 8 байт)
bool b = true;              // Булевы переменные инициализируются значением true либо false
int a[10];                  // Массив из 10 целых числе (индексация начиная с нуля, от a[0] до a[9])
int a[] = { 0, 1, 2 };      // Инициализированный массив (эвивалентно a[3] = { 0, 1, 2 };)
int a[2][2] = { { 1, 2 },    // Двумерный массив, т.е. массив массивов целых чисел
                { 4, 5 } };
char str[] = "hello";       // Строка в стиле языка C (6 элементов, включая '\0' в конце)
std::string str = "Hello"   // Строка в стиле C++, инициализированная значением "Hello"
std::string str = R"(Hello
World)";                    // Строка в стиле C++, инициализированная значением "Hello\nWorld"
int* ptr = nullptr;         // ptr - указатель на адрес в памяти, предназначенный для хранения int
const char* str = "hello";  // str указывает на анонимный массив, хранящий значение "hello\0"
void* ptr = nullptr;        // ptr хранит адрес нетипизированной области памяти
int& ref = x;               // ref - ссылка на int x (по сути синоним x)

enum Weekend                // Weekend - это тип, способный хранить WK_SATURDAY или WK_SUNDAY
{
    WK_SATURDAY,
    WK_SUNDAY,
};
Weekend day;                // day - переменная типа weekend
enum Weekend                // На уровне ассембера тип Weekend представлен целым числом,
{                           // Здесь для WK_SATURDAY и WK_SUNDAY явно назначаем значения 0 и 1
    WK_SATURDAY = 0,
    WK_SUNDAY = 1,
};
enum class Color            // Современный enum: константы не попадают в глобальную область видимости,
{                           //  обращаться к ним можно конструкциями Color::Red и Color::Blue.
    Red,
    Blue,
};
Color color = Color::Red;   // Объявляем переменную типа color, инициализируем значением Color::Red.

typedef char* ZeroedString; // Устаревшее добавление синонима типа: объявить `ZeroedString x;` значит объявить `char* x;`.
using ZeroedString = char*; // Современное добавление синонима типа.

const int c = 3;            // Константные значения инициализируются один раз и не могут быть повторно присвоены.
const int pow = GetPower(); // Инициализация константы может быть динамической.
const int* ptr = arr;       // Нельзя записывать значения в память, на которую указывает ptr (т.е. в элементы arr).
int* const ptr = arr;       // Нельзя менять значение указателя ptr (но можно записывать в память, куда он указывает)
const int* const ptr = arr; // Как ptr, так и память, на которую он указывает, недоступны для записи.
const int& cref = x;        // cref не получится использовать для изменения x
int8_t, uint8_t, int16_t,   // Целые числа с фиксированным числом бит, не зависящим от платформы.
uint16_t, int32_t, uint32_t,
int64_t, uint64_t

auto it = m.begin();        // Объявляем переменную it, тип выставляется автоматически как тип инициализатора m.begin()
auto const param            // Объявляем переменную param, тип выставляется автоматически, но будет константным.
    = config["param"];
auto& instance              // Объявляем переменную instance, тип выставляется автоматически, но будет ссылочным
    = singleton::instance();
Классы памяти
int x;                      // Память для x выделяется автоматически (обычно на стеке) и существует только в области видимости.
static int x;               // Память для x выделяется в глобальной области (даже если x объявлена внутри функции).
extern int x;               // Переменная x объявлена, но её расположение в памяти будет указано в другом месте.
Инструкции
x = y;                      // Любое невложенное выражение (включая вызов функции, присваивание) является инструкцией.
int x = 0;                  // Объявления являются инструкциями.
;                           // Пустая инструкция.
{                           // Блок внутри {} является одной инструкцией
  int x;                    //  Области видимости x - от объявления до конца блока.
}

if (x) a;                   // Если значение x - ИСТИНА (не 0), то выполнить инструкцию print('a');
else if (y) print('b');     // Если не x и y, выполняем print('b'), else if необязателен, его можно повторять;
else print('c');            // Если не x и не y, выполняем print('c') else необязателен.

while (x)                   // Повторяем 0 или более раз, пока выражение x имеет значение ИСТИНА
    print(x);

for (int i = 0; i < 10; ++i)// Эквивалентно `int i = 0; while (i < 10) { doSomething(); ++i; }`
    doSomething();

int arr[] = { 5, 10, 20 };
for (auto x : arr)          // Range-based цикл for, x последовательно принимает все значения элементов arr.
    print(x);

do                          // Эквивалентно цепочке `foo(); while(x) foo()`;
{
    foo();
} while (x);

switch (x)                  // Switch выполнит прыжок на один из case/default
{                           //  x должен быть целочисленным типом (enum допускается, строки - нет)
    case X1: a;             // Если x == X1 (X1 должно быть константой времени компиляции), продолжаем выполнение отсюда
    case X2: b;             // Иначе если x == X2, продолжаем выполнение отсюда
    default: c;             // В противном случае продолжаем выполнение отсюда (метка default опциональная)
}

switch (x)
{
    case X1:
        a;
        break;              // break прерывает выполнение после метки до конца switch,
    default:                //  если break нет, то после a будет продолжено выполнени и выполнено c, в отличии от инструкции if
        c;
}

break;                      // Выход из ветвления switch либо из цикла while, do, или for
continue;                   // Прыжок в конец цикла while, do или for
return x;                   // Завершает выполнение функции, возвращает значение x

try
{
    a;
}
catch (const ExceptionType &ex)
{
    b;                      // Если a; бросает исключение типа ExceptionType, выполнение продолжается здесь
}
catch (...)
{
    c;                      // Если a; бросает какое-либо другое исключение, выполнение продолжается здесь
}
Функции
int sum(int a, int b);      // Объявление функции sum, принимающей два параметра int и возвращающей int
void fn();                  // fn - это процедура без параметров (псевдо-тип void означает, что возвращаемого значения нет)
void fn(int a = 12);        // можно написать fn(), и это будет эквивалентно f(12), т.е. параметр имеет значение по умолчанию

int sum(int a, int b)       // Определение функции sum: тело функции станет её реализацией.
{
    statements;
}

T operator+(T x, T y)       // В выражении вида "a + b", где a, b имеют тип T, вызывается тело функции operator+(a, b)
{
    // Реализация оператора...
}

T operator-(T x);           // Унарный оператор "минус", вызывается в выражениях вида "-a"

T operator++();             // Префиксная форма оператора a++ или a--

T operator++(int);          // Постфиксная форма оператора a++ или a-- (параметр типа int игнорируется)

extern "C"                  // Все функции, объявленные внутри блока extern "C", не будут подвержены name mangling.
{                           // Это полезно, если функции могут быть вызваны из другого языка (например, из C).
    void fn();
}
Типы параметров и возвращаемого значения функции могут быть любыми. Функция должна быть либо объявлена (без тела), либо определена (с телом функции) до первого вызова. Можно сначала объявить функцию (и вызвать где-либо), а затем определить (возможно, в другом файле). Каждая программа состоит набора файлов, каждый файл содержит набор глобальных переменных и набор функций. Одна из функций — main — служит точной входа в программу.
int main()
{
    statements...
}

int main(int argc, char* argv[])
{
    statements...
}
• argv является массивом длины argc, хранящим строки параметров командной строки
• по общему соглашению, main возвращает 0 при успешном выполнении программы, ненулевой код после возникновения ошибки
Функции с различными параметрами могут иметь одинаковое имя (это называется перегрузка функций).
Могут быть перегружены все операторы, кроме “::”, “.”, “.*”, “?:”. Перегрузка не меняет приоритет оператора.
Выражения
Операторы сгруппированы по приоритету, сперва наивысший приоритет. Унарные операторы и присваивание вычисляются справа налево, все остальные слева направо. Во время выполнения программы не происходит проверок на выход за границы массива, на недопустимые указатели и т.п.
T::X                        // Доступ к символу X, объявленному в классе T
N::X                        // Доступ к символу X, объявленному в пространстве имён N
::X                         // Доступ к глобальному имени X (может помочь избежать конфликтов имён)

t.x                         // Поле или метод объекта t (структуры или класса)
ptr->x                      // Поле или метод того объекта (структуры или класса), на который указывает ptr
arr[i]                      // i-й элемент массива arr
fn(x, y)                    // Вызов функции fn с аргументами x и y
T(x, y)                     // Конструирование объекта класса T, в конструктор передаются значения x и y
x++                         // Увеличивает x на единицу, но возвращает старое значение (постфиксная форма)
x--                         // Вычитает единицу из x, но возвращает старое значение (постфиксная форма)
typeid(x)                   // Вычисляет значение типа std::type_info для объекта x
typeid(T)                   // Вычисляет (обычно при компиляции) значение типа std::type_info для типа T
dynamic_cast<T>(x)          // Приводит x к типу T во время выполнения, выполняет проверку с помощью
                            //  информации о виртуальных методах объекта.
static_cast<T>(x)           // Приводит x к типу T без каких-либо проверок
reinterpret_cast<T>(x)      // Интерпретирует байты объекта x как байты объекта типа T
const_cast<T>(x)            // Конвертирует x к типу T, убирая модификаторы const и volatile

sizeof x                    // Вычисляет число байт, используемое для хранения объекта x
sizeof(T)                   // Вычисляет число байт, используемое для хранения типа T
++x                         // Увеличивает x на единицу, возвращает новое значение (префиксная форма)
--x                         // Вычитает единицу из x, возвращает новое значение (префиксная форма)
~x                          // Битовая операция: вычисляет битовое дополнение x
!x                          // Возвращает true если x имеет значение ЛОЖЬ или 0, иначе false
-x                          // Унарный минус
+x                          // Унарный плюс
&x                          // Вычисление адреса x
*ptr                        // Доступ к памяти, на которую указывает ptr (т.е. разыменование, *&x эквивалентно x)
new T                       // Выделяет память для объекта типа T, возвращает его адрес
new T(x, y)                 // Выделяет память для объекта типа T, в конструктор передаёт x, y, возвращает адрес
new T[n]                    // Выделяет память для массива из n элементов типа T
delete ptr                  // Удаляет объект, на который указывает ptr, возвращает системе занятую им память
delete[] ptr                // Удаляет массив объектов, на которые указывает ptr
(T) x                       // Преобразует x к типу T (устаревшая форма, используйте static_cast или в крайнем случае reinterpret_case)

x * y                       // Умножение
x / y                       // Деление (для целых чисел происходит отбрасывание дробной части)
x % y                       // Получение остатка (знак результата совпадает со знаком x)
x + y                       // Сложение целых чисел либо целочисленного смещения и указателя
                            //  (для указателей эквивалентно выражению &x[y])
x - y                       // Вычитание целых чисел либо получение смещения от указателя y к указателю x
x << y                      // Битовая операция: смещение x на y бит влево, эквивалентно x * pow(2, y)
x >> y                      // Битовая операция: смещение x на y бит вправо, эквивалентно x / pow(2, y)

x < y                       // ИСТИНА, если x меньше чем y
x <= y                      // ИСТИНА, если x меньше или равен y
x > y                       // ИСТИНА, если x больше чем y
x >= y                      // ИСТИНА, если x больше или равен y

x & y                       // Битовая операция "И": 3 & 6 равно 2
x ^ y                       // Битовая операция "ИСКЛЮЧАЮЩЕЕ ИЛИ": 3 ^ 6 равно 5
x | y                       // Битовая операция "ИЛИ": 3 | 6 равно 7
x && y                      // Логическое "И": вычисляет x, и если x ЛОЖЬ, возвращает ЛОЖЬ, иначе
                            //  вычисляет y и возвращает его булево значение (ИСТИНА или ЛОЖЬ).
x || y                      // Логическое "ИЛИ": вычисляет x, и если x ИСТИНА, возвращает ИСТИНА,
                            //  иначе вычисляет y и возвращает его булево значение (ИСТИНА или ЛОЖЬ).
x = y                       // Присваивает значение y переменной x, возвращает новое значение x
x += y                      // Эквивалент x = x + y, также существуют -= *= /= <<= >>= &= |= ^=
x ? y : z                   // Тернарный оператор: возвращает y если x ИСТИНА, иначе z
throw x                     // Выбрасывает исключение, а если оно не поймано, аварийно завершает программу
x, y                        // Вычисляет x и y, затем возвращает y (редко используется)
Анонимные функции
Анонимные функции поддерживают замыкание, т.е. захват и удержание внешних переменных.
auto fn1 = [] {             // Простая анонимная функция типа `void()`
    /* тело функции */;
};
auto fn2 = [] {
};
static_assert(!std::is_same_v(fn1, fn2),
              "Две одинаковые с виду лямбды имеют разные типы."
              "Каждая лямбда принадлежит уникальному типу данных,"
              "имеющему operator().");

int value1 = 10;            // Захватим value1 по значению: [value]
int value2 = 10;            // Захватим value2 по ссылке: [&value2]
auto fn = [value1, &value2] {
    ++value1;
    ++value2;
};
assert(value1 == 10);       // Значение не изменилось (изменялась копия)
assert(value2 == 11);       // Значение изменилось

auto sum = [](int a, int b) -> int {
    return a + b;
};
int x = sum(10, 50);        // sum принимает 2 параметра int, возвращает int

int count = 0;              // mutable означает, что захваченное
                            //  по значению сохраняется между вызовами
auto bump = [count]() mutable {
    ++count;
    printf("count: %d", count);
};
bump();                     // печатает 'count: 1'
bump();                     // печатает 'count: 2'

auto sum = [](auto && a, auto && b) {
    return a + b;           // возвращаемый тип определится автоматически
};
double x = sum(10.2, 40);   // sum - обобщённая анонимная функция,
                            //  псевдо-тип auto служит местом
                            //  для параметра любого типа

// Условие в if constexpr вычисляется при компиляции,
//  это позволяет в одной обобщённой анонимной функции
//  обработать разные типы данных.
auto println = [](auto && value) {
    if constexpr (typeid(value) == typeid(int)) {
        printf("%d\n", value);
    }
    if constexpr (typeid(value) == typeid(std::string)) {
        printf("%s\n", value.c_str());
    }
};
Классы
class T                     // Новый тип данных T
{
private:                    // В этой секции символы доступны только для методов класса T
protected:                  // В этой секции символы доступны ещё для классов-наследников класса T
public:                     // В этой секции символы доступны для всех желающих
    int x;                  // Поле класса, располагается в памяти как часть объекта класса
    void f();               // Метод (функция, являющаяся членом класса)
    void g() { return; }    // Метод с телом, встроенным в класс
    void h() const;         // Метод не сможет модифицировать какие-либо поля класса
    int operator+(int y);   // t + y превращается в вызов метода-оператора t.operator+(y)
    int operator-();        // -t превращается в вызов метода-оператора t.operator-()
    T(): x(1) {}            // Конструктор использует списки инициализации конструктора: ": x(1)"
    T(const T& t): x(t.x) {}// Конструктор копирования
    T& operator=(const T& t)// Оператор присваивания
    {
        x = t.x;
        return *this;
    }
    ~T();                   // Деструктор (автоматически вызываемая процедура очистки)
    explicit T(int a);      // Позволяет писать t = T(3), но не t = 3
    T(float x): T((int)x) {}// Делегирующий конструктор, делегирует инициализацию в T(int)
    operator int() const
    {return x;}             // Оператор преобразования в int, допускает код x = int(t)
    static int y;           // Поле y становится единственным и глобальным для всех объектов типа T
    static void l();        // Метод становится методом класса, доступен для вызова через T::l()
    class Z {};             // Вложенный класс T::Z
    typedef int Int;        // T::Int - синоним типа int
};
void T::fn()                // Тело метода fn класса T
{
    this->x = x;            // this - это адрес текущего объекта (здесь поле x копируется в поле x)
}
int T::y = 2;               // Инициализация статической переменной
                            //  (должна быть вне класса для всех типов, кроме целочисленных)
T::l();                     // Вызов статического метода (метода класса)
T t;                        // Создание объекта t типа T с неявным вызовом конструктора T()
t.f();                      // Вызов метода f объекта t

struct T {                  // Эквивалентно коду class T { public:
    virtual void i();       // Реализация виртуального метода i может быть перегружена классом-наследником
    virtual void g() = 0;   // Чисто виртуальный метод, должен быть перезаписан в классе-наследнике
};
class U : public T          // Дочерний класс U наследует все поля и методы базового класса T
{
public:
    void g(int) override;   // Перегрузка метода g
};
Все классы по умолчанию имеют конструктор копирования, оператор присваивания и деструктор, которые рекурсивно вызывают соответствующие методы для базовых классов и полей. Примитивные типы, такие как целые числа, указатели и т.п., копируются прямым копированием памяти, а их деструктор ничего не делает. Конструкторы, операторы присваивания и дееструкторы никогда не копируются. Если у класса не указан ни один конструктор, то у него есть конструктор по умолчанию без аргументов, который лишь вызывает другие конструкторы.
Шаблоны
template <class T>          // Функция fn будет перегружена для любых типов-аргументов
T fn(T t);

template <class T>
class X                     // Класс параметризуется типом T
{
    X(T t);                 // Конструктор принимает значение типа T
};

template <class T>
X<T>::X(T t)                // Определение конструктора (метода) за пределами класса
{
}

X<int> x(3);                // Тип объекта x - это X<int>, специализация шаблонного класса X

template <class T, class U = T, int n = 0>
class A                     // Шаблон имеет типы-параметры с типами по умолчанию
{
};
Пространства имён
namespace N {class T {};}   // Помещает имя T в пространство имён N
N::T t;                     // Используем имя T из пространства имён N
using namespace N;          // Все символы из пространства имён N теперь доступны без префикса N::
using N::T;                 // Символ N::T теперь доступен без префикса N::
Отладочный механизм assert
#include <cassert>          // Включаем cassert
assert(cond);               // Если условие cond не выполняется, распечатать сообщение и аварийно
                            //  завершить программу. В Release-конфигурациях объявлен макрос
                            //  NDEBUG, который превращает assert в пустой макрос. Пустой макрос
                            //  ничего не выполняет и не вычисляет выражение cond.