Inaprubahan ang pamantayang C++20

ISO Committee on Standardization ng C++ Language naaprubahan Pamantayang internasyonal "C ++ 20". Ang mga kakayahan na ipinakita sa detalye, maliban sa mga nakahiwalay na kaso, suportado sa mga compiler GCC, Clang ΠΈ Microsoft Visual C ++. Ang mga karaniwang aklatan na sumusuporta sa C++20 ay ipinatupad sa loob ng proyekto Magbunsod.

Sa susunod na dalawang buwan, ang naaprubahang detalye ay nasa yugto ng paghahanda ng dokumento para sa publikasyon, kung saan isasagawa ang gawain sa pagwawasto ng editoryal ng mga pagkakamali sa spelling at typo. Sa unang bahagi ng Nobyembre, ang magreresultang dokumento ay ipapadala sa ISO para sa publikasyon sa ilalim ng pormal na pangalang ISO/IEC 14882:2020. Pansamantala, sinimulan na ng komite ang trabaho sa susunod na pamantayan ng C++23 (C++2b) at isasaalang-alang ang mga posibleng opsyon sa susunod nitong virtual na pagpupulong. mga inobasyon.

Ang pangunahing mga tampok C ++ 20 (mga halimbawa ng code):

  • Nagdagdag ng "mga konsepto", mga extension ng template, na nagbibigay-daan sa iyong tukuyin ang isang hanay ng mga kinakailangan ng parameter ng template na, sa oras ng pag-compile, nililimitahan ang hanay ng mga argumento na maaaring tanggapin bilang mga parameter ng template. Maaaring gamitin ang mga konsepto upang maiwasan ang mga lohikal na hindi pagkakapare-pareho sa pagitan ng mga katangian ng mga uri ng data na ginamit sa loob ng template at mga katangian ng uri ng data ng mga parameter ng input.

    template
    konsepto EqualityComparable = nangangailangan(T a, T b) {
    { a == b } -> std::boolean;
    { a != b } -> std::boolean;
    };

  • Tinanggap pagpapalawak para sa pagtatrabaho sa mga module na maaaring gamitin sa halip na mga file ng header. Nagbibigay ang mga module ng bagong paraan upang ayusin ang source code batay sa pagtukoy sa mga hangganan ng mga bahagi, nang hindi isinasama ang mga file ng header sa pamamagitan ng "#include".
  • Macro __VA_OPT__ para sa adaptive na pagpapalawak ng mga variable na macro depende sa pagkakaroon ng mga token sa variable na argumento.
  • Suporta para sa "" operator para sa tatlong-daan na paghahambing.
  • Suporta para sa mga default na element initializer para sa mga bitfield.
  • Kakayahang i-lambda ang pagkuha ng "*ito" na mga expression.

    struct int_value {
    int n = 0;
    auto getter_fn() {
    //MAMA:
    // return [=]() { return n; };

    // MABUTI:
    ibalik [=, *ito]() { ibalik n; };
    }
    };

  • Pagtawag ng mga elemento sa pamamagitan ng pointer (Pointer-to-member), gamit ang mga pointer sa mga pansamantalang bagay na tinukoy sa pamamagitan ng expression na "const &".
  • Ang delete operator na may destructor na inilarawan sa dokumento P0722R1.
  • Pinapayagan ang mga klase na gumamit ng mga parameter ng template na walang uri.

    struct foo {
    foo() = default;
    constexpr foo(int) {}
    };

    template
    auto get_foo() {
    bumalik f;
    }

    get_foo(); // gumagamit ng implicit constructor
    get_foo ();

  • Mga di-persistent na expression ng lambda na may constructor.
  • Pagpapahintulot sa syntax ng template para sa mga expression ng lambda (β€œauto f = [] (std::vector v)").
  • Kakayahang gumamit ng mga literal na string sa mga parameter ng template.
  • Suporta para sa C-style initialization syntax - ang mga field na hindi tahasang nakalista sa listahan ng initialization ay sinisimulan bilang default.

    struct A {
    intx;
    int y;
    int z = 123;
    };

    A a {.x = 1, .z = 2}; // ax == 1, ay == 0, az == 2

  • Suporta para sa mga walang laman na miyembro ng istruktura ng data.
  • Suporta para sa malamang at hindi malamang na mga katangian upang ipaalam sa optimizer ang tungkol sa posibilidad na ma-trigger ang conditional construct (β€œ[[malamang]] kung (random > 0) {β€œ).
  • Kakayahang gumamit ng mga hanay upang simulan ang mga variable na halaga sa isang "para" na loop

    para sa (auto v = std::vector{1, 2, 3}; auto& e : v) {

  • Awtomatikong pagkalkula ng laki ng array sa bago ("bagong double[]{1,2,3}");
  • Ang attribute na β€œ[[no_unique_address]]” kung saan ang mga variable na walang data ay hindi kumukuha ng espasyo.
  • Atomic pointer (std::atomic > at std::atomic >).
  • Kakayahang tumawag ng mga virtual na function sa mga conditional expression.
  • Suporta para sa mga agarang function na maaari lamang gumana sa mga constant.

    consteval int sqr(int n) {
    bumalik n * n;
    }

    constexpr int r = sqr(100); // OK
    int x = 100;
    int r2 = sqr(x); // ERROR: 'x' ay hindi maaaring gamitin bilang isang pare-pareho

  • Posibilidad ng paggamit ng constexpr na may mga virtual na function (β€œconstexpr virtual int f() const { return 2; }”).
  • Sa karaniwang aklatan:
    • Nagdagdag ng suporta para sa uri ng char8_t para sa mga string ng UTF-8.
    • Nagdagdag ng mga file ng header bit (mga pagpapatakbo ng bit) at bersyon.
    • Posible na ngayong suriin ang prefix at suffix ng mga string (starts_with, ends_with).
    • Nagdagdag ng std::remove_cvref, std::unwrap_reference, std::unwrap_decay_ref, std::is_nothrow_convertible at std::type_identity traits.
    • Nagdagdag ng mga function std::midpoint, std::lerp, std::bind_front, std::source_location, std::visit, std::is_constant_evaluated at std::assume_aligned.
    • Nagdagdag ng suporta para sa mga array sa std::make_shared.
    • Idinagdag ang std::to_array function upang i-convert ang mga bagay na tulad ng array sa std::array.
  • Mas maginhawang enumeration syntax:

    enum class rgba_color_channel { pula, berde, asul, alpha };

    std::string_view to_string(rgba_color_channel my_channel) {
    lumipat (my_channel) {
    gamit ang enum rgba_color_channel;
    kaso pula: ibalik ang "pula";
    kaso berde: ibalik ang "berde";
    kaso asul: ibalik ang "asul";
    case alpha: ibalik ang "alpha";
    }
    }

  • Sa mga index, dahil sa hindi natukoy na pag-uugali, ipinagbabawal ang paggamit ng operasyong "," (β€œa[b,c]”). Ang suporta para sa karamihan ng mga operasyon na may mga variable na idineklara gamit ang pabagu-bagong keyword ay hindi na ipinagpatuloy, kasama ang "++" at "β€”" na mga operasyon na may mga karaniwang uri.
  • Binawasan ang bilang ng mga sitwasyon kung saan ang "typename" ay kinakailangan upang ipahiwatig ang pagkakaroon ng isang uri.

Pinagmulan: opennet.ru

Magdagdag ng komento