C++26

C++26 или C++2c (латиницей), или Си++26 (кириллицей) — ожидаемый стандарт языка программирования C++. Разработка началась сразу же после того, как в феврале 2023 года зафиксировали C++23.

С самого начала стандарт получил рабочее имя «Си++26». Си++0x должен был приблизить устаревающий Си++ к современным языкам, непрерывно разрабатываемым под руководством единоличника. (Си++ разрабатывается комитетом и есть много реализаций — в отличие от, например, Python.) Но стандарт запоздал, и с версии 14 новый язык выпускают не «когда готово», а раз в три года, при этом последний год — только доводка. КОВИД не сместил расписание — к пандемии как раз была готова версия 20, а версию 23 подготовили дистанционно.

Заседания

1. 12…16 июня 2023, Варна (Болгария)^[1] — первое после пандемии КОВИДа очное заседание.
2. 6…11 ноября 2023, Каилуа-Кона (Гавайи, США)^[2]
3. 18…23 марта 2024, Токио (Япония)^[3].
4. 24…29 июня 2024, Сент-Луис (Миссури, США)^[4]
5. 18…23 ноября 2024, Вроцлав (Польша)^[5]
6. 10…15 февраля 2025, Хагенберг-им-Мюлькрайс (Австрия)
7. Июнь 2025, София (Болгария) — ожидается
8. Ноябрь 2025, Каилуа-Кона (Гавайи, США) — ожидается

Запрещены и удалены

Запрещены в языке

• void f(int x...); — старый редкий синтаксис переменных параметров Си на разборе стека через va_list^[6]. Остаются добавленный позже Си-совместимый void f(int x, ...);, неявный шаблон Си++20 void f(auto x...); Синтаксис шаблонов и va_list также можно объединить void f(auto x......);, и это тоже запрещено. Возможно, это шаг к шаблонному синтаксису «сколько угодно параметров int», то есть создающему отдельную функцию для нуля, одного, двух параметров^[6].

Удалены из языка

• Любые операции между enum и дробным; enum и другим enum. Ошибкоопасное наследие Си. Запрещены в Си++20, операция «звездолёт» <=> никогда не разрешалась^[7]. Использовать явное преобразование типов. Может помешать совместимости с Си, обходится легко: +C1 + C2.
• Функции больше не могут возвращать ссылку на временный объект^[8]. На именованный стековый пока ещё могут, хоть это тоже ошибка и диагностируется компиляторами. Поведение is_convertible_v<int, const double&> не изменяется — константа остаётся true, ведь преобразование int → const double& законно в других местах.
• Некодируемые строковые литералы (например, из-за отсутствия конкретного символа в кодировке исполнения) теперь ошибочны^[9]. Многосимвольные литералы 'abc' не могут иметь префикса кодировки, и могут состоять только из символов, укладывающихся в одну минимальную кодовую единицу (байт).
• Уничтожение объекта недоопределённого типа (class X;) операцией delete, даже без запрета (неофициально запрещён большинством компиляторов)^[10]. Менеджер памяти знает размер выделенного участка и ему не нужна информация о типе. Но раньше предполагалось, что деструктор ничего не делает, что может снижать взаимозависимость между единицами трансляции в настоящем, но если в будущем тривиальный объект станет управляемым, будет утечка памяти.
• Сравнение массивов. Они сравнивались как указатели, с операцией «звездолёт» (Си++20) запретили^[11]. Обходится легко: +a == b, нужно редко.

Диагностика доступа до инициализации

Доступ до инициализации — это известный источник ошибок, и теперь запрещён в очень ограниченном виде — только на стеке^[12]. Если действительно неопределённое значение нужно — использовать новый атрибут [[indeterminate]].

union всегда считается инициализированным полностью. На объекты в «куче» диагностика не распространяется.

void h() {
  int d1, d2;

  int e1 = d1;           // теперь ошибка
  int e2 = d1;           // теперь ошибка

  assert(e1 == e2);      // OK
  assert(e1 == d1);      // выполнялось, теперь ошибка
  assert(e2 == d1);      // выполнялось, теперь ошибка

  std::memcpy(&d2, &d1, sizeof(int)); // OK, но у d2 теперь ошибочное значение
  assert(e1 == d2);      // выполнялось, теперь ошибка
  assert(e2 == d2);      // выполнялось, теперь ошибка
}

void f(int);

void g() {
  int x [[indeterminate]], y;
  f(y);     // ошибка
  f(x);     // неопределённое поведение
}

Запрещены в библиотеке

• is_trivial. Использовать конкретные особенности типа^[13]: если хотим сделать массив с «канарейкой» (особым числом, записанным по краям для проверки на запорченную память) и нет желания работать с неинициализированной памятью Си++17 (то есть «канарейку» придётся писать прямо поверх новосозданных объектов), условие работоспособности канарейки — тривиальное уничтожение, is_trivially_destructible.
  • Само определение тривиального типа сложное: хотя бы один действующий (то есть не исключённый явно через =delete или неявно) конструктор или операция, копирования или переноса; все они, если действуют, то тривиальны. Также тривиальный конструктор без параметров и тривиальный деструктор.
• memory_order::consume — специфичная работа компилятора и кэша в атомарных переменных, предназначенная для задачи: один поток заполняет переменную данными, второй их потребляет (отсюда название), и более поздние загрузки этой переменной не могут быть вынесены наперёд. К посторонним переменным никаких требований. В Си++17 был устно запрещён, в Си++20 вернули. На отдельных архитектурах (POWER, GPGPU, старые реализации ARM) все загрузки будут consume, но не все — acquire, и на них, по-видимому, лучше использовать платформо-специфичные «хаки» — а в других платформах компиляторы не проверяли зависимостей и ставили барьер типа acquire (никакой доступ к памяти не может быть вынесен наперёд). Теперь всегда consume == acquire^[14]. Аннотация [[carries_dependency]] (Си++11) осталась, но больше ничего не делает.

Удалены из библиотеки

• Весь заголовок <codecvt> — нет обработки ошибок^[15]. Запрещён в Си++17. Использовать внешние, более управляемые функции.
• allocator<T>::is_always_equal^[16]. Ошибкоопасен при наследовании от аллокатора, в котором этот is_always_equal есть. Запрещён в Си++20, для проверки возможностей аллокатора использовать allocator_traits. Использовать в собственных аллокаторах, когда это действительно играет роль.
• string.reserve() без параметров, эквивалентный reserve(0)^[17]. Со старым API строк (Си++98…17) использовалось как shrink_to_fit, им же и заменено. В Си++20 reserve больше не укорачивает строку, а данную перегрузку запретили.
• strstream (поток, который пишет в буфер памяти) — запрещён давно в Си++98 из-за опасности переполнения буфера^[18]. Использовать spanstream (Си++20).
• wstring_convert (преобразование кодировок из многобайтовой в Юникод, заголовок <locale>) — запрещено в Си++17 из-за сложности^[19][20].
• Атомарный API shared_ptr — запрещён в Си++20, использовать atomic^[21].

Снят запрет

• polymorphic_allocator.destroy — запрещено в Си++20. Пусть это же можно сделать и через allocator_traits, так короче^[22].

Язык

Разные изменения в языке

• Параметром-значением в шаблонах (non-type template parameter) может стать и вызов конструктора. Указано, когда такой вызов возможен, а когда нет^[23].
• Теперь можно навешивать атрибуты и на структурные переменные: auto [a, b [[vendor::attribute]], c] = f();^[24]. Предложенное назначение — аннотирование кода для углублённой проверки на безопасность: например, char* в данном месте не требует закрывающего нуля.
• Структурные переменные в условных операторах сами могут быть условием, если для структуры в целом существует надлежащее преобразование в bool: if (auto [first, last] = parse())^[25]. Или, вместе с новыми изменениями в библиотеке: if (auto [ptr, ec] = std::to_chars(p, last, 42)){}^[26].
• union, независимо от внутренних типов, всегда тривиально конструируется-уничтожается — например, чтобы отвести место на неинициализированную память^[27].

Конструируемые строки в static_assert

Для начала придумали понятие «невычисляемая строка» (unevaluated string): закавыченная строка, значение которой не проходит в скомпилированную программу, а нужно только компилятору. Они являются частью _Pragma, asm, [[nodiscard]]… — и, конечно, static_assert^[28]. Им запрещается иметь префикс кодировки.

Впоследствии позволили в static_assert любую константно вычисляемую строку^[29]:

// Было
template <typename T, auto Expected, unsigned long Size = sizeof(T)>
constexpr bool ensure_size() {
  static_assert(sizeof(T) == Expected, "Неожиданный sizeof");
  return true;
}
static_assert(ensure_size<S, 1>());
// Остаётся надеяться, что компилятор напишет, что дело было в ensure_size<int, 1, 4>

// Стало
static_assert(sizeof(S) == 1,
    std::format("Неожиданный sizeof: хотел 1, получил {}", sizeof(S));
// Неожиданный sizeof: хотел 1, получил 4

Сам constexpr format намеренно не внесён, но его прообраз, библиотека libfmt, уже способна на constexpr.

i-й элемент пакета параметров

Теперь его можно получить как T...[i]. Например: void f(T&&... t) { g(std::forward<T...[0]>(t...[0])); }^[30].

Формально это несколько бьёт по имеющемуся коду: void f(T...[0]){} представляло собой пакет безымянных массивов, но по факту не покрыто тестовыми программами и даже не компилировалось в MSVC и G++. C# и D поддерживают и i-й параметр с конца, но отрицательные числа для этого ошибкоопасны, а более сложный синтаксис решено не просить.

Эта функциональность, написанная на шаблонах, даёт O(n) специализаций^[31]. В CLang, а за ним и в G++ реализовано «волшебным» (встроенным в компилятор) шаблоном __type_pack_element<i, Types...> и используется, например, в variant.

Имя _ может повторяться

auto [where, _] = insert(); — давно устоявшаяся манера программирования, когда функция возвращает два поля, а нужно одно, особенно если возвращается неговорящий тип вроде pair. Второй вариант — когда нужен именованный (не временный) объект, но имя не важно: захват мьютекса lock_guard _(someMutex). На случай, когда таких подчерков несколько, идиому расширили:^[32]

namespace a {
  auto _ = f();
  auto _ = f(); // Остаётся ошибка: с глобальными переменными не работает
}
int _;
void f() {
  using ::_;   // Остаётся OK, добавление в пространство имён постороннего символа
  auto _ = 42; // Теперь OK
  using ::_;   // Остаётся ошибка: using _ разрешено только до локальной _
  auto _ = 0;  // Теперь OK
  static int _; // Остаётся ошибка: со статическими переменными не работает
  {
    auto _ = 1;       // Остаётся OK, замещение
    assert( _ == 1 ); // Остаётся OK, имеем дело с замещённой переменной
  }
  assert( _ == 42 );  // Ошибка: которая из двух?
}

Использование или неиспользование имени в этом контексте не должно вызывать предупреждений.

Для функций, типов, using X=Y, концепций и шаблонных параметров новый механизм бесполезен: этим объектам либо нужно говорящее имя, либо Си++ уже даёт подходящие механизмы вроде безымянных типов.

Расширен constexpr

• Преобразование указателей в void*, а потом обратно в свой тип^[33]. Преобразование в посторонние типы неконстантно. Используется для так называемого стирания типа — при выполнении информация хранится в переменной общего типа, но её обработка выстраивается так, что все преобразования в частный тип верны. (Так устроены, например, обобщённые типы Java.) В CLang механизм уже есть (потребовался для выделения памяти) и вынести наружу ничего не стоит, G++ и EDG не видят препятствий. По заявлениям Г. Саттера, это шаг к constexpr format^[34].
• Предыдущее изменение привело к тому, что теперь можно сделать constexpr placement new, допустимый только если указатель действительно смотрит на свой тип, и являющийся простой инициализацией^[35]. Воспользовавшись нововведением, перенесли в constexpr библиотеку неинициализированной памяти (Си++17).
• Constexpr-указатели, ссылки и структурные переменные, представляющие собой просто название по имени того или иного constexpr-объекта^[36].
• Выброс исключений с последующей обработкой^[37]. Но в любом случае авария не должна выпадать наружу, иначе это не constexpr: вычисляется при исполнении, если контекст позволяет, и ошибка — если нет. Раньше уже факт выброса снимал constexpr. Некоторым наиболее распространённым исключениям сделан constexpr what(). Мотивация — при константных вычислениях иногда случаются ошибки, и нужно принудить компиляторы выводить в консоль диагностические сообщения, а не общее «выброшена ошибка std::invalid_argument».

Вариативный friend

Одно из назначений оператора friend — объекты-утилиты, сделанные через саморекурсивные шаблоны. Если шаблон вариативный, то друзей может быть много.

Пример: так называемый passkey, идиома Си++, используемая, если скрытую функцию надо вызвать из несвязанного шаблона (обычно make_unique/make_shared). Чтобы шаблон имел к ней доступ, функция должна быть общедоступной, и скрывают не её, а параметр-затычку, так называемый passkey, который так просто не сконструируешь.

// Вариативный passkey
template<class... Ts>
class Passkey {
  friend Ts...;
  Passkey() {}
};

class C {
public:
  // Можно вызвать только из Blarg, Blip и Baz
  void intentional(Passkey<Blarg, Blip, Baz>);
};

// Раскрыть класс для внутренних объектов
template<class... Ts>
struct VS {
  template<class U>
  friend class C<Ts>::Nested...;
};

Разрешение вариативных шаблонных перегрузок с концепциями

Для простой шаблонной перегрузки с концепциями 1-2 уже прописано: если подходят несколько шаблонных функций, брать ту, чья концепция сильнее (у́же). То же самое сделано и для вариативной 3-4, очень сложным языком. «Почти правильный» код Си++23 может перестать компилироваться в 26^[38].

template <std::ranges::bidirectional_range R> void f(R&&); // №1
template <std::ranges::random_access_range R> void f(R&&); // №2

template <std::ranges::bidirectional_range... R> void g(R&&...); // №3
template <std::ranges::random_access_range... R> void g(R&&...); // №4

void call() {
    f(std::vector{1, 2, 3}); // OK, №2 сильнее
    g(std::vector{1, 2, 3}); // Теперь OK, №4 сильнее
}

=delete("причина")

Иногда нужно отказаться от автоматического присваивания, одной из унаследованных функций или нежелательного преобразования типа. В Си++03 функцию удаляют заголовком без тела, по возможности скрытым private: void f();. В Си++11 появилось тело =delete: компилятор, а не линкер явно сообщает о недопустимом вызове. По словам источника, «автор библиотеки говорит: „Я знаю, что вы думаете делать, и это неверно“». И в том, и в другом случае функция участвует в разрешении перегрузок.

Нововведение дополнительно сообщает программисту, почему функция удалена и что делать — «…и это неверно, и я скажу, почему неверно и как надо». Например: Proxy<T> factory(const T&&) = delete("Опасно висячими ссылками");^[39]. Другие приведённые в источнике причины: старый API выброшен и отсылает на новый, некопируемый/труднокопируемый тип, недопустимое конструирование строки из nullptr, неправильный синтаксис создания динамического массива функцией make_unique.

Существуют предложения сделать условный =delete, как это сделали с explicit(bool) (Си++20) и noexcept(bool) (Си++11), но, по заверениям заявки, данный синтаксис не бросит на это тень.

Пакеты в структурных переменных

Синтаксический сахар для сложных шаблонов, разбирающих объект-кортеж на части^[40]. Это работало и раньше — только на уровне библиотеки.

auto [x,y,z] = f();  // остаётся OK
auto [...xs] = f();  // новое
auto [x, ...rest] = f();  // тоже новое

// Новое: чтобы помножить кортеж на кортеж, оба рассматриваем
//  как структурные переменные
template <class P, class Q>
auto dot_product(P p, Q q) {
    auto&& [...p_elems] = p;
    auto&& [...q_elems] = q;
    return (... + (p_elems * q_elems));
}

Расширенные самопроверки (контрактное программирование)

Пока сделали минимально действующий продукт^[41], с тремя операторами: предусловие, постусловие и самопроверка.

int f(const int x)
  pre (x != 1) // предусловие
  post (r : r != x) // постусловие
{
  contract_assert (x != 3); // самопроверка
  return x;
}

Пока отсутствуют:

• Включение самопроверок в систему типов — пока самопроверки никак не изменяют тип функции.
• Инварианты (одновременно предусловие и постусловие).
• Возможность обратиться к исходным значениям переменных в результате расчёта постусловия.
• Семантика, похожая на assume — компилятор предполагает, что условие выполняется, и оптимизирует код из этого предположения.
• Более наглядный показ, что собой представляет запрограммированный алгоритм.
• Деление самопроверок на уровни, которые можно включать и выключать по отдельности.
• Постусловия для функций, из которых нет выхода, или есть выход только аварийный.
• Самопроверки, которые исполнимы только при компиляции.
• Сохранение состояния от одной самопроверки к другой — «функция вызывается только один раз».
• Более сложные протоколы, чем вызов одной функции — например, перед работой с файлом нужно вызвать fopen.

Шаблоны на концепциях

Проще всего объяснить примером^[42]: понятие «диапазон целых» обобщается в «диапазон чего-то».

// Было
template<typename T>
  concept range_of_integrals = std::ranges::range<T>
       && std::integral<std::remove_cvref_t<std::ranges::range_reference_t<T>>>;

// Стало
template<typename T, template <typename...> concept C>
  concept range_of = std::ranges::range<T>
       && C<std::remove_cvref_t<std::ranges::range_reference_t<T>>>;
template<typename T>
  concept range_of_integrals = range_of<T, std::integral>;

Разработчики писали подобное на лямбда-функциях:

template <typename T, auto ConceptWrapperLambda>
  concept decays_to = requires {
    ConceptWrapperLambda.template operator()<std::decay_t<T>>();
  };
template <class T> requires decays_to<T, ([]<std::copyable>(){})>
auto f(T&& x) {}

Переезжающие типы

Переезд объекта — полное разрушение объекта и создание идентичного в неинициализированном блоке — важная функция любого языка, используемая, например, при «подчистке» временных объектов, возврате значения функции. Компилятор старается избавляться от переездов, но это не всегда возможно.

Си++03 создавал копию, уничтожал имеющийся. Перемещение объектов (Си++11) подняло производительность в важнейших случаях — тип T&& говорит, что объект ненужный и можно забрать из него ценные ресурсы (выделенную память, файловые дескрипторы и т. д.), оставляя объект опустелым, но корректным — ведь потом заработает деструктор^[43]. Так что резервы не исчерпаны: замечено, что многие нетривиальные объекты могут менять дислокацию значительно проще, чем конструктором перемещения и деструктором.

Две новых концепции, связанные с производительностью^[44]:

• Тривиально переезжающий тип — объект достаточно перебросить в неинициализированную память бит в бит, а исходному не вызвать деструктор — и это будет корректный объект.
• Заменяемый тип — вместо уничтожения-создания достаточно вызвать операцию перемещения.

Эти понятия ортогональны: динамический массив (std::vector) с полиморфным выделением памяти только тривиально переезжающий (замена даст новые данные во владении старого менеджера памяти); строка, содержащая указатель на внутренний малый буфер, только заменяемая (указатель на внутренние поля не переезжает). И оба не тривиально конструируемые с перемещением.

Автоматически (без явного указания программистом) тривиально переезжают типы с заведомо тривиальными конструктором перемещения и деструктором (виртуальный деструктор и раньше снимал тривиальность!) — правда, компилятор и до Си++26 знал, что делать. В тех случаях, которые важны для производительности, компилятор не в состоянии определить эти свойства, и программист пишет «тривиально переезжающий (заменяемый) тип, если возможно» — компилятор проверяет, что все поля переезжают/заменяются, и делает таковой всю структуру.

struct Y trivially_relocatable_if_eligible {};
static_assert(std::is_trivially_relocatable_v<Y>);

Тривиальный переезд отключается для объекта с виртуальным наследованием: в любом случае указатель на виртуального предка трогать нельзя. А если на какой-то платформе ABI предлагает не указатель, а смещение — пусть семантика будет одинаковой для всех платформ. Для объекта с виртуальными функциями тривиальный переезд возможен: у объектов одного класса таблица виртуальных функций общая. Оптимизации std::swap за рамками нововведения.

В библиотеку неинициализированной памяти (Си++17) добавили функцию std::relocate — переезд объекта полным или сокращённым образом.

Редакционные правки

• Разрешены разночтения в лексическом анализаторе: сращиванием строк текста через \⤶ и склеиванием лексем через препроцессорное ## можно получить имя символа; переводы строк внутри закавыченной строки запрещены. Это статус-кво, поддерживаемый G++, CLang и EDG^[45].
• Некодируемые строковые литералы (например, из-за отсутствия конкретного символа в кодировке исполнения) ошибочны^[9].
• Уточнены правила игнорирования стандартных атрибутов^[46]:
  • Стандартный атрибут должен быть корректным по правилам текущего Си++, даже если игнорируется. (Уже в Си++23^[34] и только добавлено примечание.)
  • У стандартных атрибутов необязательная семантика: убирание атрибута из корректной программы может менять её внешнее поведение, но не может придумывать новое — лишь ограничить до одного из допустимых вариантов, когда атрибут есть, и, возможно, убрать какие-то компилятороспецифичные гарантии. (Также в Си++23 и добавлено примечание.)
  • Псевдофункция препроцессора __has_cpp_attribute должна проверять, реагирует ли компилятор на данный атрибут (а не разбирает ли) — а если разбирает, но не реагирует, атрибут бесполезен и макросы совместимости должны развёртываться во внутренние функции вроде __builtin_assume. (А это новое правило.)
• Объявлено, что объект initializer_list ссылается на опорный массив, который может появиться в памяти двумя способами: как временный объект или как ссылка на какой-то массив, чьё время жизни продлено^[47]. Другими словами, нет нужды копировать из сегмента данных на стек, теряя в производительности и надёжности.
• Требования к generate_canonical переписаны так, чтобы работало на недвоичных машинах, сохранялись статистические свойства на всём диапазоне [0,1) — и результирующее число никогда из-за недостатков дробной арифметики не стало бы единицей^[48]. В результате может нарушиться взаимоповторяемость с Си++23 — на том же генераторе случайных битов могут выходить другие дробные.
• Переписано, когда можно опускать скобки при агрегатной инициализации: Point x[2] = { 1, 2, 3, 4 };^[49].
• Заголовок модуля export module Name; не может быть макросом — это усложняет его обработку системой сборки^[50]. Импорт может — не вызывает таких сложностей.
• Пустой бесконечный цикл — больше не неопределённое поведение^[51]. CLang в таких ситуациях почему-то исполнял посторонний код.
• Выкинуты все [[nodiscard]] из стандарта в отдельный документ, описывающий оптимальную практику, в каких случаях его применять^[52]. Предполагается, что изменения в этот документ будут вноситься легче, чем в стандарт. Один пример: правило MISRA C++ 28.6.4 запрещает вызывать как процедуры remove[_if], unique и empty^[53] — на empty аннотация была, чтобы не путали с clear, а на остальных не было (результат нужен в дальнейшем resize/erase).
• Упрощены грамматические правила для литералов^[54].
• Уточнена работа операций сравнения в expected^[55].
• На стыке диапазонов, алгоритмов и разрешения перегрузки в пространствах имён возник специфичный вид объектов, призванных не вызывать функции из <algorithm> — ниблоиды (niebloids), в честь Эрика Ниблера, автора библиотеки диапазонов. Реализованы Ниблером в изначальной библиотеке, подхвачены G++, CLang и Microsoft, и их узаконили^[56].
• Функции, работающие с непрерывными итераторами, получили официальное право преобразовывать их в указатели^[57].

Гармонизация с Си

• В набор символов внесены остатки печатного ASCII @$`, которые могут пригодится впоследствии^[58]. Ранее в Си23 добавили @$, в первую очередь из-за EBCDIC — оба символа в разных диалектах кодировки на разных позициях^[59].
• Выкинут strtok из автономной библиотеки вслед за Си^[60], так как содержит внутреннее состояние. Большинство реализаций используют потоколокальные переменные, которые в автономной среде могут отсутствовать.
• Переписан макрос assert, чтобы лучше поддерживались шаблоны и многомерная индексация, коих просто не существовало на момент появления препроцессора Си^[61].
• Новые библиотеки Си23 stdbit.h и stdckdint.h, без Си++-аналогов <cstdbit/cstdckint>^[62].

#embed — внедрение двоичных данных

Очень часто нужно вставить в программу двоичные данные в форме «как есть» — источник^[63] упоминает «чистый» образ файловой системы, который надо развернуть, когда пользователь просит полный сброс устройства, PNG-иконку, встроенные в программу скрипты на другом языке. Разработчики на Turbo Pascal могут вспомнить программу binobj и функцию Graph.InstallUserDriver.

Конструкция constinit const unsigned char data[] = { 1, 2 }; создаёт непропорционально много лексем, и хороший синтаксический движок CLang как-то справляется с ней, а другие компиляторы могут «зависнуть» надолго: 4 мегабайта данных компилируются от 8 секунд (CLang) до минуты (MSVC), а внедряются — за долю секунды.

const unsigned char icon_display_data[] = {
    #embed "art.png"
};

Директива уже есть в стандарте Си23.

Преобразование данных из порядка байтов заведомо Intel/Motorola в машинный не предусмотрено. Все примеры из статьи оперируют типом (unsigned) char, которому преобразование не нужно. Впрочем, немалое количество embed’ов — это байтовые данные в некоем стандартном формате: PNG, UTF-8, машинный код…

Библиотека

Разные изменения в библиотеке

• Простейшая^{[к 1]} библиотека идентификации кодировки исполнения^[64].
• Получение системного дескриптора из fstream^[65]. Может использоваться в высоконадёжном программировании, когда надо гарантированно записать данные на диск^[66].
• Поддержка отладчика. Новый заголовочный файл <debugging> с тремя функциями: breakpoint(), breakpoint_if_debugging(), bool is_debugger_present()^[67].
• Теперь объект ignore применим не только в tie: std::ignore = foo();^[68].

Автономная библиотека

Автономная (freestanding) библиотека не полагается на системные вызовы (даже выделение памяти), выброс исключений (требует серьёзной работы со стеком), может быть написана даже на чистом Си++ и потому полностью кроссплатформенна.

• Возможен (не обязателен) operator new, возвращающий nullptr, приводящий к системной аварии или делающий что угодно по желанию реализатора. Добавлен макрос __cpp_lib_has_default_operator_new, проверяющий, возможно ли выделение памяти — например, вместо динамического std::vector могут использоваться массивы ограниченного размера^[69].
• Множество функций Си, включая строковые и математические, а также <charconv> и char_traits^[70].
• algorithm, array, optional, variant, string_view^[71]. Переписаны монадные функции optional так, чтобы не ссылались на неавтономный (выбрасывающий исключения) value.
• expected, span, mdspan^[72].
• numeric, random^[73]

Новые constexpr

• Устойчивая сортировка^[74].
• consteval bool is_within_lifetime(&union_.field) — «волшебная» (реализованная внутри компилятора) функция, проверяющая, держит ли union то или иное поле^[75]. Тип union при компиляции изначально (с Си++11) помеченный на манер variant, Си++20 позволил менять активное поле при компиляции, а доступ к другому полю отключает constexpr. Используется для экстремальной оптимизации по памяти с сохранением константности — например, для однобайтового optional<bool>.
• Больше математических функций, включая комплексные^[76].
• Библиотека неинициализированной памяти, в constexpr-контексте или ничего не делающая, или проводящая простое присваивание^[77][78].
• atomic, atomic_ref^[79]. Многозадачности при компиляции, это, разумеется, не даст, но позволит выполнять такой код хоть в один поток.
• Многие части стандартных контейнеров, включая deque и map^[80].

Перевод данных в строку и наоборот

• from_chars_result получил operator bool^[81] — проверку кода ошибки.
• to_string для дробных выдаёт то же, что и format("{}", x). А он, в свою очередь, то же, что to_chars — в компактном точном нелокализованном виде с целой частью^{[66][к 2]}. Ранее он был унифицирован с printf("%f", x), то есть обращался к глобальной локали (ненадёжно, да и вычисление нужных параметров локали затратно)^[66] и плохо работал со слишком большими/малыми числами^[82]. Это нарушение совместимости, но to_string значительно реже других методов перевода чисел в строку. Проверив случайные 100 вызовов, авторы обнаружили, что только семь из них дробные, в одном явная ошибка — запись в INI в локализованном виде, а остальные используются для отладки.
• stringstream можно инициализировать строками string_view^[83].
• То же самое с bitset^[84].
• string + string_view^[85]. Изначально в операции отказали из-за особенностей архитектуры LLVM — всё, что можно, она исполняет «лениво», и append точками следования фиксирует, где исполнять, а сложение в большом выражении может выйти за время жизни string_view. Так что целых пять редакций — это попытка найти наиболее удачную реализацию.

format (Си++20)

• Унифицировано форматирование указателей^[86].
• Параметры ширины теперь также проверяются при компиляции^[87].
• Форматирование строк, заранее не известных: std::vformat(str, std::make_format_args(path.string())); → std::format(std::runtime_format(str), path.string());. Первое предназначено для писателей своих обёрток над форматированием вроде doLog(str, args...), а не для конечных пользователей, и в пользовательском коде опасно: make_format_args содержит string_view, и если его вытащить в отдельную переменную, string_view будет жить дольше, чем временная строка. Для надёжности тонкая обёртка runtime_format_string принимается только по временной ссылке^[88].
• В само́м make_format_args избавились от std::forward и временных объектов, делая форматирование более устойчивым к висячим ссылкам^[89].
• Серьёзная ошибка, ранее случившаяся в fmt (прообразе format): кодовые единицы char, будучи отформатированы как числа или с «широкой» форматной строкой, выдавали зависящий от реализации вид^[90]. Теперь char, отформатированный как число, будет unsigned; отформатированный как символ в широком контексте — символом с кодом 0…255.
• Форматирование path^[91].

print (Си++23)

• println() без параметров^[92].
• print может захватывать или не захватывать мьютекс консоли в зависимости от того, как происходит преобразование: преобразовать в строку целиком, потом вывести (например, для чисел), или параллельно преобразование-вывод (например, для массивов)^[93].

Функциональное программирование

• Добавлена copyable_function, построенная по принципу новой move_only_function (Си++23) и много легче^{[к 1]}, чем function (Си++11), которая один из самых тяжёлых типов STL. Последнюю всё-таки решили не запрещать^[94].
• Добавлена совсем лёгкая function_ref, не инкапсулирующая вызываемый объект, а просто ссылающаяся на него^[95]. Может использоваться для callback’ов, если основная функция тяжёлая или виртуальная, и не хочется делать её шаблонной. Класс писали своими силами: в заявке приведены шесть реализаций, некоторые на Си++14, и три из них назывались function_ref.
• Добавлен облегчённый шаблонный карринг через bind_front, если вызываемый объект (например, слот Qt) вычисляется раз и навсегда при компиляции^[96].
• This-параметры из Си++23 позволили внести одну из перегрузок visit внутрь variant^[97].

Метапрограммирование

• std::is_virtual_base_of — важно при преобразовании указателей из типа в тип^[98]. Приведён пример: в зависимости от того, виртуальный целевой указатель или нет, weak_ptr переносится из типа в тип через сильный указатель или напрямую.
• Объект monostate продублирован в <utility>^[99].

Хранение данных

• Добавлен hash для календарных типов^[100].
• Добавлен weak_ptr.owner_hash и несколько других подобных функций^[101].
• Закончен разнородный поиск в [unordered_]set/map: добавлены шаблонные insert, insert_or_assign, try_emplace, operator[], bucket^[102]. Разнородный поиск начат в Си++14, и позволяет хранить с «тяжёлыми» ключами (string), а искать по «лёгким» (string_view или даже const char*). Программист сам включает разнородный поиск (полем-типом CompareObject::is_transparent) и задаёт набор допустимых ключей.
• Операции сравнения для reference_wrapper^[103].
• Возможность писать std::find(v.begin(), v.end(), {3, 4});^[104]. Для этого всего лишь в шаблоны типа template<class T, class Allocator, class U> добавили class U=T, которое работает, когда тип ключа определить невозможно.

inplace_vector — простейший массив переменной длины

Массив переменной, но ограниченной длины, основанный на обычном массиве^[105]. Этот контейнер часто пишут собственными силами — скажем, boost::static_vector<T, Capacity>. Нужен, если даже обычный вектор слишком тяжёлый, или менеджер памяти недоступен (в автономной/безопасной среде, на очень ограниченных машинах). Constexpr, если внутренний тип тривиальный. Тривиально копируемый, если внутренний тип тривиально копируемый.

Частично автономный: часть функций при переполнении массива выбрасывает исключения. Но такие структуры любят в ограниченных средах, безопасном и системном программировании^[106], где исключениями пользоваться не принято, так что есть функции вроде try_emplace_back.

indirect и polymorphic — аналоги unique_ptr

Представляют собой указатели единоличного доступа. Семантически это объекты-значения, с такими отличиями от старого unique_ptr:

• есть конструктор копирования, копирующий объект;
• const-доступ делает константным и объект;
• для удобства могут и не содержать объекта, и для этого есть функция, именуемая valueless_after_move, но эта семантика не поощряется и лучше null object и/или optional;
• может применяться оптимизация малых буферов.

Разница только в том, что indirect поддерживает только свой тип (и годится, например, для идиомы pimpl), а polymorphic — любой производный, и потому «под капотом» содержит инфраструктуру для подбора нужного конструктора копирования^[107].

Улей — неперемещающий динамический список

Улей (hive) — специализированный менеджер памяти для однотипных данных, используемый в играх и скоростной торговле. Никогда не перемещает, объект вставляется в случайное место, быстры операции «проход», «добавление» и «удаление»^[108].

Диапазоны и другие представления данных

• Переписан projected (внутренний тип библиотеки диапазонов), лучше работающий с указателями на недоопределённые классы (class Opaque;). Многие из функций диапазонов не работали там, где работал «голый» STL^[109].
• Комплексным числам добавлено get<0> и <1>, как обычным кортежам (tuples)^[110].
• basic_const_iterator можно получить из неконстантного собрата^[111].
• views::concat^[112].
• ranges::generate_random^[113] — стандартная версия простейшая, но авторы библиотек могут добавлять к генераторам/распределениям нестандартные функции, чтобы получать сразу много случайных чисел. Какие именно — стандарта пока нет.
• Объекту std::optional даны итератор, begin и end — то есть он тоже стал диапазоном^[114].
• Выкинуто invocable<F&, iter_common_reference_t> из многих концепций, связанных с итераторами, что позволило итераторы-заместители (vector<bool>)^[115].
• views::cache_latest^[116].
• ranges::reserve_hint — обычно применяется для представлений (views), и приближённо прикидывает, сколько там элементов. Связано это с Юникодом: малая доля букв имеет верхний регистр, и совсем немного — верхний регистр не из одной буквы, так что для условного uppercase_view можно предположить, что ожидаемая длина — это длина исходной строки (а может, немного больше).^[117].
• views::to_input — переводит представление в самый простой вид, чтобы дальнейшие алгоритмы не пользовались медленной продвинутой функциональностью^[118].

span (Си++20) и mdspan (Си++23)

• Функция submdspan, производящая слайсинг многомерных массивов. На выходе получается mdspan (Си++23), возможно, с нестандартным типом внутри^[119].
• Конструктор span(initalizer_list), не требующий промежуточного объекта вроде массива^[120].
• span.at(i), выкидывающий аварию^[121].
• mdspan с излишним выравниванием^[122].
  • Впоследствии сделали объект для излишнего выравнивания — aligned_accessor^[123].
• Улучшено угадывание статических (устанавливающихся при компиляции) габаритов mdspan, если таковые имеются^[124].
• std::mdspan<float, std::dextents<2>> a; — не столько для краткости, сколько для угадывания шаблонных параметров: mdspan a(storage.data(), height, width);^[125]

Параллельное программирование

Атомарный API

• atomic_fetch_min/max — вычисление минимума/максимума атомарной переменной и обычной, и запись полученного обратно в атомарную^[126].
• atomic и atomic_ref могут работать с cv-объектом. Предполагаемое назначение — объект в системной памяти и у него семантика volatile, а для доступа между потоками одной программы нужен atomic^[127]. Задним числом добавлен в Си++11 и далее.
• atomic_ref может давать указатель на неатомарный объект^[128]. Заявленные задачи: старый API на volatile; отход от атомарного доступа к неатомарному; атомарный доступ к полю объекта, а не ко всему объекту вместе; адрес вообще не надо разыменовывать (например, чтобы различать объекты).

Read-copy-update

Примитив неблокирующей синхронизации. Объект хранится в динамической памяти. Как только этот объект изменили, создают новый такой же, а старый, когда можно, удаляют^[129].

// Было — блокирующая версия
Data* data_;
std::shared_mutex m_;

template <typename Func>
auto reader_op(Func fn) {
  std::shared_lock<std::shared_mutex> l(m_);
  Data* p = data_;
  return fn(p);
}

void update(Data* newdata) {
  Data* olddata;
  { std::unique_lock<std::shared_mutex> wlock(m_);
    olddata = std::exchange(data_, newdata);
  }
  delete olddata;
}

// Стало — не блокируются только читатели
std::atomic<Data*> data_;

template <typename Func>
auto reader_op(Func fn) {
  std::scoped_lock l(std::rcu_default_domain());
  Data* p = data_;
  return fn(p);
}

void update(Data* newdata) {
  Data* olddata = data_.exchange(newdata);
  std::rcu_synchronize();
  delete olddata;
}

Hazard pointer

Главный недостаток идиомы read-copy-update в данном исполнении — не ждут только читатели, писатель может надолго «зависать». Это «зависание» означает, что другие читатели работают и держат объект, но не всегда допустимо.

Hazard pointer дополнительно следит, какие потоки пользуются тем или иным объектом, и как только объект перестаёт использоваться, он исчезает^[130].

Идиома похожа на подсчёт ссылок, но подсчитывает только локальные ссылки из функций доступа — а не глобальные ссылки между объектами. Это позволяет циклические ссылки без слежения, чей «ранг» выше (от «контейнеров» к «содержимому» — shared_ptr, в прочие стороны — weak_ptr), а также без присущего shared/weak_ptr управляющего объекта, исчезающего, когда исчезнет последний слабый указатель.

Система сделана беспрепятственной по записи ценой повышенного расхода памяти: read-copy-update хранит одно поколение старых данных, а hazard pointer — сколько угодно^[66].

Поскольку G++ всё ещё держит совместимость двоичных интерфейсов, на будущие дополнения оставили 4/8 байтов на объект.

(Старая блокирующая версия — та же)

// Стало — не блокируется и писатель
struct Data : std::hazard_pointer_obj_base<Data> {}
std::atomic<Data*> pdata_;

template <typename Func>
auto reader_op(Func userFn) {
  std::hazard_pointer h = std::make_hazard_pointer();
  Data* p = h.protect(pdata_);
  return userFn(p);
}

void writer(Data* newdata) {
  Data* old = pdata_.exchange(newdata);
  old->retire();
}

Фреймворк асинхронно-параллельного исполнения

Предполагается, что немалые части этой библиотеки будут написаны не на Си++. Два главных объекта — планировщик (scheduler) и задача на исполнение (sender), оба — концепции (sender auto). Для тех, кто сам пишет планировщики, есть объект receiver для этой же задачи^[131].

using namespace std::execution;

scheduler auto sch = thread_pool.scheduler();

sender auto begin = schedule(sch);
sender auto hi = then(begin, []{
    std::cout << "Hello world! Have an int.";
    return 13;
});
sender auto add_42 = then(hi, [](int arg) { return arg + 42; });

auto [i] = this_thread::sync_wait(add_42).value();

Антон Полухин из Яндекса считает, что пока у этой системы есть недостатки: она устроена на шаблонах и концепциях (нет единого полиморфного объекта для передачи между библиотеками), и крайняя низкоуровневость^[132].

В ноябре 2024 добавили объекты prop и env^[133].

Математика

• В библиотеку рациональных чисел (Си++11) добавлены новые приставки СИ ронна-, ронто-, кветта-, квекто-^[134].

Арифметика с насыщением (упором в край)

Стандартная работа беззнаковых типов — арифметика остатков: при переходе через ${\displaystyle 2^{n}}$ значение превращается в 0. Знаковые — зависят от реализации. Но это не всегда нужно: например, ${\displaystyle 2^{n}-1}$ может означать «сколько угодно» и прибавление к нему единицы должно оставлять ${\displaystyle 2^{n}-1}$. Никакой защиты от дурака нет. Поддерживаются четыре арифметических действия и преобразование типов. Деление с упором div_sat при делении на ноль перестаёт быть константным^[135].

# include <numeric>

// Считаем, что у нас 8-битный char и отрицательные в дополнительном коде
int x1 = add_sat(3, 4);               // 7
int x2 = sub_sat(INT_MIN, 1);         // INT_MIN
unsigned char x3 = add_sat(255, 4);   // 3!! — работа в int и преобразование 259 → 3
unsigned char x4 = add_sat<unsigned char>(255, 4);   // 255
unsigned char x5 = add_sat(252, x3);  // Ошибка, нет нужной перегрузки
unsigned char x6 = add_sat<unsigned char>(251, x2);  // 251!! — преобразование INT_MIN → 0
unsigned char x7 = saturate_cast<unsigned char>(-5);  // 0

Заполненная линейная алгебра

Добавились BLAS-подобные алгоритмы линейной алгебры для заполненных (большей частью ненулевых) векторов и матриц^[136]. Мотивация^[136]:

• Комитет Си++ сам поставил линейную алгебру приоритетом.
• Си++ — стандартная платформа для наукоёмкого ПО, которому линейная алгебра более чем нужна.
• Это как сортировка массива: примитивные алгоритмы медленные, а самые быстрые реализации можно получить аппаратно-специфичными улучшениями.
• В стандарте Си++ и так много разной математики — и умножение матриц не менее важно, чем функции Бесселя.
• BLAS — известный стандарт линейной алгебры, мало менявшийся с годами.
• Это такой же путь к интеграции в Си++ сторонних стандартов, как Юникод (идёт работа) и часовые пояса.

Конструкция полностью шаблонная и на mdspan. Преимущества перед стандартным BLAS:

• Работают любые типы, в том числе смешанные (данные в float, расчёт в double), а не только четыре стандартных BLAS’овских.
• Можно оптимизировать работу с матрицами небольших жёстко заданных габаритов — например, через SIMD.
• С небольшими изменениями возможно будет запустить целый пакет заданий (например, для машинного обучения).

Пока вне рассмотрения: расширенные функции BLAS/LAPACK, разреженная алгебра, расчёты повышенной точности, тензоры («матрицы» с тремя и более измерениями), параллельная работа, перегрузка операций ±. Последняя — из-за неоднозначности (есть несколько типов умножения векторов), данные могут быть в одном типе, а работа в другом, и из-за больших объёмов памяти и многоступенчатых расчётов промежуточные буфера часто используются повторно.

Добавлены^[136]:

• Простейшие операции с матрицами вроде сложения
• Поиск, как надо повернуть вектор в 2D, чтобы одна из координат равнялась нулю (поворот Гивенса)
• Разные виды норм векторов и матриц
• Операции y := Ax, y := Ay, z := y + Ax для матриц общего вида, а также симметричных/эрмитовых/треугольных
• Операции A:=A + xyᵀ + yxᵀ, A:=A + αxxᵀ для симметричных/эрмитовых матриц (для эрмитовых матриц — вместо транспонирования соответственно эрмитово сопряжение)
• Операции A := xyᵀ, C := BA, C:=E + BA для матриц общего вида
• Операции C := BA, C := AC, C := CA, C:=E + BA для симметричных/эрмитовых/треугольных матриц
• Операция с симметричной/эрмитовой матрицей C :=C + αAAᵀ (матрица C была симметричной/эрмитовой и в результате ею останется, матрица A общего вида)
• Операция с симметричной/эрмитовой матрицей C:=C + ABᵀ + BAᵀ
• Решение треугольной СЛАУ, а также серии таких СЛАУ с общей матрицей

Нет даже решения заполненных СЛАУ. Вот одна из стандартных функций — решение треугольной СЛАУ на месте.

template<in-matrix InMat,
         class Triangle,
         class DiagonalStorage,
         inout-vector InOutVec>
void triangular_matrix_vector_solve(
  InMat A,
  Triangle t,
  DiagonalStorage d,
  InOutVec b);

Здесь пустой тип-тэг Triangle показывает, каким треугольником собрана матрица, верхним или нижним. Аналогичный тэг DiagonalStorage — что представляет собой диагональ матрицы A: явные значения или неявные единицы. В векторе b изначально правая часть системы, в результате расчёта будет решение.

Семейство инкрементальных генераторов псевдослучайных чисел Philox

В параллельных расчётах сложно получить псевдослучайность: если брать несколько независимых генераторов (multistream approach), то чем их инициализировать, чтобы не случилась атака «дней рождения»? Можно также брать 2-е, 12-е, 22-е число (substream approach)^[137], но арифметический генератор потребует 10 пусков на каждое число. В таких случаях используют специальные инкрементальные (основанные на счётчике) генераторы псевдослучайных чисел — к счётчику (единицы машинных слов) прибавляется 1, затем обрабатывается очень слабым шифром^[138]. Потоки либо получают каждый по генератору с далёкими друг от друга значениями счётчика^[138] в уверенности, что последовательности не пересекутся (multistream approach), либо берут 2-е, 12-е, 22-е число без потери производительности (substream approach)^[137].

В Си++ добавлено семейство инкрементальных генераторов Philox (2011)^[139], и две специализации philox4x32 и philox4x64. Поведение каждой жёстко заспецифицировано: 10 000-й запуск версии 4×32 даст число 1 955 073 260. Семейство широко распространено и независимо реализовано у NumPy^[138], nVidia, AMD, Intel, Microsoft…

Поддержка SIMD

Сложная долго разрабатывавшаяся библиотека^[140]. Пример:

float * addr = ...;
void f(std::simd<double>x ) {
  x.copy_to(addr, std::simd_flag_convert |
            std::simd_flag_overaligned<16 >);
}

Работа с неопределённым поведением

observable — барьер для неопределённого поведения

Функция observable является барьером для неопределённого поведения^[141] — всё, что до неё, если само не является неопределённым, должно пройти нормально. Например, она может служить для автотестов на неопределённое поведение, или как барьер перед сомнительным действием.

void b(int &r, int *p) {
  if (!p) std::fprintf(stderr, "count: %d\n", ++r);
  std::observable();
  if (!p) std::fprintf(stderr, "p is null\n");
  *p += r;    // Из-за этой строки компилятор может считать, что p ≠ null
}

Функция не обязательно «магическая» (встроенная в компилятор); одна из возможных реализаций — доступ к volatile-переменной. На многозадачность никак не влияет и не заменяет межпоточную синхронизацию.

Не принято, но ожидается: любая проверка контракта — вызов этой же std::observable^[142].

Укреплённая библиотека

Си++ много думает над тем, как сделать новый код безопаснее, но надо налаживать безопасность здесь и сейчас, тем более доклад Белого дома (февраль 2024) говорит, что Си++ — очень опасный язык. Предлагается новая версия стандартной библиотеки — укреплённая. Некоторые (пока немногие) предусловия, обычно выход за диапазон, превращаются в нарушение контракта^[143].

Может быть вопрос: а зачем это, если и без контрактов будет аварийный останов? Может и не быть, а тихо испортить память или выдавать другие ошибки: разыменование пустого std::optional может выдать что угодно^[43].

Ожидаются, но не одобрены

• Структуры данных
  • path_view, аналог string_view для путей^[144]. По факту variant, способный ссылаться без хранения на пути разных форматов и оперативно перекодировать в системный вид — rendered_path, буфер достаточно больших размеров с возможностью запросить ещё больше, выделив память.
• Многозадачность:
  • Параллельные очереди^[145].
  • «Волокна», элементы стековой кооперативной многозадачности^[146]. Сопрограммы Си++20 бесстековые, то есть могут использоваться в любой среде, где есть setjmp/longjmp и выделение памяти (в автономной нет даже их).
• Прочее:
  • Улучшения в библиотеке диапазонов^[147].
  • Замена integral_constant на более простой в использовании constexpr_v^[148].
  • Улучшение рефлексии при компиляции^[2].

Будут неизвестно когда

Ожидается добавление дополнительных важных функций, однако пока не ясно, будут ли они готовы к сроку Си++26^[149].

• Библиотечная поддержка сопрограмм (языковая есть в Си++20)
• Сеть — не удалось сделать модульный подход
• Некое pattern matching — возможно, используя ключевое слово inspect, аналог switch, действующий даже на разные объектные подтипы и разные шаблоны строк^[150]

Комментарии

1. Здесь и далее «лёгкий/тяжёлый» — по системным ресурсам (процессорному коду, расходу памяти и т. д.), «простой/сложный» — по работе программиста, «простейший» — по функциональности.
2. Компактный — выбирает простой или стандартный вид в зависимости от того, что короче. С целой частью — не может выдавать запись .5. Точный — производит достаточно цифр, чтобы обратное преобразование вернуло ту же дробь до бита. Нелокализованный — жёстко закодирована так называемая «локаль Си»: набор цифр ASCII 0…9, знак отрицательного числа ASCII дефис-минус, разделитель дроби точка, разделителя тысяч нет.