Standarden C++26 är godkänd

ISO-kommittén för standardisering av C++-språket har godkänt den slutliga versionen av specifikationen som utgör den internationella standarden "C++26". De funktioner som presenteras i specifikationen stöds delvis redan av kompilatorerna GCC, Clang och Microsoft Visual C++. Standardbiblioteken som stöder C++26 har implementerats inom ramen för Boost-projektet.

Under de kommande två månaderna kommer den godkända specifikationen att vara i beredning för publicering, där arbete kommer att utföras för att redigera stavfel och tryckfel. I början av november kommer den slutgiltiga versionen av dokumentet att skickas till ISO för publicering under det formella namnet ISO/IEC 14882:2026.

Huvudfunktionerna i C++26:

• Element för kontraktsprogrammering (Contracts) har implementerats, vilket gör det möjligt att definiera formella specifikationer för gränssnitt med tre nya operatörer: pre (före), post (efter) och contract_assert (kontroll av påstående). Operatören "pre" definierar förutsättningar som måste uppfyllas före anrop (kontroll av ingångsvärden); "post" — villkor som måste efterlevas efter utförandet (krav på utdata); contract_assert — villkor för undantag. Denna funktionalitet kommer att finnas i GCC 16. int f(const int x) pre (x != 1) // krav på ingångsvärden post (r : r == x && r != 2) // krav på resultat; r — resultatvärdet { contract_assert (x != 3); return x; }
• Stöd för reflektion (Reflection) har lagts till, vilket gör det möjligt att spåra och modifiera programkomponenter under kompilering. Nya operatörer "^^" har lagts till för att få meta-information om grammatiska konstruktioner och "[:…:]" för att utföra omvandlingar. För att omvandla och behandla informationen som erhållits genom inspektion har biblioteket std::meta föreslagits och funktioner som konstantberäkningar är tillgängliga. Stöd för reflektion kommer att läggas till i 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’ och ‘j’ har olika värden. static_assert(constant_of(^^i) == constant_of(^^j)); // ‘i’ och ‘j’ är identiska static_assert(^^i != std::meta::reflect_constant(42)); // skiljer sig från värdet 42
• En operator "template for" har lagts till för att iterera över element som paket av parametrar, tuples-liknande objekt och reflektionsresultat (metaobjekt) under kompilering i stil med en vanlig loop. Vid körning av "template for" utvecklas loopens kropp för varje element och varje iteration behandlas i ett eget synfält där den föränderliga variabeln i loopen är en konstant. I reflektionssammanhang kan "template for" användas för att iterera över egenskaper hos klasser eller enumerationer. Möjligheten kommer att finnas i GCC 16. void f() { template for (constexpr int I : std::array{1, 2, 3}) { static_assert(I < 4); } } kommer att utvecklas till: 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); } } }
• Ett ramverk std::execution har lagts till för asynkront och parallellt utförande av kod. Objekt som scheduler tillhandahålls, vilket definierar schemaläggaren för att utföra arbete (tråd, trådpool, GPU, händelseloop), sender som definierar det utförda arbetet, och receiver - resultatbehandlaren. 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();
• Biblioteket std::simd har lagts till för att parallellisera utförandet av operationer på data med hjälp av SIMD-instruktionsuppsättningar som AVX-512 och NEON, med den standardiserade typ systemet 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;
• En implementation av en vektor (array) av variabel storlek std::inplace_vector, som placeras på stacken, har föreslagits och storleken bestäms vid kompilering. API:n ligger nära std::vector, men elementen i arrayen lagras inte i "heap", utan inuti objektet. inplace_vector a(10); inplace_vector b(std::move(a)); assert(a.size() == 10);
• Direktivet "#embed" har lagts till för att integrera binära resurser i koden. const unsigned char icon_display_data[] = { #embed "art.png" };
• Stöd för generering och hantering av undantag under kompilering vid fel i kontexten constexpr har lagts till. 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); }
• Datakonstruktionen std::hive för oordnad lagring av data och återanvändning av minne frigjort efter borttagna element har implementerats. Konstruktionen är optimerad för belastningar med hög intensitet av tillägg och borttagning av element i godtycklig ordning. Till skillnad från arrayer, orsakar borttagning av ett element i std::hive ingen förskjutning av andra element, utan det borttagna elementet markeras som tomt, och den frigjorda positionen fylls vid tillägg av ett nytt element.
• Biblioteket std::linalg med API för linjär algebra som baseras på BLAS har lagts till.
• Stöd för synkroniseringsmekanismen Hazard pointer har lagts till, vilket gör det möjligt att förhindra frigöring av minnet för objekt som fortfarande används i andra trådar utan att sätta upp lås. Vid borttagning av ett objekt markeras det endast som borttaget, men det minne som objektet använder frigörs först när alla trådar har lyft hazard-pekarna som sätts under arbetet med objektet.
• Stöd för synkroniseringsmekanismen RCU (Read-Copy Update) har lagts till — vid skrivoperationer skapas en ny instans av objektet, medan läsoperationer inte blockeras utan fortsätter att arbeta med den gamla instansen. Efter att ändringen har slutförts blir den nya instansen aktiv och nya läsoperationer utförs med den, medan den gamla instansen tas bort efter att alla läsande trådar har slutfört.
• Ändringar har gjorts för att stärka säkerheten i standardbiblioteket, såsom kontroller av giltiga värden och överträdelse av gränser för bufferten. Till exempel, vid åtkomst till elementet «constexpr reference operator[](size_type idx) const;» läggs en kontroll in av villkoret «idx < size()».
• Möjlighet att använda nyckelordet «constexpr» med en variant av operatorn «new» (placement new) för att placera ett objekt i förutbestämd minne under kompilering har tillhandahållits.
• Stöd för strukturerade bindningar (structured binding) har lagts till i kontexten "constexpr", vilket innebär att referenser till konstanter nu själva kan vara konstanter. Stöd har implementerats för arrayer och enkla strukturer. constexpr int arr[] = {1, 2}; constexpr auto [x, y] = arr;
• I de strukturerade bindningarna har möjligheten att använda syntaxen "…" lagts till för att ange paket (pack) som fångar det återstående antalet element från den tilldelade sekvensen. auto [x,y,z] = f(); // tre element returnerade av f() kommer att skrivas till variablerna x, y, z. auto […xs] = f(); // alla element returnerade av f() kommer att skrivas till paketet xs. auto [x, …rest] = f(); // x kommer att få det första elementet och rest de återstående. auto [x, y, …rest] = f(); // x kommer att få det första elementet, y det andra och rest det tredje. auto [x, …rest, z] = f(); // x får det första, rest det andra och z det tredje.
• Stöd för "trivially relocatable" typer (Trivial Relocatability) har lagts till, vilket möjliggör optimering av flyttningar av objekt av en viss typ genom att klona dem i minnet utan att kalla på konstruktorer eller destruktorer. För klasser har egenskaperna memberwise_trivially_relocatable och memberwise_replaceable implementerats, och för lågnivåflyttning av ett eller flera objekt har funktionerna trivially_relocate_at och trivially_relocate lagts till.
• Stöd för att koppla funktionen main() till det globala modulen och definiera funktionen main() i namngivna moduler har implementerats.
• Den variabla operatören "friend" ("friend Ts…") har lagts till.
• Attribut för strukturerade bindningar har implementerats.
• Syntaxen ‘= delete(«orsak»)’ har lagts till.
• Tecken som "@", "$" och "`" har lagts till i grunduppsättningen av tecken.
• Möjligheten att använda strukturerad bindning (structured binding) som villkor i if- och switch-operatorer har tillhandahållits.
• Möjligheten att använda flera variabler med namnet „_” i en och samma domän har lagts till, exempelvis är följande konstruktioner nu giltiga: struct S { int _, _; }; void func() { int _, _; } void other() { int _; // tidigare visades en varning i läge -Wunused }
• Möjligheten att använda strängliteraler i kontexter där de inte används för att initiera teckenarrayer och inte ingår i den resulterande koden, utan endast används vid kompilering för diagnostiska meddelanden och preprocessning, exempelvis som parametrar för direktiv och attribut _Pragma, asm, extern, static_assert, [[deprecated]] och [[nodiscard]].
• Inbyggda funktioner har lagts till: «__builtin_is_within_lifetime» för att kontrollera aktiviteten hos alternativ i unioner och «__builtin_is_virtual_base_of» för att kontrollera om basklassen är virtuell.
• Triviala oändliga loopar har implementerats utan obestämd beteende.
• Ett felmeddelande ges vid borttagning av pekaren till en ofullständig typ.
• Syntaxen för att definiera variabla parametrar med tre prickar utan föregående kommatecken har förklarats som föråldrad (till exempel när det anges «void e(int…)» istället för «void e(int, …)»).
• Användning av makron för att deklarera moduler är förbjudet.
• Implicit omvandling av uppräknade värden till aritmetiska beräkningar har klassificerats som föråldrad. int main() { enum E1 { e }; enum E2 { f }; bool b = e <= 3.7; // föråldrat int k = f - e; // föråldrat int x = +f - e; // OK }
• Stödet för direkt jämförelse av arrayer har upphört. int arr1[5]; int arr2[5]; bool same = arr1 == arr2;
• Den mallklass is_trivial har förklarats som föråldrad.
  
  Källa: opennet.ru