C++17

Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt közreműködők, és jelentősen eltérhet a 2021. május 5-én felülvizsgált verziótól ; az ellenőrzések 17 szerkesztést igényelnek .

A C++17 (más néven C++1z) a C++ szabvány ISO /IEC verziójának neve. A C++17 specifikációit 2017 decemberében tették közzé [1] [2] .

A konstans értéke a __cpluspluslett 201703L, ezt használjuk a feltételes fordításhoz .

Eltávolítva vagy kitiltva

Trigráfok eltávolítva

A trigráfokat nem szabványos kódolású és/vagy korlátozott billentyűzettel rendelkező gépeknél használták. A 80-as évek végén, a 8 bites kódolások és az olcsó gumimembrán billentyűzetek elterjedésével a trigráfok tulajdonképpen értelmüket vesztették, harminc évvel később pedig természetesen kizárták [3] [4] .

// A következő sor végrehajtásra kerül??????????????????/ a ++ ; /* trigráfokkal ez a sor megjegyzésre kerül - trigráf ??/ egyenértékű a következővel: \ */

Eltávolított regisztrációs kulcsszó

A C nyelv "hordozható assembler" volt: lehetővé tette gyors, különböző számítógépeken lefordító programok készítését, emellett assembler segédprogramokat ( linker , librarian) is használt. Az olyan fogalmak, mint a „ fejlécfájl ” és a „ fordítási egység ” ezeknek az időknek a visszhangja.

A szó registereredetileg a program kézi optimalizálásához kapcsolódott. A modern fordítók „a motorháztető alatt” rengeteg optimalizálást hajtanak végre, és az ilyen kézi vezérlés feleslegesnek tűnik. A C++11-ben a szót nemkívánatosnak nyilvánították. A szó továbbra is fenntartva van, és egy nap más célra is felhasználható – mint például a C++11-ben [5] . auto

A bool ++ művelet eltávolítva

A művelet nyilvánvalóan nem biztonságos, és tiltott a C++98-ban [6] . A művelet --hiányzik.

A deklarált kivételek eltávolítva

A bejelentett kivételek void f() throw(A, B, C);, amelyek például a Java -ban találhatók, többet ártanak, mint használnak. C++11-ben kitiltották, C++17-ben eltávolították. A [7]throw() szinonimája maradt . noexcept(true)

Eltávolítottuk azokat a típusokat és funkciókat, amelyeket lecseréltek (és betiltottak) a C++11-ben

Köztük std::auto_ptrrégi std::random_shufflefunkcionális adapterek [8] [9] .

Ehelyett a unique_ptr, és a / shufflefüggvényen alapuló új függvénysablonok használatosak . Azt állítják, hogy bármely kód mechanikusan konvertálható -ra , egy egyszerű kiegészítéssel, ha a tulajdonjog átruházására kerül sor. functionbindauto_ptrunique_ptrstd::move

A C++98-ban [10]iostream tiltott különálló részeket is eltávolították .

Eltávolították az std::függvény konstruktorait, amelyek elfoglaltak egy allokátort

Összesen öt túlterhelés, beleértve ezt az egyet is

sablon < classAlloc > _ function ( std :: allocator_arg_t , const Alloc & alloc ) noexcept ;

Az érthetetlen szemantika és megvalósítási nehézségek miatt előzetes tiltás nélkül eltávolították [11] .

A szabványos könyvtár rendkívül ritka funkciói tilosak

A standard könyvtár számos ritka funkciója tiltott: [12] [13] [14]

  • allocator<void> - nem igényeltnek bizonyult;
  • egyes funkciókat allocator a sablon duplikál allocator_traits;
  • raw_storage_iterator - nem hív meg konstruktorokat, ezért korlátozott az alkalmazási területe;
  • get_temporary_buffer - nyilvánvaló buktatói vannak;
  • is_literal_type - használhatatlan az általános kódhoz, de addig marad, amíg a C++-ban van a "literális típus" fogalma;
  • iterator - egyszerűbb a nulláról iterátorokat írni, mint ráépíteni;
  • codecvt - valójában nagyon rosszul működött, a bizottság szakkönyvtárak használatát szorgalmazta;
  • shared_ptr::unique() - a megbízhatatlanság miatt többszálú környezetben.

Azt ígérik, hogy teljesen eltávolítják őket C++20-ban.

Új C++17 függvényekkel kapcsolatos tilalmak

  • result_of→ invoke_resultegy egyszerűbb szintaxis, amely C++11 típusú következtetésen alapul [15] ;
  • bool uncaught_exception()→ int uncaught_exceptions() - egy kivétel feldolgozása során a rendszer dobhat egy másikat, így több kivétel kezeletlenül „lóghat”. Annak ellenőrzése, hogy közülük hány volt a konstruktorban és hány a destruktorban, megbízhatóbb és „ingyenes” módszer a rendelkezésre álló könyvtárak szempontjából annak meghatározására, hogy a destruktor alól kivételt kell-e adni vagy sem [16] [ 17] [18] .

C-könyvtár fejlécek eltávolítva

A C11-re való átállással a fejlécek <ccomplex>, <cstdalign>, <cstdbool>, <ctgmath>. A fájl <ciso646>nem tiltott [19] .

autox{}; már nem hoz létre inicializáló_listát

A C++11-hez hozzáadott univerzális inicializátor int x{};lehetővé teszi objektumok, struktúrák, tömbök létrehozását egyetlen szintaxissal. A C++17-ben tisztázva van: ha típus helyett áll , akkor a autofelhasználó egy objektumot szeretne létrehozni, és nincs szükség inicializáló_listára.

Ugyanakkor auto x = {1, 2, 3};folytatja a létrehozást: egyrészt a kompatibilitás érdekében , másrészt for (auto x : {1, 2, 3})egy objektumhoz auto x = 1;[20] [9] tartozik .

auto x1 = { 3 }; // std::initializer_list<int> auto x2 { 1 , 2 }; // hiba most auto x3 { 3 }; // int

Globális változások

A kivételspecifikáció mostantól a típusrendszer része

A és függvények  mostantól különböző típusú függvények (de nem alkothatnak túlterhelt halmazt). Ez lehetővé teszi, hogy az API visszahívásokat kérjen , amelyek nem dobnak kivételeket, valamint optimalizálja a kódot egyikre sem [21] . void f() noexcept(true);void f() noexcept(false);

Új túligazított

A C++11 bevezette az elméletinél nagyobb illesztésű adatstruktúrák létrehozásának lehetőségét. Ezt a lehetőséget felvette az új művelet [22] .

osztály alignas ( 16 ) float4 { float f [ 4 ]; }; float4 * p = új float4 [ 1000 ];

Az új operátor túlterhelt egy további paraméterrel, amely a túligazított objektum helyes kiosztását szolgálta a memóriában.

A másolás kötelező selejtezése

A prvalue fogalom jelentése megváltozott: most már csak inicializálás.

Bár a kódhoz SomeType a = 10;továbbra is szükség van a konstruktorra és az = operátorra, garantáltan csak a konstruktort hívják meg.

Ez azt jelenti, hogy a függvények olyan típusokat adhatnak vissza, amelyeket nem lehet másolni és áthelyezni.

Szigorúbb értékelési sorrend

Most a a.b, a->b, a->*b, a(b1, b2, b3), b += a(és más műveletek analógjai), a[b], a << bés műveletek a >> ba → b sorrendben kerülnek kiértékelésre a mellékhatások ellenőrzése érdekében [23] .

Ha függvényként hívjuk meg őket (például operator += (a, b)), a sorrend definiálatlan marad.

Kibővítette az "állandó a sablonban" fogalmát

Vannak olyan sablonok, amelyek elfogadnak egy állandót.

template < int N > struct Tömb { int a [ N ]; };

Mi lehet konstans N, és mi nem - ellenkezőleg. A sablonban lévő konstans nem lehet mutató mezőre, ideiglenes objektumra, karakterlánc-literálra, eredményre typeidvagy szabványos változóra __func__[17] [24] ;

A számára különböző típusú eleje és vége lehet

A most for (auto v : x)azt jelenti , hogy lehetővé teszi a különböző típusok kezdetét és végét. auto __begin = begin-expr; auto __end = end-expr;

Ez az alapja a tartományokon keresztüli iterációnak, ami egy folyamatban lévő munka [25] .

Szerkesztői változások

A "folyamatos iterátor" fogalma

Az std::vector és std::string tömbök a memória összefüggő régióival foglalkoznak. Bevezették a "folyamatos iterátor" [26] [27] fogalmát . Elvileg semmi sem változott.

Definíciókat is adtak más fogalmakhoz – továbbítási hivatkozás , alapértelmezett taginicializáló , sablonos entitás . Ez a munka a C++20 koncepciókon .

Azok az u'x' és U'x' karakterek, amelyeket nem egy karakter kódol, tilos

Korábban ezt a viselkedést implementáció határozta meg.

Ezzel egy időben készítettek "UTF-8 karaktereket", amelyek típusa van, és 0-tól 127-ig terjedő kódokat tartalmazhat, hasonlóan az UTF-8 karakterláncokhoz - úgy tűnik, hogy a program kevésbé függ a számítógépen lévő területi beállításoktól [ 17] [28] . char

Átmenetileg letiltva a memory_order_consume

A nem megfelelő szemantika miatt a „fogyaszt” rendelési módot verbálisan (jel nélkül ) betiltották, az „acquire” módszer alkalmazását szorgalmazva. Az új szemantikával kapcsolatos munka még folyamatban van, és talán egyszer feloldják a tilalmat [29] . [[deprecated]]

Mindenesetre a PowerPC -n és az ARM -en minden letöltés automatikusan elfogy , de nem mindegyik szerzi be , és a fogyasztási módszer többplatformos kódban mentheti az órákat [30] .

Nyelv

static_assert egy argumentummal

Ha static_assertnem működik, nem mindig szükséges elmondani a programozónak, hogy mi a baj - gyakran ő maga is kitalálja a szövegkörnyezetből. [31] .

static_assert ( sizeof ( wchar_t ) == 2 );

inline a globális változókhoz és konstansokhoz

Most már írhat a fejlécfájlba, és amikor ezt a fájlt tartalmazza a cpp fájlokban, akkor mindegyik ugyanarra az objektumra fog hivatkozni (az osztálykonstruktort nem hívják meg ismételten minden cpp fájlnál, ellentétben a vagy -vel ), inline const ClassName INSTANCE_NAMEconst ClassName INSTANCE_NAMEstatic const ClassName INSTANCE_NAME

Új szabványos megjegyzések

  • [[fallthrough]]: az operátor egyik szekciójában switchszándékosan „esünk át” a következőbe. A Duff eszköz lehetséges megvalósítása
int n = ( szám + 7 ) / 8 ; if ( ! count ) return ; kapcsoló ( számlálás % 8 ) { 0. eset : do { * to = * from ++ ; [[ fallthrough ]]; 7. eset : * -tól = * -ig ++ ; [[ fallthrough ]]; 6. eset : * -tól = * -ig ++ ; [[ fallthrough ]]; 5. eset : * -tól = * -ig ++ ; [[ fallthrough ]]; 4. eset : * -tól = * -ig ++ ; [[ fallthrough ]]; 3. eset : * -tól = * -ig ++ ; [[ fallthrough ]]; 2. eset : * -tól = * -ig ++ ; [[ fallthrough ]]; 1. eset : * -tól = * -ig ++ ; } while ( -- n > 0 ); }
  • [[nodiscard]]: egy függvény eljárásként történő meghívása hibának minősül - például ez egy "tiszta" függvény, mint a string::empty()[32] , amelynek egyetlen feladata egy érték visszaadása, vagy egy objektumprotokoll megköveteli, hogy valamit tenni a visszaadott értékkel, mint pl. unique_ptr::release(). A későbbi C++20 szabványban lehetővé vált a hívás sikertelenségének okának megadása.
class SmartPtr { // az egyedi_ptr public saját megvalósítása : /// Felügyelt objektumot átad kézi vezérlésre /// @mutató visszaadása felügyelt objektumhoz [[ nodiscard ]] Payload * release (); }; SmartPtr p ; Hasznos teher * adatok = p . kiadás (); // smart pointer helyes használata adatok törlése ; o . kiadás (); // figyelmeztetés: figyelmen kívül hagyja a 'SmartPtr::release()' visszatérési értékét, a nodiscard ( void ) p attribútummal deklarált . kiadás (); // így hallgatják el a figyelmeztetést
  • [[maybe_unused]]: az egyik fordítási módban ( Windows / POSIX , debug/release) ez vagy az az elem nem használatos, és ez nem hiba.
// A QString mindig UTF-16, a wstring pedig operációs rendszer függő sablon < int Sz > void append ( QString & s , előjel nélküli hosszú ch ); // Windows verzió, wstring = UTF-16 sablon <> [[ Maybe_unused ]] inline void append < 2 > ( QString & s , unsigned long ch ) { s . append ( static_cast < uint16_t > ( ch ); } // POSIX verzió, wstring = UTF-32 sablon <> [[ Maybe_unused ]] void append < 4 > ( QString & s , unsigned long ch ) {} // a kódpozíció kódolása UTF-16-ban, a rövidség kedvéért hagyd ki std :: wstring s = L " \U0001F60E " ; // smiley szemüveggel QString r ; // A rövidség kedvéért pontos másolatot készítünk, és nincs szükség ilyen összetett kódra. // De néha szükség van rá valamilyen feldolgozás során - például unescape karakterek esetén. for ( auto c : s ) append < sizeof ( c ) > ( r , c ); Vagy szándékosan nem használjuk a paramétert, de a nevet meghagyjuk a dokumentációnak. osztály ISoccerSeason { // nyilvános felület : /// @pre mindkét csapat részt vesz ebben a szezonban. /// @return true, ha a mérkőzést hazai és vendégcsapatok játszják /// @warning Egy tipikus futballszezonban mindkét csapat hazai és vendégcsapattal is játszik. virtual bool doTeamsPlay ([[ Maybe_unused ]] const Team & home , [[ Maybe_unused ]] const Team & away ) const { return true ; } virtual ~ ISoccerSeason () = alapértelmezett ; };

Típusnév használata beágyazott sablonokban

A C++ nyelv hibája: sablonokban typenameés classhelyenként nem cserélhető [33] .

template < template < typename > class X > struct C ; // OK template < template < typename > typename X > struct D ; // nem fordít

Mindkét kulcsszó kifejezetten felcserélhetőnek van nyilvánítva.

Strukturális összekapcsolás

Megjelent az összetett objektumok kicsomagolásához szükséges változók deklarálásának új módja, az úgynevezett strukturális kötés [34] .

auto [ hely , wasInserted ] = someMap . emplace ( kulcs , érték );

Párokhoz, sorokhoz és más típusokhoz működik, ahol . std::get

Névtér A::B bejegyzés

Beágyazott névterek meghatározása: [9] [35] namespace A::B {} a namespace A { namespace B {} };

Jegyzetek névterekhez és felsorolt ​​elemekhez

Például:

enum class TriBool { NEM , talán , IGEN , NN [[ Maybe_unused ]], NEM MEGHATÁROZOTT [[ elavult ( "Átnevezve erre: MAYBE" )]] = MAYBE }; constexpr int TriBool_N = static_cast < int > ( TriBool :: NN ); const char * triBoolNames [ TriBool_N ] = { "nem" , "talán" , "igen" };

Még nincs deklarált cél [17] [36] , de ez lehetővé teszi a fordítóprogramok fejlesztői számára, hogy előálljanak egy - például deklarálják, hogy az NN elem speciális, és nem kell változókhoz hozzárendelni, feldolgozása -ben switch.

Ha fordításkor

A SFINAE koncepció lehetővé tette egy olyan egyszerű sablon készítését enable_if, amely különböző funkcionalitást biztosít a különböző típusokhoz, de nehéz kódot ad. C++17-ben leegyszerűsíthetjük a programot: az operátor if constexpr(expression)példányosítja a kódot, ha a zárójelben lévő kifejezés igaz [37] .

sablon < classT > _ constexpr T abszolút ( T arg ) { return arg < 0 ? - arg : arg ; } sablon < classT > _ constexpr auto precision_threshold = T ( 0,000001 ); sablon < classT > _ constexpr bool close_enough ( T a , T b ) { if constexpr ( is_lebegő_pont_v < T > ) // << !! visszatér abszolút ( a - b ) < pontossági_küszöb < T > ; más return a == b ; }

Ebben az esetben ügyelünk arra, hogy a törtszámok közötti különbség kicsi legyen, és az egész számokat egyszerűen ellenőrizzük az egyenlőség szempontjából.

Egyszerűsített szintaxis bináris műveletekhez változósablonokban

Csomagolt kifejezések [17] [38] :

sablon < típusnév ... As > bool foo ( As ... args ) { return ( args && ...); }

Törtszámok hexadecimális ábrázolása

Hexadecimális mantissza és decimális kitevő: 0xC.68p+2, 0x1.P-126, hasonló a helyettesítéshez %a. A C a 99-es verzió óta támogatja ezt a szintaxist [39] .

Helyi változó inicializálása if/switchben

Hasonlóan a helyi változók inicializálásához a -ban for, kompaktabbá teszi a kódot [40] .

if ( auto it = m . find ( key ); it != m . end ()) return it -> second ;

Használata attribútumokban

// Void volt f ( ) { [[ rpr :: kernel , rpr :: target ( cpu , gpu )]] // ismétlés do_task (); } // Void lett f ( ) { [[ using rpr : kernel , target ( cpu , gpu )]] do_task (); }

Típus nélküli paraméterek a sablonokban

Lehetővé teszi bármilyen típusú sablon paraméter beállítását a [41] segítségével . auto

template < auto X > struct B { static constexpr auto value = X ; }; B < 5 > b1 ; // OK: a sablonparaméter típusa int B < 'a' > b2 ; // OK: a sablonparaméter típusa char B < 2.5 > b3 ; // hiba: a sablon paraméter típusa nem lehet dupla

Lambda objektum rögzítése *ez

Volt: . Ez lett: [42] . [self = *this]{ self.f(); }[*this]{ f(); }

Egy enum osztályt inicializálhat egy számmal

enum classnéha arra használnak, hogy egy másik, semmivel nem kompatibilis egész számtípust készítsenek. Mostantól az ilyen típusú változók inicializálhatók számokkal [43]

enum class Handle : intptr_t { INVALID = 0 }; Fogantyú h { 42 }; Fogantyú h = 42 ; // tilos

Könyvtár

Kisebb fejlesztések a könyvtárban

  • Nem állandó túlterhelés string::data. Alacsony szintű karakterlánc-függvények meghívására szolgál, amelyek egy bizonyos hosszúságú memóriát foglalnak el, és azt karakterekkel töltik meg (például WinAPI ). A C++11 előtt ezt használták const_cast<char*>(x.data()), a C++17 előtt pedig &x.front().
  • emplace_backaz egyik elem hivatkozást ad vissza. Lehetővé teszi, hogy valami ilyesmit írjon:
v . emplace_back ( "alpha" , "bravo" ). doSomething ();
  • A C szabványkönyvtár C99 -ről C11 -re frissült [44] .
  • Funkciók std::size(x), std::begin(x), std::end(x), std::empty(x). Lehetővé teszi az STL konténerek és tömbök közös alapkódjának írását [26] [45] . Ezenkívül az std:: size egy szükséges függvény, amely gyakran hibásan íródott le.
  • Részleges specializáció hozzáadva [46]bool_constant<bool B> = integral_constant<bool, B>;
  • Hozzáadott tulajdonságfüggvények a SFINAE -hez : , , , , (összetett típus), (triviálisan másolható objektum, és bármely két azonos értékű objektum ugyanazzal a belső reprezentációval rendelkezik).is_swappableis_nothrow_swappableis_swappable_withis_nothrow_swappable_withis_aggregatehas_unique_object_representations
  • Kibővített könyvtár az inicializálatlan memóriával való munkavégzéshez. Vannak , , , , , függvények , valamint ezek változatai n elemre.uninitialized_default_constructuninitialized_value_constructuninitialized_movedestroydestroy_at
  • Új sablon . Leegyszerűsíti a SFINAE sablonok létrehozását, amelyek bővíthetők, ha létezik T típus [47] .void_t<T> = void
  • Hozzáadott verzió keresőobjektummal . Alapértelmezés szerint három kereső van: Protozoan, Boyer-Moore és Boyer-Moore-Horspool .std::search
  • Az új függvény a T típust inicializálja egy sorból származó adatokkal.make_from_tuple
  • Az új állandó határozza meg, hogy az atomi változó nem blokkoló- e .atomic::is_always_lock_free
  • Hozzáadott funkciók a felfelé, lefelé és a legközelebbi kerekítéshez .chrono
  • Hozzáadtuk az elemek eldobásának ( ) és kivonásának ( ) függvényeit.map/setmergeextract
  • Hozzáadott típus .shared_ptr<T>::weak_type = weak_ptr<T>
  • Egyes esetekben az allokátorok típusa nem teljes. Most olyan rekurzív struktúrák, mint a . A nagyobb fordítók ezt már régóta támogatják, csak pontosítani kell.struct X { std::vector<X> data; };
  • Implicit konstruktorok hozzáadva a és -hoz .pairtuple
  • unique_ptr/shared_ptrműködhet C-stílusú tömbökkel ( ). A C++14-ben a megfelelő törlési funkciót kellett behúzni ( ).shared_ptr<string[]>(new string[n])shared_ptr<string[]>(new string[n], default_delete<string[]>() )
  • A [48] [49] munka finomításra került .common_type

Új típusú std::string_view

Gyakran előfordul, hogy változatlan karakterláncot kell átadnia egy másik kódrészletnek, ezt a következő módszerekkel teheti meg:

void doSmth ( const char * s ); // mi van, ha null karakter van a sztringben? Igen, és a függvény belseje hibás lesz void doSmth ( const std :: string & s ); // mi van, ha a karakterlánc nem karakterlánc, és memóriát kell lefoglalnunk?

A C++17 bevezetett egy típust – egy string_view karakterláncot, amelynek csak egy mutatója és egy hossza van, nincs tulajdonjog, nincs memóriakezelés, és nincs még nulla lezáró sem –, így nincs benne c_str(). Csak a szegélyek (eleje/hossz) módosíthatók, a karakterek nem. A programozó feladata, hogy megbizonyosodjon arról, hogy az objektum ne élje túl azt a memóriapuffert, ahol a karakterlánc található, és a paraméterek átadása remekül használható. Az objektum string_viewnagyon kicsi (2 bites gép), és nem hivatkozással, hanem értékkel kell átadni.

string_viewmaga egy absztrakció - elvonatkoztatja a karakterlánc tárolási módszert, egyetlen dolgot igényel - hogy a szöveges adatok egymást követő bájtok legyenek a memóriában. Csak összetett szokatlan szerkezetek (például heveder/kötél ) tárolnak véletlenszerű karakterláncokat. És az összes többi - és , és , és különféle tömbök - konvertálva . stringconst char*string_view

Gyorsítótár sormérete

Két új állandó van, hardware_constructive_interference_sizeés hardware_destructive_interference_size. Így a felhasználó elkerülheti a hamis megosztást (destruktív interferencia) és javíthatja a lokalitást (konstruktív interferencia).

struct keep_apart { alignas ( hardware_desstructive_interference_size ) atomic < int > cat ; alignas ( hardware_desstructive_interference_size ) atomic < int > dog ; // a macska távol áll a kutyától, különböző szálakból változtathatók. }; struct -together { atomi < int > kutya ; int kölyökkutya ; }; struct kennel { //... alignas ( sizeof ( együtt )) together pack ; //... }; static_assert ( sizeof ( együtt ) <= hardver_konstruktív_interferencia_méret ); // győződjön meg arról, hogy együtt egy gyorsítótár sor.

Elméletileg mindkét konstansnak azonosnak kell lennie, de a heterogén architektúrák támogatása érdekében úgy döntöttek, hogy két állandót készítenek. [ötven]

Az új share_mutex típus

Mutex, amely lehetővé teszi a párhuzamos olvasást és írást egy [51] . Az erre szolgáló blokkolókat shared_lockés unique_lock.

Automatikus tárolóparaméter-típus felismerés

A könyvtárban megjelentek a függvények, az úgynevezett levonási útmutatók , amelyek lehetővé teszik ezt:

std :: p pár ( 2 , 4,5 ); // egy std :: vektor < int > v = { 1 , 2 , 3 , 4 }; std :: vektor x ( v.begin ( ), v.end ( ) ) ; 2

Új funkciók az asszociatív tömbbe történő beszúráshoz nem ismétlődő kulccsal

A std::mapés std::unordered_mapkét új funkcióval bővült [52] .

#include <iostream> #include <térkép> osztály pár { nyilvános : int érték1 , érték2 ; Pár () : érték1 ( 0 ), érték2 ( 0 ) {} explicit pár ( int aÉrték1 ) : érték1 ( aÉrték1 ), érték2 ( 0 ) {} Pár ( int aValue1 , int aValue2 ) : érték1 ( aÉrték1 ), érték2 ( aÉrték2 ) {} }; int main () { std :: térkép < std :: string , Pair > m ; // C++11 m [ "a" ] = Pár ( 3 , 4 ); m . emplace ( "a" , 1 ); // A pár mindig létrejön // C++17 m . insert_or_assign ( "a" , Pár ( 3 , 4 )); m . try_emplace ( "a" , 1 ); // A pár létrejön, amikor szükséges return 0 ; }

Új matematikai függvények

Nem szabványos matematikai függvények kerültek be az std névtérbe: beta, , , , , , , , , , , [53] [54] . Nincsenek std-n kívül (in ). cyl_bessel_i/j/kcyl_neumann[comp_]ellint_1/2/3expinthermite[assoc_]laguerre[assoc_]legendreriemann_zetasph_besselsph_legendresph_neumannmath.h

Az első mondattól (2010): "Reméljük, hogy ennek a javaslatnak az elfogadása azt az üzenetet küldi a különböző számítástechnikai közösségeknek, hogy a közhiedelem ellenére a C++ az ő iparágukban is megfelelő." Aztán nem fogadták el. Most már a nagy könyvtárszállítók ( Dinkumware , Boost , GCC ) már rendelkeznek ezekkel a funkciókkal.

Szintén hozzáadva a GCD [55] és az LCM [56] számítását , a tartományba való redukció függvényét ( ) [57] , háromdimenziós hipotenúzát . clamphypot(x, y, z)

Fájlrendszer könyvtár

A következőre épülő fájlrendszer-könyvtár boost::filesystemlehetővé teszi: [58]

  • a fájlnevek automatikus nemzetközivé tétele az operációs rendszer jellemzőitől függően. A könyvtár elrejti a kódolást, amelyben működik, és maga alakítja át a neveket a kívántra - legalábbis a területi beállítás által meghatározott egybájtosra és különféle Unicode-változatokra;
  • címtárbejárás (rekurzív is);
  • fájltípusok meghatározása (regular, directory , socket ...);
  • a fájl elérési útjának felosztása összetevőkre: meghajtó, könyvtár, név és kiterjesztés;
  • könyvtárak létrehozása, fájlok másolása, könyvtárak és fájlok törlése (rekurzív is);
  • nevek lekérése az ideiglenes fájlokhoz .

Változótípusok

Volt egy osztály , amely bármilyen típusú adatot tartalmazhatott [59] [60] . Megvalósításokra van szükség ahhoz, hogy kis objektumokat memória lefoglalása nélkül illesszen be. A függvény a típus pontos egyezését igényli, és nem ad semmit, ha a . std::anyanyany_castany_cast<double>int

std :: cout << std :: boolalpha ; std :: bármely a = 1 ; std :: cout << a . típus (). név () << ": " << std :: any_cast < int > ( a ) << std :: endl ; a = 3,14 ; std :: cout << a . típus (). név () << ": " << std :: any_cast < double > ( a ) << std :: endl ; a = igaz ; std :: cout << a . típus (). név () << ": " << std :: any_cast < bool > ( a ) << std :: endl ; // i: 1 // d: 3,14 // b: igaz

Vannak egyszerűbb std::variant<int, bool, double>és std::optional<T>.

Alacsony szintű szám-szöveg átalakítási függvények

A C++ ismert hátránya: a számok alacsony szintű szöveggé konvertálásához memóriafoglalás nélkül nehéz és megbízhatatlant kell futtatni sprintf, és a szöveg C-vel hagyott számmá történő beépített konvertálása meglehetősen megbízhatatlan.

Jelenleg beépített helyi-független szupersebesség from_chars[61] és to_chars[62] . Úgy vannak megtervezve, hogy nem igényelnek (és nem állítanak elő) záró nullát, és működhetnek pl string_view. Korlátozásuk és helyi függetlenségük miatt elsősorban JSON -hoz és XML -hez készültek , ahol óriási sebességre van szükség.

Új típus polymorphic_allocator

Az STL adatstruktúrák ( karakterláncok , vektorok stb.) tartalmaznak egy sablonparamétert - egy memórialeosztót. Ez az allokátor általános programozási koncepcióként működik , nem objektum-orientált interfészként: a halomban és a készletben lévő memória lefoglalása különböző inkompatibilis típusokat eredményez. Az osztály  egy ritka feladat szokásos kezdete: bizonyos feltételektől függően foglaljon le memóriát a kupacban vagy a készletben. polymorphic_allocator

Önmagában  nem interfész, de egy interfészhez van társítva . polymorphic_allocatormemory_resource

Új sablon std::invoke

Lehetővé teszi a függvények, objektumok () operátorral ( functors ) és lambda objektumok következetes hívását [63] . Szintén hozzáadott funkciók , , . is_invocableis_invocable_rinvoke_result

STL algoritmusok párhuzamos változatai

69 algoritmushoz , és párhuzamos változatokat találtak ki [64] [65] [66] . <algorithm><numeric><memory>

Lásd még

Linkek

Jegyzetek

  1. ↑ ISO/IEC 14882:2017 . Letöltve: 2017. december 4. Az eredetiből archiválva : 2013. május 17.
  2. ↑ Legutóbbi mérföldkövek: a C++17 szinte teljes körű, a TS-ek második köre jelenleg fejlesztés alatt áll . Letöltve: 2016. március 28. Az eredetiből archiválva : 2020. szeptember 8.
  3. ↑ N3981: Trigráfok eltávolítása??! (Richard Smith) (2014. május 6.). Letöltve: 2016. március 28. Az eredetiből archiválva : 2018. július 9..
  4. ↑ IBM megjegyzés a Trigraph-ellenes jövőre való felkészülésről a C++17-ben Archiválva : 2018. szeptember 11., a Wayback Machine , IBM N4210 papír, 2014.10.10.
  5. ↑ A kulcsszó regiszter elavult használatának eltávolítása . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2017. szeptember 14.
  6. ↑ Elavult operátor++(bool) eltávolítása . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2017. szeptember 11..
  7. ↑ Elavult kivételspecifikációk eltávolítása a C++17-ből . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2017. szeptember 13.
  8. ↑ N4190: Auto_ptr, random_shuffle() és régi <funkcionális> dolgok eltávolítása (Stephan T. Lavavej) . Letöltve: 2016. március 28. Az eredetiből archiválva : 2017. október 20.
  9. ↑ 1 2 3 Frissítések az utazási beszámolómhoz . Hozzáférés dátuma: 2016. március 28. Az eredetiből archiválva : 2015. március 19.
  10. ↑ Távolítsa el az elavult iostreams álneveket . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2017. augusztus 22.
  11. ↑ Az allokátor támogatás eltávolítása az std::függvényben (1. rev.) . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2017. szeptember 17.
  12. ↑ Vestigiális könyvtárrészek elavulása a C++17-ben . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2017. szeptember 13.
  13. ↑ Elavult <codecvt> . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2017. szeptember 16..
  14. ↑ Javasolt megoldás a CA 14-hez (shared_ptr use_count/unique) . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2017. július 7.
  15. ↑ GB 55, US 84, US 85, US 86 megoldása . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2017. július 5.
  16. ↑ N4259: Az std::uncaught_exceptions (Herb Sutter) szóhasználata . Letöltve: 2016. március 28. Az eredetiből archiválva : 2014. november 29..
  17. ↑ 1 2 3 4 5 Új alapnyelvi dolgozatok elfogadva a C++17-hez . Letöltve: 2016. március 28. Az eredetiből archiválva : 2015. április 27..
  18. ↑ Forrás . Letöltve: 2022. május 31. Az eredetiből archiválva : 2017. november 16..
  19. ↑ A C++17-nek a C99 helyett C11-re kell hivatkoznia . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2017. szeptember 13.
  20. ↑ N3922: Új szabályok az automatikus levonáshoz a kapcsos kezdőbetűk listájából (James Dennett) . Letöltve: 2016. március 28. Az eredetiből archiválva : 2015. augusztus 10..
  21. ↑ Tegye a kivételspecifikációkat a típusrendszer részévé . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2017. szeptember 12.
  22. ↑ Dinamikus memóriafoglalás a túligazított adatokhoz . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2017. szeptember 8..
  23. ↑ [ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0145r3.pdf Kifejezésértékelési sorrend finomítása Idiomatic C++-hoz] . Letöltve: 2018. augusztus 23. Az eredetiből archiválva : 2018. augusztus 26..
  24. ↑ N4268: Állandó kiértékelés engedélyezése minden nem típusú sablon argumentumhoz (Richard Smith) . Letöltve: 2016. március 28. Az eredetiből archiválva : 2016. március 12.
  25. ↑ A tartomány alapú for hurok általánosítása . Letöltve: 2018. augusztus 23. Az eredetiből archiválva : 2017. október 5..
  26. ↑ 1 2 Új szabványos könyvtári dolgozatok a C++17-hez . Letöltve: 2016. március 28. Az eredetiből archiválva : 2014. november 29..
  27. ↑ N4284: Egybefüggő iterátorok (Jens Maurer) . Letöltve: 2016. március 28. Az eredetiből archiválva : 2014. november 29..
  28. ↑ N4267: U8 karakteres literálok hozzáadása (Richard Smith) . Letöltve: 2016. március 28. Az eredetiből archiválva : 2015. október 28..
  29. ↑ A memory_order_consume ideiglenes elutasítása . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2018. január 16..
  30. ↑ A memory_order_consume célja a C++11-ben . Letöltve: 2019. augusztus 15. Az eredetiből archiválva : 2019. november 11.
  31. ↑ N3928: Static_assert kiterjesztése, v2 (Walter E. Brown) . Letöltve: 2016. március 28. Az eredetiből archiválva : 2015. augusztus 11..
  32. ↑ Így a PVS-Studio szerzői gyakran panaszkodtak hibára: a programozó clear()azt írta empty().
  33. ↑ N4051: Típusnév engedélyezése egy sablonsablon paraméterben (Richard Smith) . Letöltve: 2016. március 28. Az eredetiből archiválva : 2015. augusztus 11..
  34. ↑ Strukturált kötelező érvényű nyilatkozat (C++17 óta) Archiválva : 2020. szeptember 8. a Wayback Machine en.cppreference.com webhelyen
  35. ↑ N4230: Beágyazott névtér meghatározása (Robert Kawulak, Andrew Tomazos) . Letöltve: 2016. március 28. Az eredetiből archiválva : 2015. augusztus 3..
  36. ↑ N4266: Attribútumok névterekhez és felsorolókhoz (Richard Smith) . Hozzáférés dátuma: 2016. március 28. Az eredetiből archiválva : 2016. március 6.
  37. ↑ constexpr if: Kicsit eltérő szintaxis . Letöltve: 2018. augusztus 20. Az eredetiből archiválva : 2017. október 7..
  38. ↑ N4295: Hajtogatási kifejezések (Andrew Sutton, Richard Smith) . Letöltve: 2016. március 28. Az eredetiből archiválva : 2015. április 4..
  39. ↑ Hexadecimális lebegő literálok C++ esetén . Letöltve: 2019. június 12. Az eredetiből archiválva : 2017. augusztus 22.
  40. ↑ Kiválasztási utasítások inicializálóval . Letöltve: 2019. június 12. Az eredetiből archiválva : 2017. október 6..
  41. ↑ Nem típusú sablonparaméterek deklarálása auto -val . Letöltve: 2020. augusztus 7. Az eredetiből archiválva : 2017. szeptember 16.
  42. ↑ *this lambda rögzítése érték szerint [=,*this ] . Letöltve: 2020. augusztus 7. Az eredetiből archiválva : 2017. augusztus 22.
  43. ↑ Az értékek enum osztályának szerkesztési szabályai . Letöltve: 2020. augusztus 7. Az eredetiből archiválva : 2017. december 9.
  44. ↑ A C++17-nek a C99 helyett C11-re kell hivatkoznia . Letöltve: 2016. december 18. Az eredetiből archiválva : 2016. november 13..
  45. ↑ N4280: Nem tag méret() és több (Riccardo Marcangelo) . Hozzáférés dátuma: 2016. március 28. Az eredetiből archiválva : 2015. március 9.
  46. ↑ A bool_constant megfogalmazása, 1. revízió . Letöltve: 2020. január 1. Az eredetiből archiválva : 2017. október 14.
  47. ↑ Archivált másolat . Letöltve: 2020. január 1. Az eredetiből archiválva : 2017. augusztus 28..
  48. ↑ Archivált másolat . Letöltve: 2020. január 1. Az eredetiből archiválva : 2017. október 10.
  49. ↑ Archivált másolat . Letöltve: 2020. január 1. Az eredetiből archiválva : 2017. július 5.
  50. ↑ P0154R1 constexpr std::hardver_{konstruktív,pusztító_interferencia_méret .
  51. ↑ std::shared_mutex - cppreference.com . Letöltve: 2019. augusztus 30. Az eredetiből archiválva : 2019. augusztus 30.
  52. ↑ Továbbfejlesztett beillesztési felület a std::{unordered_,}map számára (átdolgozva) . Letöltve: 2016. március 28. Az eredetiből archiválva : 2015. április 27..
  53. ↑ Archivált másolat . Letöltve: 2019. augusztus 20. Az eredetiből archiválva : 2019. szeptember 17.
  54. ↑ Matematikai speciális függvények C++17-hez, v5 . Letöltve: 2016. március 28. Az eredetiből archiválva : 2016. április 5..
  55. ↑ std::gcd - cppreference.com . Letöltve: 2019. augusztus 30. Az eredetiből archiválva : 2019. március 28.
  56. ↑ std::lcm - cppreference.com . Letöltve: 2019. augusztus 30. Az eredetiből archiválva : 2019. március 28.
  57. ↑ std::clamp - cppreference.com . Letöltve: 2019. augusztus 30. Az eredetiből archiválva : 2019. augusztus 30.
  58. ↑ Fájlrendszer könyvtári javaslat (Beman Dawes) . Letöltve: 2016. március 28. Az eredetiből archiválva : 2016. július 20.
  59. ↑ C++ Extensions for Library Fundamentals, 2. verzió, munkavázlat . Letöltve: 2019. augusztus 30. Az eredetiből archiválva : 2019. augusztus 25.
  60. ↑ std::any - cppreference.com . Letöltve: 2019. augusztus 30. Az eredetiből archiválva : 2019. augusztus 30.
  61. ↑ std::from_chars - cppreference.com . Letöltve: 2019. augusztus 30. Az eredetiből archiválva : 2019. augusztus 30.
  62. ↑ std::to_chars - cppreference.com . Letöltve: 2019. augusztus 30. Az eredetiből archiválva : 2019. augusztus 30.
  63. ↑ Javaslat meghívó függvény sablon hozzáadására (1. változat) . Letöltve: 2020. január 1. Az eredetiből archiválva : 2017. október 6..
  64. ↑ A párhuzamosság kiterjesztései - cppreference.com . Letöltve: 2021. február 5. Az eredetiből archiválva : 2020. november 12.
  65. ↑ A párhuzamossági TS-t szabványosítani kell . Letöltve: 2016. március 28. Az eredetiből archiválva : 2016. április 5..
  66. ↑ C++17 párhuzamos algoritmusok használata a jobb teljesítmény érdekében | C++ Team Blog . Letöltve: 2021. február 5. Az eredetiből archiválva : 2021. január 24.
 C programozási nyelv
Fordítók
Könyvtárak
Sajátosságok
Néhány leszármazott
C és más nyelvek
Kategória:C programozási nyelv
 C++
Sajátosságok
Néhány
könyvtár
Fordítók
befolyásolta
  • C++ kategória