C++26

Эту статью предлагается удалить. Пояснение причин и соответствующее обсуждение вы можете найти на странице Википедия:К удалению/8 августа 2023. Пока процесс обсуждения не завершён, статью можно попытаться улучшить, однако следует воздерживаться от переименований или немотивированного удаления содержания, подробнее см. руководство к дальнейшему действию. Не снимайте пометку о выставлении на удаление до подведения итога обсуждения. Последнее изменение сделано участником Mercury (вклад · журналы) в 18:33, 18 февраля 2025 (UTC; около 5 часов назад). Администраторам и подводящим итоги: ссылки сюда история журналы удалить

Эта статья во многом или полностью опирается на первичные источники. Такие источники рассматриваются как нежелательные. А если они не опубликованы, то они не допустимы по правилу проверямости. Вместо этого следует использовать опубликованные вторичные научные источники, рассматривающие данную тему. Вы можете отредактировать статью, добавив ссылки на вторичные научные источники.

Возможно, эта статья содержит оригинальное исследование. Проверьте соответствие информации приведённым источникам и удалите или исправьте информацию, являющуюся оригинальным исследованием. В случае необходимости подтвердите информацию авторитетными источниками. В противном случае статья может быть выставлена на удаление. (12 сентября 2024)

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. Февраль 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]] осталась, но больше ничего не делает.

• Весь заголовок <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].

Для начала придумали понятие «невычисляемая строка» (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.

Теперь его можно получить как 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, концепций и шаблонных параметров новый механизм бесполезен: этим объектам либо нужно говорящее имя, либо Си++ уже даёт подходящие механизмы вроде безымянных типов.

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

Одно из назначений оператора 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 сильнее } 

Иногда нужно отказаться от автоматического присваивания, одной из унаследованных функций или нежелательного преобразования типа. В Си++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) {} 

Замечено, что многие нетривиальные объекты стандартной библиотеки могут менять свою дислокацию в памяти значительно проще, чем конструктором перемещения и деструктором. Так что две новых концепции, связанные с производительностью^[43]:

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

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

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

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

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

Также добавили функцию std::relocate, похожую на работу с неинициализированной памятью — производит переезд полным или сокращённым образом. На входе этой функции рабочий объект и неинициализированная память, на выходе — неинициализированная память и рабочий объект.

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

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

Очень часто нужно вставить в программу двоичные данные в форме «как есть» — источник^[62] упоминает резервную прошивку, которую надо установить, когда пользователь просит полный сброс устройства, 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.

Преобразование данных в машинный порядок байтов не предусмотрено, данные вставляются как есть.

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

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

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

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

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

• Унифицировано форматирование указателей^[85].
• Параметры ширины теперь также проверяются при компиляции^[86].
• Форматирование строк, заранее не известных: 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 принимается только по временной ссылке^[87].
• В само́м make_format_args избавились от std::forward и временных объектов, делая форматирование более устойчивым к висячим ссылкам^[88].
• Серьёзная ошибка, ранее случившаяся в fmt (прообразе format): кодовые единицы char, будучи отформатированы как числа или с «широкой» форматной строкой, выдавали зависящий от реализации вид^[89]. Теперь char, отформатированный как число, будет unsigned; отформатированный как символ в широком контексте — символом с кодом 0…255.
• Форматирование path^[90].

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Было — блокирующая версия 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; } 

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

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

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

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

Поскольку 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 для этой же задачи^[130].

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(); 

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

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

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

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

# 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-подобные алгоритмы линейной алгебры для заполненных (большей частью ненулевых) векторов и матриц^[135]. Мотивация^[135]:

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

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

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

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

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

• Простейшие операции с матрицами вроде сложения
• Поиск, как надо повернуть вектор в 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 изначально правая часть системы, в результате расчёта будет решение.

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

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

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

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

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

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^[141].

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

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

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

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

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