🥇 C++26 standard on heaks kiidetud

C++-i standardimise ISO komitee on lõpetanud rahvusvahelise standardi „C++26” lõpliku spetsifikatsiooni heakskiitmise. Spetsifikatsioonis esitatud võimalustest toetavad osa juba GCC, Clang ja Microsoft Visual C++ kompilaatorid. C++26 standardiga ühilduvad teegid on teostatud Boost projekti raames.

Järgmise kahe kuu jooksul kinnitatud spetsifikatsioon läbib dokumendi avaldamise ettevalmistuse etapi, kus viiakse läbi toimetamis- ja trükiveakontroll. Novembri alguses saadetakse lõplik dokument ISO-le avaldamiseks formaalse nimega ISO/IEC 14882:2026.

C++26 peamised omadused:

On realiseeritud lepinguprogrammeerimise elemendid (Contracts), mis võimaldavad määratleda vormilised spetsifikatsioonid liideste jaoks kolme uue operaatori abil: pre (eeltingimus), post (järgtingimus) ja contract_assert (väite kontrollimine). Operaator "pre" määratleb eeltingimused, mis peavad olema täidetud enne kutsumist (sisendi kontroll); "post" - tingimused, mis peavad olema täidetud pärast täitmist (väljundi nõuded); contract_assert - erandite tekkimise tingimused. See võimalus saabub GCC 16-s. int f(const int x) pre (x != 1) // sisendi 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 grammatilise konstruktsiooni meta-informatsiooni saamiseks ning «[:…:]» tagasisuunatava muundamise teostamiseks. Muundamiseks ja kontrollimise käigus saadud teabe töötlemiseks on pakutud std::meta teek ja saadaval on sellised võimalused nagu konstantidega arvutamine. Refleksiooni tugi lisatakse 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’ ja ‘j’ omavad erinevaid väärtusi. static_assert(constant_of(^^i) == constant_of(^^j)); // ‘i’ ja ‘j’ on sama static_assert(^^i != std::meta::reflect_constant(42)); // erineb väärtusest 42
Lisatud on «template for» operaator elementide, nagu tuletiste sarnaste objektide ja peegeldamise (metaobjektid) pakettide läbimiseks, mis toimub kompileerimise etapis tavalise tsükli stiilis. Kui «template for» käivitatakse, avatakse tsükli keha iga elemendi jaoks ja iga iteratsioon töödeldakse eraldi ulatuses, kus tsüklis muutuv muutuja on konstant. Peegeldamise kontekstis võib «template for» rakendada klasside või loetelude atribuutide läbimiseks. See funktsionaalsus peaks ilmuma GCC 16. void f() { template for (constexpr int I : std::array{1, 2, 3}) { static_assert(I < 4); } } avatakse järgmisena: 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 std::execution raamistik koodi asünkroonseks ja paralleelseks täitmiseks. Pakutakse scheduler objekte, mis määratleb tööd tehtava ajakava (protsess, niitide kogum, GPU, sündmuste tsükkel), sender, mis määratleb täidetava töö, ja receiver — 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 < "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();
Lisatud std::simd teek andmete töötlemise operatsioonide paralleelimiseks, kasutades SIMD käske nagu AVX-512 ja NEON, C++ standardse tüüpide süsteemi abil. 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;
Pakutud on muutuva suurusega vektori (massivi) std::inplace_vector rakendust, mis asub kuhjas ja mille suurus määratakse kompileerimise käigus. API on sarnane std::vector'ile, kuid massiivi elemendid hoitakse mitte "virnas", vaid objekti sees. inplace_vector a(10); inplace_vector b(std::move(a)); assert(a.size() == 10);
Lisatud direktiiv «#embed», mis on mõeldud binaarsete ressursside koodi integreerimiseks. const unsigned char icon_display_data[] = { #embed «art.png» };
Lisatud tugi genereerimiseks ja erandite töötlemiseks kompileerimise etapis, kui esinevad vead constexpr kontekstis. 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, et hoida andmeid mittekorrastatult ja tagada mälule, mis on vabanenud kustutatud elementide tõttu, korduvkasutamine. Struktuur on optimeeritud kõrge elemendi lisamise ja kustutamise intensiivsusega koormuste jaoks, olenemata nende järjekorrast. Erinevalt massiividest ei põhjusta std::hive elemendi kustutamine teiste elementide nihkumist, vaid kustutatud elemendi märgistamine tühjaks, millele järgnevalt täidetakse vabaks saanud asukoht uue elemendi lisamisel.
Lisatud raamatukogu std::linalg, millel on API lineaaralgebra jaoks, mis põhineb BLAS-il.
Lisati toetatakse Hazard pointeri sünkroniseerimise mehhanismi, mis võimaldab vältida objektide mälust vabastamist, millega jätkatakse töötamist teistes lõimedes, ilma lukustamisteta. Objekti kustutamisel, lihtsalt märgitakse see kustutatuks, kuid objekti poolt hõivatud mälu vabastatakse alles siis, kui kõik lõimed eemaldavad hazard-viit, mis on kehtestatud objekti töötamise ajal.
Lisati toetatakse RCU (Read-Copy Update) sünkroniseerimise mehhanismi — kirjutamistegevuste puhul luuakse uus objekti eksemplar ning lugemisoperatsioonid ei blokeeru, vaid jätkavad töö tegemist vana eksemplariga. Pärast muudatuse lõpetamist muutub uus eksemplar aktiivseks, ja uued lugemisoperatsioonid tehakse juba selle baasil, mille järel vana eksemplar eemaldatakse pärast nende lugemist lõpule viinud lõimede lõpetamist.
Tehtud muudatused standardraamatukogu turvalisuse tugevdamiseks, nagu lubatud väärtuste ja mälupiiride kontrollimised. Näiteks, kui pääsete juurde elemendile „constexpr reference operator[](size_type idx) const;”, lisatakse kontroll tingimuse „idx < size()".
Proovis võimalust kasutada võtmesõna „constexpr“ koos uue operatori tüübiga (placement new), et paigutada objekt eelnevalt eraldatud mällu kompileerimise ajal.
Lisatud on struktureeritud sidemete tugi (structured binding) „constexpr“ kontekstis, see tähendab, et viidatud konstantsetele väljenditele võivad nüüd olla samuti konstantseteks väljenditeks. Tugi on rakendatud massiivide ja lihtsate struktuuride jaoks. constexpr int arr[] = {1, 2}; constexpr auto [x, y] = arr;
Struktureeritud sidemetes on lisatud võimalus kasutada süntaksit „…“ pakettide (pack) määramiseks, et haarata ülejäänud elemendid määratud järjestusest. auto [x,y,z] = f(); // muutuja x, y, z saavad kolm elementi, mis f() tagastab. auto […xs] = f(); // paketti xs saavad kõik elemendid, mis f() tagastab. auto [x, …rest] = f(); // x-sse salvestatakse esimene element, rest-i — ülejäänud. auto [x, y, …rest] = f(); // x-sse salvestatakse esimene element, y-sse — teine, rest-i — kolmas. auto [x, …rest, z] = f(); // x-sse — esimene, rest-i — teine, z-sse — kolmas.
Lisatud tugi tüüpi „triviaalne nihutatavus” (Trivial Relocatability), mis võimaldab optimeerida objektide liikumist läbi nende kloonimise mälus ilma konstruktorite või destruktorite kutsumiseta. Klasside jaoks on rakendatud omadused memberwise_trivially_relocatable ja memberwise_replaceable ning madala taseme nihutamiseks ühe või mitme objekti puhul on lisatud funktsioonid trivially_relocate_at ja trivially_relocate.
Rakendatud on toetust funktsiooni main() sidumiseks globaalsetele moodulitele ja funktsiooni main() määratlemiseks nimetatud moodulites.
Lisatud on muutujaoperaator „friend” („friend Ts…”).
Rakendatud on atribuudid struktureeritud sidumist jaoks;
Lisatud on süntaks „= delete(„põhjus”)”.
Algsete sümbolite komplekti on lisatud „@”, „$” ja „`”.
On antud võimalus kasutada struktureeritud sidumist tingimuseks protseduurides if ja switch.
Lisatud võimalus kasutada korraga mitut täitmismuutuja nimega „_“ ühes ulatuses, näiteks on nüüd kehtivad konstruktsioonid: struct S { int _, _; }; void func() { int _, _; } void other() { int _; // varem kuvati hoiatust režiimis -Wunused }
Antud võimalus kasutada stringi literaale kontekstis, kus neid ei kasutata märgistusmassiivide initsialiseerimiseks ja nad ei satu lõppkoodisse, vaid kasutatakse ainult kompileerimise ajal diagnostikateadeteks ja eelprotsessimiseks, näiteks direktiivide ja atribuutide _Pragma, asm, extern, static_assert, [[deprecated]] ja [[nodiscard]] parameetritena.
Lisatud sisseehitatud funktsioonid: „__builtin_is_within_lifetime“ alternatiivi aktiivsuse kontrollimiseks liitumistes (union) ja „__builtin_is_virtual_base_of“ kontrollimiseks, kas põhiklass on virtuaalne.
Tehtud triviaalsete lõputute tsüklite rakendamine ilma määratlemata käitumiseta.
Tagatakse viga, kui proovitakse kustutada näidikut mittetäieliku tüübi peale.
Muutus, et variatiivsete parameetrite määramise süntaks sümpaatilise kolmpunkti kujul on aegunud, kui eelnevat koma ei ole (näiteks, kui on märgitud «void e(int…)» asemel «void e(int, …)»).
Moodulite deklareerimiseks ei ole lubatud makrode kasutamine.
Aegunud on varjatud teisenduste tegemine aritmeetilistes arvutustes loetletud väärtustega. int main() { enum E1 { e }; enum E2 { f }; bool b = e <= 3.7; // aegunud int k = f - e; // aegunud int x = +f - e; // OK }
Otse massiivide võrdlemise to support on katkestatud. int arr1[5]; int arr2[5]; bool same = arr1 == arr2;
Aegunud on malliklass is_trivial.

Allikas: opennet.ru

Kinnitamisel C++26 standard