Standardul C++20 a fost aprobat

Comitetul ISO pentru standardizarea limbajului C++ a aprobat standardul internațional „C++20„. Funcționalitățile prezentate în specificație, cu excepția cazurilor izolate, sunt suportate în compilatoare GCC, Clang și Microsoft Visual C++. Bibliotecile standard care susțin C++20 sunt implementate în cadrul proiectului Boost.

În următoarele două luni, specificația aprobată va fi în faza de pregătire a documentului pentru publicare, în care va fi efectuată o revizie editorială pentru corectarea greșelilor de tipărire și a erorilor ortografice. La începutul lunii noiembrie, versiunea finală a documentului va fi trimisă la ISO pentru publicare sub numele formal ISO/IEC 14882:2020. Între timp, comitetul a început deja lucrul la următorul standard C++23 (C++2b) și în cadrul următoarei întâlniri virtuale va analiza posibilele noutăți.

Principalele grafica realizată prin WebGL și C++20 (exemple de cod):

• Au fost adăugate „conceptele”, extensii ale șabloanelor care permit definirea unui set de cerințe pentru parametrii șablonului, care în timpul compilării restricționează setul de argumente ce pot fi acceptate ca parametrii șablonului. Conceptul poate fi aplicat pentru a evita neconcordanțele logice între proprietățile tipurilor de date utilizate în interiorul șablonului și proprietățile tipurilor de date ale parametrilor de intrare.

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

• În compunerea acceptată extensii pentru lucrul cu module, care pot fi utilizate în locul fișierelor header. Modulele oferă o nouă modalitate de organizare a codului sursă pe baza definirii limitelor componentelor, fără fișiere header incluse prin „#include”.
• Macroul __VA_OPT__ pentru desfășurarea adaptivă a macrourilor variative în funcție de prezența token-urilor în argumentul variativ.
• Support for the operator „” for three-way comparison.
• Support for default element initializers for bit-fields.
• Ability to lambda-capture the expression „*this”.

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

  // GOOD:
  return [=, *this]() { return n; };
  }
  };

• Accessing elements by pointer-to-member, using pointers to temporary objects defined through the expression „const &”.
• The delete operator with a destructor described in document P0722R1.
• Classes are permitted to use type-parameterized templates without a type.

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

  template
  auto get_foo() {
  return f;
  }

  get_foo(); // uses implicit constructor
  get_foo();

• Expresiile lambda neconservate cu constructor.
• Acceptabilitatea utilizării sintaxei șabloanelor pentru expresiile lambda ("auto f = [](std::vector v)").
• Posibilitatea utilizării literelor de șir în parametrii șablonului.
• Suport pentru sintaxa de inițializare în stil C — câmpurile nereferite în lista de inițializare sunt inițializate cu valoarea implicită.

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

  A a {.x = 1, .z = 2}; // a.x == 1, a.y == 0, a.z == 2

• Suport pentru membri goi în structuri de date.
• Suport pentru atributele likely și unlikely pentru a informa optimizatorul despre probabilitatea activării unei condiții ("[[likely]] if (random > 0) {").
• Posibilitatea utilizării intervalelor pentru inițializarea valorilor variabilelor în bucla „for”

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

• Calculul automată a dimensiunii unei matrice în new ("new double[]{1,2,3}");
• Atributul "[[no_unique_address]]" pentru variabilele fără date care nu ocupă spațiu.
• Punctatori atomici (std::atomic<shared_ptr> și std::atomic<weak_ptr>).
• Posibilitatea apelării funcțiilor virtuale în expresii condiționale.
• Suport pentru funcții rapide (immediate), care pot funcționa doar cu constante.

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

  constexpr int r = sqr(100); // OK
  int x = 100;
  int r2 = sqr(x); // EROARE: 'x' nu poate fi utilizat ca o constantă

• Posibilitatea aplicării constexpr cu funcții virtuale ("constexpr virtual int f() const { return 2; }").
• În biblioteca standard:
  • Suportul pentru tipul char8_t pentru șiruri UTF-8 a fost adăugat.
  • Fișierele de antet bit (operații pe biți) și version au fost adăugate.
  • A apărut posibilitatea de a verifica prefixul și sufixul șirurilor (starts_with, ends_with).
  • Au fost adăugați tipurile std::remove_cvref, std::unwrap_reference, std::unwrap_decay_ref, std::is_nothrow_convertible și std::type_identity.
  • Au fost adăugate funcțiile std::midpoint, std::lerp, std::bind_front, std::source_location, std::visit, std::is_constant_evaluated și std::assume_aligned.
  • În std::make_shared a fost adăugat suport pentru matrice.
  • Funcția std::to_array a fost adăugată pentru a transforma obiecte asemănătoare cu matrice în std::array.
• Sintaxă mai convenabilă pentru enumerații:

  enum class rgba_color_channel { red, green, blue, alpha };

  std::string_view to_string(rgba_color_channel my_channel) {
  switch (my_channel) {
  using enum rgba_color_channel;
  case red: return "red";
  case green: return "green";
  case blue: return "blue";
  case alpha: return "alpha";
  }
  }

• În indici, utilizarea operației „,” („a[b,c]”) este interzisă din cauza unui comportament nedefinit. Suportul pentru majoritatea operațiunilor cu variabile declarate cu cuvântul cheie volatile a fost suspendat, inclusiv operațiile „++” și „—” cu tipurile standard.
• Numărul situațiilor în care este necesar să specificați „typename” pentru a informa despre existența unui tip a fost redus.

Sursa: opennet.ro