Утвърден стандарт C++26

Комитетът на ISO за стандартизация на езика C++ завърши и утвърди финалната версия на спецификацията, която образува международния стандарт „C++26“. Представените възможности в спецификацията частично вече се поддържат в компилаторите GCC, Clang и Microsoft Visual C++. Поддържащите C++26 стандартни библиотеки са реализирани в рамките на проекта Boost.

През следващите два месеца утвърдената спецификация ще бъде на етап подготовка на документа за публикация, по време на който ще се извърши редакционна проверка на правописни грешки и печатни грешки. В началото на ноември окончателният вариант на документа ще бъде изпратен в ISO за публикуване под формалното име ISO/IEC 14882:2026.

Основни характеристики на C++26:

• Реализирани са елементи на контрактното програмиране (Contracts), които позволяват да се определят формални спецификации на интерфейсите с помощта на три нови оператора: pre (предусловие), post (постусловие) и contract_assert (проверка на твърдения). Операторът „pre“ определя предварителни условия, които трябва да бъдат изпълнени преди извикването (проверка на входните данни); „post“ — условия, които трябва да се спазват след изпълнението (изисквания за изходните данни); contract_assert — условия, при които възникват изключения. Възможността ще се появи в GCC 16. int f(const int x) pre (x != 1) // изисквания към входните данни post (r : r == x && r != 2) // изисквания към резултата; r — стойността с резултата { contract_assert (x != 3); return x; }
• Добавена е поддръжка на рефлексия (Reflection), която позволява проследяване и модифициране на елементи на програмата на етап компилация. Добавени са нови оператори „^^“ за извличане на метаинформация за граматичната конструкция и „[:…:]“ за извършване на обратно преобразуване. За преобразуване и обработка на получената в резултат на инспекция информация е предложена библиотека std::meta, а налични са такива възможности, като изчисления с константи. Поддръжката на рефлексия ще бъде добавена в GCC 16. constexpr int i = 42, j = 42; constexpr std::meta::info r = ^^i, s = ^^i; static_assert(r == r && r == s); static_assert(^^i != ^^j); // ‘i’ и ‘j’ имат различни стойности. static_assert(constant_of(^^i) == constant_of(^^j)); // ‘i’ и ‘j’ са еднакви static_assert(^^i != std::meta::reflect_constant(42)); // различава се от стойността 42
• Добавен е операторът «template for» за итериране на елементи като пакети параметри, подобни на кортежи, обекти и резултати от рефлексия (метаобекти) на етапа на компилация в стил на обикновен цикъл. При изпълнение на «template for» тялото на цикъла се разкрива за всеки елемент и всяка итерация се обработва в отделна област на видимост, където променливата, променяща се в цикъла, е константа. В контекста на рефлексията «template for» може да се приложи за обход на свойствата на класове или изброявания. Възможността ще се появи в GCC 16. void f() { template for (constexpr int I : std::array{1, 2, 3}) { static_assert(I < 4); } } ще бъде разкрито в: void f() { { constexpr auto&& __range = std::array{1, 2, 3}; constexpr auto __begin = __range.begin(); constexpr auto __expansion-size = __range.end() — __begin; // 3 { constexpr int I = *(__begin + 0); static_assert(I < 4); } { constexpr int I = *(__begin + 1); static_assert(I < 4); } { constexpr int I = *(__begin + 2); static_assert(I < 4); } } }
• Добавен е фреймворкът std::execution за асинхронно и паралелно изпълнение на код. Осигуряват се обекти scheduler, определящи планировчика за изпълнение на работи (нишка, пул от нишки, GPU, event loop), sender, определящ работа за изпълнение, и receiver — обработчик на резултата. 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();
• Добавена е библиотеката std::simd за паралелизиране на изпълнението на операции върху данни с помощта на набори от инструкции SIMD, като AVX-512 и NEON, използвайки стандартната система от типове C++. std::simd a = {1.0f, 2.0f, 3.0f, 4.0f}; std::simd b = {5.0f, 6.0f, 7.0f, 8.0f}; std::simd result = a + b;
• Предложена е реализация на вектор (масив) с променлив размер std::inplace_vector, разположен в стека, чийто размер се определя на етапа на компилация. API-то е близко до std::vector, но елементите на масива се съхраняват не в «куче», а вътре в обекта. inplace_vector a(10); inplace_vector b(std::move(a)); assert(a.size() == 10);
• Добавена е директивата «#embed», предназначена за вграждане на бинарни ресурси в кода. const unsigned char icon_display_data[] = { #embed "art.png" };
• Добавена е поддръжка за генериране и обработка на изключения на етап компилиране при грешки в контекста на constexpr. constexpr std::optional checked_divide(unsigned n, unsigned d) { try { return divide(n, d); } catch (…) { return std::nullopt; } } constexpr date parse_date(std::string_view input) { auto [correct, year, month, day] = ctre::match(input); if (!correct) { throw incorrect_date{input}; } return build_date(year, month, day); }
• Реализирана е структура от данни std::hive за неупорядочено съхранение на данни и осигуряване на повторно използване на паметта, освободена след изтрити елементи. Структурата е оптимизирана за натоварвания с висока интензивност на добавяне и изтриване на елементи в произволен ред. За разлика от масивите, изтриването на елемент в std::hive не предизвиква преместване на другите елементи, а просто помечава изтрития елемент като празен, с последващо запълване на освободената позиция при добавяне на нов елемент.
• Добавена е библиотеката std::linalg с API за линейна алгебра, базирана на BLAS.
• Добавена е поддръжка на механизма за синхронизация Hazard pointer, който позволява да се предотврати освобождаването на паметта на обекти, с които продължава да се работи в други нишки, без използване на блокировки. При изтриване на обект той само се помечава като изтрит, но паметта, заемана от обекта, се освобождава само когато всички нишки свалят hazard-указателя, зададен по време на работа с обекта.
• Добавена е поддръжка на механизма за синхронизация RCU (Read-Copy Update) — при операции на запис се създава нов екземпляр на обекта, а операциите на четене не се блокират, а продължават да работят със стария екземпляр. След завършване на промените новият екземпляр става активен и новите операции за четене вече се извършват с него, а старият екземпляр се изтрива след завършване на четящите го потоци.
• Внесени са промени за усилване на сигурността на стандартната библиотека, като проверки на допустимите стойности и изходи извън границите на буфера. Например, при достъп до елемента "constexpr reference operator[](size_type idx) const;" се добавя проверка за условието "idx < size()".
• Предоставена е възможност за използване на ключовата дума "constexpr" с разновидността на оператора "new" (placement new) за разполагане на обект в предварително заделена памет по време на компилация.
• Добавена е поддръжка на структурирани привръзки (structured binding) в контекста на «constexpr», т.е. препратки към константни изрази сега също могат да бъдат константни изрази. Поддръжката е реализирана за масиви и прости структури. constexpr int arr[] = {1, 2}; constexpr auto [x, y] = arr;
• В структурирани свързвания е добавена възможност за използване на синтаксиса „...“ за указване на пакети, които захващат останалите елементи от присвояваната последователност. auto [x,y,z] = f(); // в променливите x, y, z ще бъдат записани три елемента, върнати от f(). auto […xs] = f(); // в пакета xs ще бъдат записани всички елементи, върнати от f(). auto [x, ...rest] = f(); // В x ще бъде записан първият елемент, а в rest — останалите. auto [x, y, ...rest] = f(); // В x ще бъде записан първият елемент, в y — вторият, а в rest — третият. auto [x, ...rest, z] = f(); // в x — първият, в rest — вторият, в z — третият.
• Добавена е поддръжка на «тривиалната преместване» (Trivial Relocatability), която позволява оптимизиране на премeстванията на обекти от определен тип чрез клонирането им в паметта без извикване на конструктори или деструктори. За класовете са реализирани свойствата memberwise_trivially_relocatable и memberwise_replaceable, а за нискоуредно преместване на един или няколко обекта са добавени функциите trivially_relocate_at и trivially_relocate.
• Реализирана е поддръжка за свързване на функция main() с глобалния модул и определяне на функция main() в именувани модули.
• Добавен е вариативен оператор «friend» («friend Ts…»).
• Реализирани са атрибути за структурирани привръзки;
• Добавен е синтаксис ‘= delete(«причина»)’.
• В базовия набор от символи са включени «@», «$» и «`».
• Предоставена е възможност за прилагане на структурирано свързване (structured binding) като условие в операторите if и switch.
• Добавена е възможност за използване на няколко променливи-запълнители с име «_» в една и съща област на видимост, например, сега валидни конструкции са: struct S { int _, _; }; void func() { int _, _; } void other() { int _; // преди това се извеждаше предупреждение в режим -Wunused }
• Предоставена е възможност за използване на стринг литерали в контексти, в които не се използват за инициализиране на масив от символи и не попадат в резултатния код, а се прилагат само по време на компилация за диагностични съобщения и препроцесиране, например, като параметри на директиви и атрибути _Pragma, asm, extern, static_assert, [[deprecated]] и [[nodiscard]].
• Добавени са вградени функции: «__builtin_is_within_lifetime» за проверка на активността на алтернативи в обединения (union) и «__builtin_is_virtual_base_of» за проверка дали базовият клас е виртуален.
• Реализирани са тривиални безкрайни цикли без неопределено поведение.
• Осигурено е извеждане на грешка при опит за изтриване на указател към непълен тип.
• Обявен за остарял синтаксис на определяне на вариативни параметри с многоточие без предшестваща запетая (например, когато се посочва «void e(int…)» вместо «void e(int, …)»).
• Забранено е използването на макроси за дефиниране на модули.
• Преведено в категорията на остарелите изпълнението на неявни преобразувания на избираеми стойности в аритметични изчисления. int main() { enum E1 { e }; enum E2 { f }; bool b = e <= 3.7; // остаряло int k = f — e; // остаряло int x = +f — e; // OK }
• Поддръжката на директното сравнение на масиви е прекратена. int arr1[5]; int arr2[5]; bool same = arr1 == arr2;
• Шаблонният клас is_trivial е обявен за остарял.
  
  Източник: opennet.ru