C++26 standard on heaks kiidetud

ISO komitee, mis tegeleb C++ keele standardimisega, on läbi viinud viimase variandi spetsifikatsiooni, mis loob rahvusvahelise стандарди "C++26". Spetsifikatsioonis esitatud omadused on osaliselt juba toetatud GCC, Clang ja Microsoft Visual C++ kompilaatorites. C++26 standardraamatukogud on ellu viidud projekti Boost raames.

Järgmise kahe kuu jooksul viib kinnitatud spetsifikatsiooni dokument valmistamise etappi, kus teostatakse redigeerimist õigekirja- ja trükivigade osas. Novembri alguses saadetakse dokumendi tulemuseks ISO-sse avaldamiseks ametliku nime all ISO/IEC 14882:2026.

C++26 peamised jooned:

• On rakendatud lepinguprogrammeerimise (Contracts) elemendid, mis võimaldavad määratleda formaalsed spetsifikatsioonid liideste jaoks kolme uue operaatori abil: pre (eeltingimus), post (järgtingimus) ja contract_assert (väidete kontroll). Operaator „pre“ määratleb eeltingimused, mis peavad olema täidetud enne kutsumist (sisendite kontroll); „post“ – tingimused, mis peavad olema täidetud pärast täitmist (väljade nõuded); contract_assert – erandite tekkimise tingimused. See funktsionaalsus lisatakse GCC 16-sse. int f(const int x) pre (x != 1) // sisendite nõuded post (r : r == x && r != 2) // tulemuse nõuded; r – tulemuse väärtus { contract_assert (x != 3); return x; }
• Lisatud on refleksiooni (Reflection) tugi, mis võimaldab jälgida ja muuta programmi elemente kompileerimise etapis. Uued operaatorid „^^“ on lisatud meta-informatsiooni saamiseks grammatilise konstruktsiooni kohta ja „[:…:]“ tagasimuundamiseks. Eldis KGTK ja vastavad võimalused, nagu konstantide arvutamine, on saadaval raamatukogus std::meta. Refleksiooni tugi lisatakse GCC 16-sse. 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' ja 'j' omavad erinevaid väärtusi. static_assert(constant_of(^^i) == constant_of(^^j)); // 'i' ja 'j' on samad static_assert(^^i != std::meta::reflect_constant(42)); // erineb väärtusest 42
• Lisatud on "template for" operaator, et läbida elemente, nagu parameetrite paketid, tuple-sarnased objektid ja refleksiooni tulemused (metaobjektid), kompilatsiooni etapis tavalisest tsüklist. "Template for" läheneb tsükli kehale igas iteratsioonis eraldi nähtavuses, kus tsükli muutuja on konstant. Refleksiooni kontekstis võib "template for" kasutada klasside või loendite omaduste läbimiseks. See võimalus saabub GCC 16. void f() { template for (constexpr int I : std::array{1, 2, 3}) { static_assert(I < 4); } } paisutatakse: 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); } } }
• Lisatud on std::execution raamistik asünkroonsete ja paralleelsete koodide täitmiseks. Pakutakse välja scheduler objekte, mis määratleb töödeldavate ülesannete plaani (töötlus, niitide bassein, GPU, sündmuste tsükkel), sender, mis määratleb täidetava töö, ja receiver, mis on tulemuse töötleja. using namespace std::execution; scheduler auto sch = thread_pool.scheduler(); sender auto begin = schedule(sch); sender auto hi = then(begin, []{ std::cout < "Tere maailm! Olgu int."; return 13; }); sender auto add_42 = then(hi, [](int arg) { return arg + 42; }); auto [i] = this_thread::sync_wait(add_42).value();
• Lisatud on std::simd raamatukogu, et paralleelselt teostada andmete operatsioone SIMD instruktsioonide kogumitega, nagu AVX-512 ja NEON, kasutades C++ standardtüübide süsteemi. 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;
• Pakkumine on välja töötada muutuva suurusega vektor (massiv) std::inplace_vector, mis on paigutatud kuhja ja mille suurus määratakse kompilatsiooni etapis. API on lähedane std::vector'ile, kuid massiivid hoitakse mitte "kuhjas", vaid objekti sees. inplace_vector a(10); inplace_vector b(std::move(a)); assert(a.size() == 10);
• Lisatud on direktiiv "#embed", mis on mõeldud binaarsete ressursside koodile manustamiseks. const unsigned char icon_display_data[] = { #embed "art.png" };
• Lisatud genereerimise ja töötlemise toe tugi kompileerimise etapis, kui esinevad vead kontekstis 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); }
• Rakendatud andmestruktuur std::hive ebaühtlase andmete salvestamise ja kustutatud elementide vabaneva mälu taaskasutamise tagamiseks. Struktuur on optimeeritud koormuste jaoks, kus elementide lisamine ja kustutamine toimub suures mahus suvalises järjekorras. Erinevalt massiividest ei põhjusta std::hive's elemendi kustutamine teiste elementide nihkumist, vaid eemaldatud element märgistatakse tühjaks ning vabanev asend täidetakse uue elemendi lisamise korral.
• Lisatud std::linalg teek lineaaralgebra jaoks, mis põhineb BLAS-il.
• Lisatud Hazard pointeri sünkroniseerimise mehhanismi tugi, mis võimaldab vältida objektide mälu vabastamist ilma lukustuseta, kui objektidega töötatakse teistes lõimed. Kui objekt kustutatakse, märgistatakse see lihtsalt kustutatuks, kuid objekti kasutatud mälu vabastatakse alles siis, kui kõik lõimed eemaldavad hazard-viitaja, mis on määratud objekti töötamise ajal.
• Lisatud RCU (Read-Copy Update) sünkroniseerimismehhanismi tugi — kirjutamise toimingute ajal luuakse objekti uus eksemplar, samas kui lugemise toimingud ei blokeeru, vaid jätkavad töötlust vana eksemplariga. Pärast muudatuste lõpetamist muutub uus eksemplar aktiivseks ja uued lugemisoperatsioonid viiakse ellu selle kaudu, samal ajal kui vana eksemplar kustutatakse pärast kõigi lugemisega tegelevate lõimede lõpetamist.
• Tehtud muudatused standardbiblioteegi turvalisuse parandamiseks, näiteks lubatavate väärtuste ja mälupiiride kontrollid. Näiteks elemendi „constexpr reference operator[](size_type idx) const;” juurde lisatakse tingimuse „idx < size()" kontroll.
• Antud võimalus kasutada märksõna „constexpr” koos „new” operaatori (placement new) variandiga, et paigutada objekt eelnevalt reserveeritud mällu kompileerimise ajal.
• Lisatud on struktureeritud sidemete (structured binding) tugi 'constexpr' kontekstis, st konstantsete väljendite viidatud variandid võivad nüüd ise olla konstantsete väljendite. Tugi on rakendatud massiivide ja lihtsate struktuuride jaoks. constexpr int arr[] = {1, 2}; constexpr auto [x, y] = arr;
• Struktureeritud sidemetes on lisatud '...' süntaksi kasutamise võimalus pakettide (pack) näitamiseks, mis haaravad ülejäänud elemendid määratud järjestusest. auto [x,y,z] = f(); // muutuja x, y, z saavad kolm elementi, mille f() tagastab. auto […xs] = f(); // paketis xs saavad kõik elemendid, mille f() tagastab. auto [x, …rest] = f(); // x-s on esimene element ja rest-s ülejäänud. auto [x, y, …rest] = f(); // x-s on esimene element, y-s teine ja rest-s kolmas. auto [x, …rest, z] = f(); // x-s on esimene, rest-s teine ja z-s kolmas.
• Lisatud on 'triviaalne liigutatavus' (Trivial Relocatability) tüüpi toetamine, mis võimaldab optimeerida objektide liigutamist määratud tüübi kaudu nende kloonimisega mälus ilma konstruktorite või destruktorite kutsumata. Klasside jaoks on rakendatud omadused memberwise_trivially_relocatable ja memberwise_replaceable, ning madala taseme ühe või mitme objekti liigutamiseks on lisatud funktsioonid trivially_relocate_at ja trivially_relocate.
• Rakendatud on funktsiooni main() kinnitamise toetus globaalsetesse moodulitesse ja funktsiooni main() määramine nimetatud moodulites.
• Lisatud on variatiivne operaator 'friend' ('friend Ts…').
• Rakendatud on atribuudid struktureeritud sidemete jaoks;
• Lisatud on süntaks '= delete("põhjus")'.
• Algsesse sümbolite kogumisse on lisatud '@', '$' ja '`'.
• Pakutud on võimalust kasutada struktureeritud sidumist (structured binding) kui tingimust if ja switch operaatorites.
• Lisatud on võimalus kasutada mitut täitjat nimega '_' ühes ulatuses, näiteks, nüüd on järgmised konstruktsioonid õiged: struct S { int _, _; }; void func() { int _, _; } void other() { int _; // varem näidati hoiatust režiimis -Wunused }
• Sõneteadlike stringikujundite kasutamine on võimaldatud kontekstis, kus neid ei kasutata sümbolite massiivi algatamiseks ja nad ei satuks lõppkoodisse, vaid kasutatakse ainult kompileerimise ajal diagnostiliste sõnumite ja eeltöötluse jaoks, näiteks direktiivide ja atribuudi _Pragma, asm, extern, static_assert, [[deprecated]] ja [[nodiscard]] parametritena.
• Lisatud on hübriidfunktsioonid: „__builtin_is_within_lifetime” alternatiivide aktiivsuse kontrollimiseks ühendites (union) ja „__builtin_is_virtual_base_of” aluseks oleva klassi virtuaalsuse kontrollimiseks.
• On rakendatud triviaalsetes lõpututes tsüklites, mis ei sisalda määramatut käitumist.
• Viga näidatakse, kui proovite kustutada osutajat ebatäielikule tüübile.
• Mugavuse huvides on deklareeritud suhtes ettenähtud sarnaste parameetrite defineerimise süntaks, kus enne kolme punkti pole koma (näiteks „void e(int…)“ asemel „void e(int, …)“).
• Makrode kasutamine moodulite deklareerimiseks on keelatud.
• On liigitatud vananenuks, kui selgesõnaliselt muudetakse loetelu väärtusi arvutustes. int main() { enum E1 { e }; enum E2 { f }; bool b = e <= 3.7; // vananenud int k = f — e; // vananenud int x = +f — e; // OK }
• Toetuse lõpetamine otse massiivide võrdlemiseks. int arr1[5]; int arr2[5]; bool same = arr1 == arr2;
• Mugavused on klassifitseeritud nagu is_trivial.
  
  Allikas: opennet.ru