• 1 Запрещены и удалены
  • 1.1 Запрещены операции с volatile
  • 1.2 Удалена агрегатная инициализация при наличии пользовательского конструктора
  • 1.3 Удалены запреты из C++17
  • 1.4 Прочие запреты из языка
  • 1.5 Прочие запреты из библиотеки
• 2 Язык
  • 2.1 Мелкие изменения
  • 2.2 Модули
  • 2.3 Сопрограммы
  • 2.4 typename объявлен излишним там, где допустим только тип
  • 2.5 Вычисление размера массива в new
  • 2.6 Новые атрибуты
  • 2.7 [[nodiscard]] для конструкторов и с причиной
  • 2.8 Расширен constexpr
  • 2.9 Ключевые слова consteval и constinit
  • 2.10 explicit (bool)
  • 2.11 Трёхзначное сравнение («звездолёт»)
  • 2.12 Концепции
    • 2.12.1 Условно-тривиальная функция
    • 2.12.2 Неявные шаблоны
  • 2.13 Строковые константы как параметры шаблона
  • 2.14 Именованная инициализация структур
  • 2.15 Можно инициализировать структуры круглыми скобками ( )
  • 2.16 Изменения в лямбда-функциях
• 3 Редакционные правки
  • 3.1 Функция noexcept=default больше не забраковывается
  • 3.2 Новые условия неявного перемещения
  • 3.3 Числа со знаком — дополнительный код
  • 3.4 Новая модель памяти
• 4 Библиотека
  • 4.1 Мелкие изменения в библиотеке
  • 4.2 Объявление функций constexpr
  • 4.3 Библиотека форматирования
  • 4.4 Невладеющие указатели на массив (span)
  • 4.5 Библиотека работы с битами <bit>
  • 4.6 Библиотека работы с синхронизированными «потоками вывода» <syncstream>
  • 4.7 Библиотека диапазонов <ranges>
  • 4.8 Библиотека календарей и часовых поясов в <chrono>
  • 4.9 Расширенная библиотека потоков <jthread>, <stop_token>
  • 4.10 Барьеры и засовы
  • 4.11 Разнородный поиск в unordered_set/map
• 5 Реализованы как экспериментальные библиотеки
• 6 Оставлены на будущее
• 7 См. также
• 8 Примечания

• операции ++, --;
• операции += и другие (снят в C++23);
• цепочки присваиваний;
• функции, параметры и возвращаемые значения с модификатором volatile;
• все функции STL, связанные с volatile, кроме некоторых вроде remove_volatile;

struct X {
  int a = 0;  
  X() = default;
};

X x { 5 };  // Си++17: OK
            // Си++20: no matching constructor for initialization of 'X'

• allocator<void> — оказался невостребованным;
• часть функций allocator — дублируется шаблоном allocator_traits;
• raw_storage_iterator — не вызывает конструкторов и потому ограничен по применению;
• get_temporary_buffer — имеет неочевидные подводные камни;
• is_literal_type — бесполезен для обобщённого кода;
• shared_ptr::unique() — из-за ненадёжности в многопоточной среде; если очень надо, используйте use_count;
• result_of — заменён на invoke_result;
• uncaught_exception() — заменён на uncaught_exceptions.
• <ccomplex>, <ciso646>, <cstdalign>, <cstdbool>, <ctgmath> — не имеют смысла в Си++. <complex.h> и прочие оставили для совместимости с Си.

#if __cplusplus < 201103L
  #define noexcept throw()
#endif

• codecvt — на поверку работал очень плохо, комитет призвал пользоваться специализированными библиотеками.
• iterator — проще писать итераторы с нуля, чем основываться на нём.
• потоки char* — непонятно, что взамен.
• неявное создание операции «присвоить», если есть конструктор копирования и деструктор (а также конструктора копирования, если есть присваивание и деструктор) — библиотека всё ещё полагается на это поведение.

• Неявный перехват *this в лямбда-функциях [](){ std::cout << myField; } — из-за неясной семантики. Существует [this](){ std::cout << myField; } для перехвата по указателю и [*this](){ std::cout << myField; } для перехвата по копии.
• Операция «запятая» в индексах a[b,c] для любых a, b и c — из-за неочевидного поведения и желания создать новый синтаксис для многомерных массивов^[7]. Если очень нужно, пишите a[(b,c)].
• Неявные преобразования в перечисляемый тип — для более прогнозируемого поведения новой операции «звездолёт» (<=>, трёхзначное сравнение).
• Сравнение двух массивов — для более прогнозируемого поведения новой операции «звездолёт» (<=>, трёхзначное сравнение). Хотя бы один надо преобразовать в указатель.

• is_pod — вместо сложного понятия «простая структура данных» лучше использовать конкретные свойства типа: тривиально строится, тривиально уничтожается и т. д. Если очень надо (например, для передачи данных между плагинами), эквивалентно is_trivial && is_standard_layout.
• std::rel_ops — новая операция «звездолёт» делает это лучше.
• атомарные возможности shared_ptr — непонятно, как работать с указателем, атомарно или нет. Лучше это определить системой типов, atomic<shared_ptr>.
• string::capacity() — теперь решили, что reserve не будет уменьшать ёмкость.
• string::reserve() — запретили версию без параметров, эквивалентную shrink_to_fit. (До Си++11, да и после тоже, функция reserve(0) была эквивалентна shrink_to_fit.)
• filesystem::u8path — теперь u8string отличается от string.
• ATOMIC_FLAG_INIT, atomic_init, ATOMIC_VAR_INIT — теперь это делает шаблонный конструктор atomic.

• Добавлен беззнаковый тип char8_t, способный содержать единицы UTF-8.
• using EnumClass, позволяющий сделать код в ключевых местах менее загромождённым.
• Дополнительная инициализация в for по объекту: for (T thing = f(); auto& x : thing.items())^[8]. Если возвращаемый items() объект временный, его срок жизни расширяется на весь цикл, но другие временные объекты благополучно исчезают, и если временный на поверку f(), запись for (auto& x : f().items()) ошибочная.

// helloworld.cpp
export module helloworld;  // module declaration
import <iostream>;         // import declaration
 
export void hello() {      // export declaration
    std::cout << "Hello world!\n";
}

task<> tcp_echo_server() {
  char data[1024];
  for (;;) {
    size_t n = co_await socket.async_read_some(buffer(data));
    co_await async_write(socket, buffer(data, n));
  }
}

• тип после new — auto x = new Object::Thing;
• тип в using — using Thing = Object::Thing;
• заключительный возвращаемый тип auto f() -> Object::Thing;
• тип по умолчанию в шаблоне template<class T = Object::Thing> T f();
• тип в static_cast, const_cast, reinterpret_cast, dynamic_cast — auto x = static_cast<Object::Thing>(y);
• тип переменной/функции в пространстве имён (в том числе в глобальном) или классе — Object::Thing variable;
• тип параметра функции/шаблона, если есть идентификатор (кроме выражений, связанных с вычислением значения параметра по умолчанию) — void func(Object::Thing x);

template<class T> T::R f();      // Теперь OK, тип в глобальном пространстве имён
template<class T> void f(T::R);  // Нужен typename, без него это попытка создания void-переменной, инициализированной T::R
template<class T> struct S {
  using Ptr = PtrTraits<T>::Ptr; // Теперь OK, тип в using
  T::R f(T::P p) {               // Теперь OK, тип в классе
    return static_cast<T::R>(p); // Теперь OK, static_cast
  }
  auto g() -> S<T*>::Ptr;      // Теперь OK, заключительный возвращаемый тип
};
template<typename T> void f() {
  void (*pf)(T::X);   // Остаётся OK, переменная типа void*, инициализированная T::X
  void g(T::X);       // Нужен typename, без него это попытка создания void-переменной, инициализированной T::X
}

double a[]{1,2,3};                // Остаётся OK
double* p = new double[]{1,2,3};  // Теперь OK

• [[no_unique_address]] — переменная без данных может не занимать места, а в «дырах» переменной с данными можно держать другие переменные. Но: переменные одного типа никогда не могут находиться по одному адресу.

template <class Allocator> class Storage {
private:
  [[no_unique_address]] Allocator alloc;
};

• [[likely]] / [[unlikely]] — отмечают, под какие ветви надо оптимизировать программу для лучшей работы предсказателя переходов. Эта методика фактически уже реализована в некоторых компиляторах — __builtin_expect в GCC.

if (x > y) [[unlikely]] {
  std::cout << "Редко случается" << std::endl;
} else [[likely]] {
  std::cout << "Часто случается" << std::endl;
}

struct my_unique {
  my_unique() = default; // не захватывает ресурса
  [[nodiscard]] my_unique(int fd) {} // захватывает ресурс
  ~my_unique() noexcept {}
};

void foo() {
  my_unique(42);    // Предупреждение
  my_unique();      // OK, этому конструктору можно
  my_unique x(43);  // OK, именованный объект
}

struct Container {
	[[nodiscard("Чревато утечкой памяти")]] Data* release();
	[[nodiscard("Вы хотели clear?")]] bool empty() const;
};

• вызывать виртуальные функции^[15];
• вызывать деструкторы, которые тоже должны быть constexpr;
• менять активное поле union^[16] — он изначально (с Си++11) может участвовать в constexpr, помеченный на манер variant, а доступ к неактивному полю лишает функцию константности;
• работать с try — блок перехвата ничего не делает, а выброс исключения в таком контексте, как и раньше, вычислит функцию при исполнении^[17];
• использовать dynamic_cast и typeid^[18];
• new, с некоторыми ограничениями^[19];
• asm, если тот не вызывается при компиляции;
• неинициализированные переменные.

• consteval в функциях: требует, чтобы функция выполнялась при компиляции. Вызов из контекста, невыполнимого при компиляции, запрещён. Consteval крайне редок и обычно применяется из-за особой природы, связанной с процессом компиляции, константными вычислениями и самопроверками кода (source_location::current — нельзя получить при выполнении, конструктор basic_format_string — проверка соответствия между строкой и параметрами при компиляции), или просто из-за плохой производительности. В заголовках совместимости со старыми компиляторами заменяется на constexpr.
• constinit в переменной: требует, чтобы переменная вычислялась при компиляции. Сама переменная может быть и не константной. В заголовках совместимости со старыми компиляторами заменяется на пустую строку.

consteval int sqr(int n)
  { return n * n; }
 
constinit const auto res2 = sqr(5);

int main()
{
  int n;
  std::cin >> n;
  std::cout << sqr(n) << std::endl;   // ошибка, невычислимо при компиляции
}

// Было, std::forward опущен для краткости
template<class T> struct Wrapper {
  template<class U, std::enable_if_t<std::is_convertible_v<U, T>>* = nullptr>
  Wrapper(U const& u) : t_(u) {}
  
  template<class U, std::enable_if_t<!std::is_convertible_v<U, T>>* = nullptr>
  explicit Wrapper(U const& u) : t_(u) {}

  T t_;
};

// Стало
template<class T> struct Wrapper { 
  template<class U> 
  explicit(!std::is_convertible_v<U, T>) 
    Wrapper(U const& u) : t_(u) {} 

  T t_; 
};

• Частичный порядок: меньше, эквивалентны, больше, несравнимы.
• Слабый порядок: меньше, эквивалентны, больше. Может случиться, что у эквивалентных объектов значение какого-то общедоступного поля или функции может разниться. Понятие «эквивалентны» транзитивно.
• Сильный (линейный) порядок (меньше, равны, больше). Равные объекты различимы разве что по адресу.

class PersonInFamilyTree { // ...
public:
  std::partial_ordering operator<=>(const PersonInFamilyTree& that) const {
    if (this->is_the_same_person_as ( that)) return partial_ordering::equivalent;
    if (this->is_transitive_child_of( that)) return partial_ordering::less;
    if (that. is_transitive_child_of(*this)) return partial_ordering::greater;
    return partial_ordering::unordered;
  }
};

template <class T>
concept bool EqualityComparable() { 
    return requires(T a, T b) {
        {a == b} -> Boolean;  // Концепция, означающая тип, преобразуемый в boolean
        {a != b} -> Boolean;
    };
}

template <typename T>
struct X {
    X(X const&) requires C<T> = default;
    X(X const& ) {}
};

std::sort(a.begin(), a.end(),
     // Неявно-шаблонная лямбда-функция Си++14
     [](const auto& x, const auto& y) { return (x.f < y.f); }); 

void f(std::integral auto x);                   // теперь OK
template <std::integral T> void f(T x);         // эквивалент
template <std::integral auto X> void g(int x);  // теперь OK
void h(auto x);            // также впоследствии разрешили

template <auto& str>
void f() {
  // str = char const (&)[7]
}
f<"foobar">();

union FloatInt {
  float asFloat;
  int32_t asInt;
};
FloatInt x { .asInt = 42 };

• именованная инициализация массивов int arr[3] = {[1] = 5}; — начиная с Си++11 квадратные скобки в начале выражения означают лямбда-функцию.
• объявление не по порядку Point p { .y=20, .x=10 }; — конфликтует с автодеструкторами Си++: сконструировали в одном порядке, разрушили в другом?
• именованная инициализация элементов вложенной структуры struct B b = {.a.x = 0}; — редко используются
• смешение именованной и порядковой инициализации: Point p {.x = 1, 2};

struct A {
  int a;
  int&& r;
};

int f();
int n = 10;

A a1{1, f()};               // OK, продление жизни
A a2(1, f());               // Компилируется, но висячая ссылка
A a3{1.0, 1};               // Ошибка: сужение типа
A a4(1.0, 1);               // Компилируется, но висячая ссылка
A a5(1.0, std::move(n));    // OK

// Было
auto f = [](auto vector) {
  using T = typename decltype(vector)::value_type;
  ...
};

// Стало
auto f = []<typename T>(std::vector<T> vector) {
  ...
};

    std::priority_queue<
        int,                                  // тип элемента
        std::vector<int>,                     // тип контейнера
        decltype( [](int a, int b)->bool{     // тип функции сравнения элементов
                   return a>b;
        })>  q;

// Было
template <class... Args>
auto delay_invoke_foo(Args... args) {
    return [tup=std::make_tuple(std::move(args)...)]() -> decltype(auto) {
        return std::apply([](auto const&... args) -> decltype(auto) {
            return foo(args...);
        }, tup);
    };
}

// Стало
template <class... Args>
auto delay_invoke_foo(Args... args) {
    return [args=std::move(args)...]() -> decltype(auto) {
        return foo(args...);
    };
}

• Преобразование T* bool объявлено сужающим. Внесено задним числом в Си++11…17^[33].

struct X { X(); };
struct A {
  struct B {
    B() noexcept(A::value) = default;
    X x;
  };
  decltype(B()) b;  // возможна ли строка?
  static constexpr bool value = true;
};
A::B b;

class Stream {
public:  // noexcept убран: раньше надо было тело {}
  virtual ~Stream() noexcept(false) = default;
};

class MemStream : public Stream {
public:  // noexcept добавлен: точно не генерирует ошибок ввода-вывода
  ~MemStream() noexcept = default;
};

void f() {
  T x;
  try {
    T y;
    try {g(x);}
    catch(...) {
      if(/*...*/)
        throw x;    // скопирует — x снаружи try-блока
      throw y;      // переместит — y внутри try-блока
    }
    g(y);
  } catch(...) {
    g(x);
    // g(y); // ошибка
  }
}

• Новые версии make_unique/make_shared, связанные с массивами^[38][39].
• atomic<shared_ptr<>> и atomic<weak_ptr<>>.
• atomic_ref<>, объект, позволяющий сделать атомарным что угодно^[40].
• std::erase, std::erase_if, упрощают мета программирование^[41].
• map.contains^[42].
• Новый заголовок <version> — стандартное место для объявлений, связанных с развитием конкретной стандартной библиотеки^[43]. Объявления определяются реализацией.
• to_address — преобразование указателеподобного объекта в указатель^[44]. addressof уже есть, но он требует разыменования, что может стать неопределённым поведением.
• Новые #define для проверки функциональности компилятора и библиотеки^[45]. Стандарты Си++ огромны, и не все разработчики компиляторов быстро вносят их в свои продукты. А некоторые — сбор мусора Си++11 — остаются заглушками и поныне (2021), не реализованные ни в одном компиляторе.
• Упрощённый карринг через bind_front^[46].
• source_location — обёртка макросов __FILE__ и подобных на Си++.
• Новый заголовок <numbers> с математическими константами^[47]. До этого даже обычные и e существовали только как расширения.
• string.reserve(n) и другие больше не уменьшают ёмкость^[48].
• cmp_equal и другие, безопасно сравнивающие числа — расширением до общего типа или ещё каким-то образом^[49]. Используется в первую очередь в обобщённом программировании.
• Серьёзная часть библиотеки переписана под новое трёхзначное сравнение («звездолёт»)^[50].

• std::pointer_traits^[51].
• xxx.empty() и некоторые другие. Запись xxx.empty(); вместо xxx.clear(); стала стандартной ошибкой Си++^[52][53], и она объявлена [[nodiscard]].
• <numeric>^[54].
• конструкторы-деструкторы std::vector и std::string, следствие послаблений в constexpr. На момент проверки (май 2020) ни один компилятор этого не поддерживает^[55].
• atomic, atomic_flag^[56].

char c = 120;
auto s1 = std::format("{:+06d}", c);   // "+00120"
auto s2 = std::format("{:#06x}", 0xa); // "0x000a"
auto s3 = std::format("{:<06}", -42);  // "-42   " (0 игнорируется из-за выравнивания <)

• Один и тот же параметр можно форматировать сколько угодно раз разными способами.
• Подстановки можно переставлять местами.
• Выравнивание слева, по центру и справа, любым символом.
• По умолчанию числа, даты и прочее форматируются локале-нейтрально; если нужна локализация — это задаётся явно.
• Работает через шаблоны и потому расширяется на любые типы.
• Скобки можно заэкранировать {{ }}.

void do_something(std::span<int> p) {
    std2::sort(p);
    for (int& v: p) {
        v += p[0];
    }
}
// ...
std::vector<int> v;
do_something(v);

int data[1024];
do_something(data);

boost::container::small_vector<int, 32> sm;
do_something(sm);

• Подсчёт количества битов
• Округление до степени двойки
• Преобразование «бит в бит» из одного типа в другой (см. Быстрый обратный квадратный корень)
• Циклический сдвиг, стандартная функция многих процессоров
• Определение порядка байтов целевой машины

osyncstream{cout} << "The answer is " << 6*7 << endl;

auto d1 = 2018_y / mar / 27;
auto d2 = 27_d / mar / 2018;
auto d3 = mar / 27 / 2018;
year_month_day today = floor<days>(system_clock::now());
 
assert(d1 == d2);
assert(d2 == d3);
assert(d3 == today);

#include <thread>
#include <iostream>
 
using namespace std::literals::chrono_literals;
 
void f(std::stop_token stop_token, int value)
{
    while (!stop_token.stop_requested()) {
        std::cout << value++ << ' ' << std::flush;
        std::this_thread::sleep_for(200ms);
    }
    std::cout << std::endl;
}
 
int main()
{
    std::jthread thread(f, 5); // prints 5 6 7 8... for approximately 3 seconds
    std::this_thread::sleep_for(3s);
    // The destructor of jthread calls request_stop() and join().
}

struct string_hash {
  using is_transparent = void;
  [[nodiscard]] size_t operator()(const char *txt) const {
    return std::hash<std::string_view>{}(txt);
  }
  [[nodiscard]] size_t operator()(std::string_view txt) const {
    return std::hash<std::string_view>{}(txt);
  }
  [[nodiscard]] size_t operator()(const std::string &txt) const {
    return std::hash<std::string>{}(txt);
  }
};

std::unordered_map<std::string, int, string_hash, std::equal_to<>> m { 
    { "Hello Super Long String", 1 }, 
    { "Another Longish String", 2 }, 
    {"This cannot fall into SSO buffer", 3 }
};

bool found = m.contains("Hello Super Long String");
std::cout << "Found: " << std::boolalpha << found << '\n';

• Параллелизм v2^[65], в том числе task blocks. Версия 1 внесена в Си++17.
• Рефлексия v1^[66]
• Сеть v1^[67]

• Контракты — есть конкурирующее предложение
• Метаклассы
• Исполнители
• Свойства
• Расширенные future

• C++
• C++11
• C++17

1. ISO/IEC 14882:2020 (англ.). ISO. Дата обращения: 21 декабря 2020.
2. Current Status : Standard C++ (англ.). Дата обращения: 8 февраля 2019. Архивировано 8 сентября 2020 года.
3. P1152R4: Deprecating volatile  (неопр.). Дата обращения: 9 августа 2022. Архивировано 9 августа 2022 года.
4. Deprecating Vestigial Library Parts in C++17  (неопр.). Дата обращения: 29 января 2021. Архивировано 13 сентября 2017 года.
5. Deprecating <codecvt>  (неопр.). Дата обращения: 29 января 2021. Архивировано 16 сентября 2017 года.
6. Proposed Resolution for CA 14 (shared_ptr use_count/unique)  (неопр.). Дата обращения: 29 января 2021. Архивировано 7 июля 2017 года.
7. P1161R3: Deprecate uses of the comma operator in subscripting expressions (англ.). www.open-std.org. Дата обращения: 21 декабря 2020. Архивировано 9 ноября 2020 года.
8. Trip report: Fall ISO C++ standards meeting (Albuquerque) – Sutter’s Mill  (неопр.). Дата обращения: 8 февраля 2019. Архивировано 13 февраля 2019 года.
9. Modules (since C++20) — cppreference.com  (неопр.). Дата обращения: 2 февраля 2021. Архивировано 27 января 2021 года.
10. Coroutines (C++20) — cppreference.com  (неопр.). Дата обращения: 3 февраля 2021. Архивировано 25 марта 2021 года.
11. Down with typename!  (неопр.) Дата обращения: 13 августа 2020. Архивировано 22 апреля 2018 года.
12. Архивированная копия  (неопр.). Дата обращения: 14 августа 2020. Архивировано 15 августа 2020 года.
13. Источник  (неопр.). Дата обращения: 14 ноября 2023. Архивировано 2 октября 2023 года.
14. P1301R4: [[nodiscard("should have a reason")]]  (неопр.). Дата обращения: 29 августа 2024. Архивировано 29 августа 2024 года.
15. Allowing Virtual Function Calls in Constant Expressions  (неопр.). www.open-std.org. Дата обращения: 11 марта 2019. Архивировано 11 июня 2018 года.
16. P1330R0 - Changing the active member of a union inside constexpr  (неопр.). Дата обращения: 13 августа 2020. Архивировано 26 июля 2019 года.
17. P1002R0 - Try-catch blocks in constexpr functions  (неопр.). Дата обращения: 8 февраля 2019. Архивировано 11 ноября 2018 года.
18. P1327R0 - Allowing dynamic_cast, polymorphic typeid in Constant Expressions  (неопр.). Дата обращения: 13 августа 2020. Архивировано 26 июля 2019 года.
19. More constexpr containers (англ.). www.open-std.org. Дата обращения: 21 декабря 2020. Архивировано 14 ноября 2020 года.
20. C++20’s Conditionally Explicit Constructors | C++ Team Blog  (неопр.). Дата обращения: 2 февраля 2021. Архивировано 23 января 2021 года.
21. Default comparisons (since C++20) - cppreference.com  (неопр.). Дата обращения: 7 января 2022. Архивировано 7 января 2022 года.
22. Conditionally Trivial Special Member Functions
23. Yet another approach for constrained declarations
24. String literals as non-type template parameters  (неопр.). Архивировано 11 декабря 2017 года.
25. Tim Shen, Richard Smith. P0329R4: Designated Initialization Wording (англ.). http://www.open-std.org/. Дата обращения: 21 декабря 2020. Архивировано 15 ноября 2020 года.
26. Allow initializing aggregates from a parenthesized list of values
27. Thomas Kppe. Allow lambda capture [=, this]  (неопр.). Дата обращения: 8 февраля 2019. Архивировано 9 февраля 2019 года.
28. Familiar template syntax for generic lambdas (англ.). Дата обращения: 8 февраля 2019. Архивировано 21 ноября 2018 года.
29. ^{1 2 3} Trip Report: C++ Standards Meeting in Albuquerque, November 2017. There's Waldo! (англ.). 20 ноября 2017. Архивировано 11 декабря 2017. Дата обращения: 8 февраля 2019.
30. Wording for lambdas in unevaluated contexts  (неопр.). Архивировано 12 декабря 2017 года.
31. Default constructible and assignable stateless lambdas  (неопр.). Архивировано 12 декабря 2017 года.
32. Pack expansion in lambda init-capture  (неопр.). www.open-std.org. Дата обращения: 11 декабря 2017. Архивировано 14 февраля 2020 года.
33. Converting from T* to bool should be considered narrowing (re: US 212) - HackMD
34. P1286R2: Contra CWG DR1778
35. Архивированная копия  (неопр.). Дата обращения: 14 августа 2020. Архивировано 12 августа 2020 года.
36. P1236R0: Alternative Wording for P0907R4 Signed Integers are Two's Complement  (неопр.). Архивировано 11 ноября 2018 года.
37. P0668R4: Revising the C++ memory model  (неопр.). Архивировано 11 ноября 2018 года.
38. std::make_unique, std::make_unique_for_overwrite — cppreference.com  (неопр.). Дата обращения: 29 января 2021. Архивировано 3 февраля 2021 года.
39. std::make_shared, std::make_shared_for_overwrite — cppreference.com  (неопр.). Дата обращения: 29 января 2021. Архивировано 3 февраля 2021 года.
40. std::atomic_ref — cppreference.com  (неопр.). Дата обращения: 2 марта 2021. Архивировано 27 апреля 2021 года.
41. Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20  (неопр.). Дата обращения: 2 февраля 2021. Архивировано 8 марта 2021 года.
42. std::map<Key,T,Compare,Allocator>::contains — cppreference.com  (неопр.). Дата обращения: 2 февраля 2021. Архивировано 11 июня 2018 года.
43. Архивированная копия  (неопр.). Дата обращения: 2 февраля 2021. Архивировано 20 января 2021 года.
44. Utility to convert a pointer to a raw pointer  (неопр.). Дата обращения: 2 февраля 2021. Архивировано 20 февраля 2018 года.
45. Integrating feature-test macros into the C++ WD  (неопр.). Дата обращения: 8 февраля 2019. Архивировано 20 июля 2018 года.
46. Simplified partial function application  (неопр.). Дата обращения: 2 февраля 2021. Архивировано 28 сентября 2020 года.
47. Standard library header <numbers> — cppreference.com  (неопр.). Дата обращения: 2 марта 2021. Архивировано 25 января 2021 года.
48. p0966R1: string::reserve Should Not Shrink  (неопр.). Дата обращения: 5 января 2024. Архивировано 5 января 2024 года.
49. Safe integral comparisons  (неопр.). Дата обращения: 5 января 2024. Архивировано 5 января 2024 года.
50. The Mothership has Landed  (неопр.). Дата обращения: 5 января 2024. Архивировано 5 января 2024 года.
51. P1006R1 - Constexpr in std::pointer_traits  (неопр.). Дата обращения: 8 февраля 2019. Архивировано 11 ноября 2018 года.
52. string::empty — C++ Reference  (неопр.). Дата обращения: 29 января 2021. Архивировано 28 октября 2020 года.
53. 100 багов в Open Source проектах на языке Си/Си  (неопр.). Дата обращения: 29 января 2021. Архивировано 26 января 2021 года.
54. Numerics library — cppreference.com  (неопр.). Дата обращения: 2 февраля 2021. Архивировано 21 апреля 2021 года.
55. C++20: The Unspoken Features — Human Readable Magazine  (неопр.). Дата обращения: 8 декабря 2020. Архивировано 30 ноября 2020 года.
56. Источник  (неопр.). Дата обращения: 5 января 2024. Архивировано 5 января 2024 года.
57. Formatting library (C++20) — cppreference.com  (неопр.). Дата обращения: 29 января 2021. Архивировано 31 января 2021 года.
58. Standard library header  — cppreference.com  (неопр.). Дата обращения: 29 января 2021. Архивировано 27 апреля 2021 года.
59. Ranges library (C++20) — cppreference.com  (неопр.). Дата обращения: 3 февраля 2021. Архивировано 16 января 2021 года.
60. Extending <chrono> to Calendars and Time Zones  (неопр.). Дата обращения: 3 февраля 2021. Архивировано 13 мая 2018 года.
61. P0342R0: Timing barriers  (неопр.). Дата обращения: 8 февраля 2019. Архивировано 24 ноября 2019 года.
62. std::unordered_set<Key,Hash,KeyEqual,Allocator>::find - cppreference.com  (неопр.). Дата обращения: 31 мая 2022. Архивировано 31 мая 2022 года.
63. C++20: Heterogeneous Lookup in (Un)ordered Containers - C++ Stories  (неопр.). Дата обращения: 17 мая 2022. Архивировано 24 мая 2022 года.
64. abseil / Tip of the Week #144: Heterogeneous Lookup in Associative Containers  (неопр.). Дата обращения: 17 мая 2022. Архивировано 18 мая 2022 года.
65. C++ Extensions for Parallelism Version 2  (неопр.). Дата обращения: 10 апреля 2022. Архивировано 21 сентября 2022 года.
66. C++ Extensions for Reflection  (неопр.). Дата обращения: 10 апреля 2022. Архивировано 21 сентября 2022 года.
67. C++ Extensions for Networking  (неопр.). Дата обращения: 10 апреля 2022. Архивировано 21 сентября 2022 года.