C++20 standaard goedgekeurd

ISO-commissie voor standaardisatie van de C++-taal goedgekeurd internationale standaard "C ++ 20". De mogelijkheden die in de specificatie worden gepresenteerd, met uitzondering van geïsoleerde gevallen, ondersteund bij compilers GCC, kletteren и Microsoft Visual C ++. Standaardbibliotheken die C++20 ondersteunen, worden binnen het project geïmplementeerd boost.

De komende twee maanden bevindt de goedgekeurde specificatie zich in de fase van het gereedmaken van het document voor publicatie, waarbij zal worden gewerkt aan redactionele correctie van spelfouten en typefouten. Begin november zal het resulterende document ter publicatie naar ISO worden gestuurd onder de formele naam ISO/IEC 14882:2020. In de tussentijd is de commissie al begonnen met het werken aan de volgende C++23-standaard (C++2b) en zal ze tijdens haar volgende virtuele vergadering mogelijke opties overwegen. innovaties.

De belangrijkste kenmerken C ++ 20 (codevoorbeelden):

• Er zijn "concepten" toegevoegd, sjabloonextensies, waarmee u een set sjabloonparametervereisten kunt definiëren die, tijdens het compileren, de set argumenten beperken die als sjabloonparameters kunnen worden geaccepteerd. De concepten kunnen worden gebruikt om logische inconsistenties te voorkomen tussen de eigenschappen van de gegevenstypen die in de sjabloon worden gebruikt en de gegevenstype-eigenschappen van de invoerparameters.

  sjabloon
  concept GelijkheidVergelijkbaar = vereist(T a, T b) {
  { a == b } -> std::boolean;
  { a != b } -> std::boolean;
  };

• Geaccepteerd uitbreiding voor het werken met modules die kunnen worden gebruikt in plaats van headerbestanden. Modules bieden een nieuwe manier om broncode te organiseren op basis van het definiëren van de grenzen van componenten, zonder headerbestanden op te nemen via “#include”.
• Macro __VA_OPT__ voor adaptieve uitbreiding van variabele macro's, afhankelijk van de aanwezigheid van tokens in het variabele-argument.
• Ondersteuning voor de operator "" voor driewegvergelijking.
• Ondersteuning voor standaardelementinitialisatoren voor bitvelden.
• Mogelijkheid om "*this"-expressies vast te leggen.

  struct int_waarde {
  intn = 0;
  automatische getter_fn() {
  //SLECHT:
  // retourneer [=]() { retourneer n; };

  // GOED:
  return [=, *dit]() { return n; };
  }
  };

• Elementen aanroepen met behulp van een aanwijzer (Pointer-to-member), met behulp van verwijzingen naar tijdelijke objecten die zijn gedefinieerd via de uitdrukking “const &”.
• De verwijderoperator met een destructor die in het document wordt beschreven P0722R1.
• Klassen mogen sjabloonparameters gebruiken zonder type.

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

  sjabloon
  automatisch get_foo() {
  retour f;
  }

  get_foo(); // gebruikt een impliciete constructor
  krijg_foo ();

• Niet-persistente lambda-expressies met constructor.
• Sjabloonsyntaxis toestaan ​​voor lambda-expressies ("auto f = [] (std::vector v)").
• Mogelijkheid om letterlijke tekenreeksen te gebruiken in sjabloonparameters.
• Ondersteuning voor initialisatiesyntaxis in C-stijl - velden die niet expliciet in de initialisatielijst staan, worden standaard geïnitialiseerd.

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

  EEN een {.x = 1, .z = 2}; // bijl == 1, ay == 0, az == 2

• Ondersteuning voor lege gegevensstructuurleden.
• Ondersteuning voor de waarschijnlijke en onwaarschijnlijke attributen om de optimalisatie te informeren over de waarschijnlijkheid dat de voorwaardelijke constructie wordt geactiveerd (“[[waarschijnlijk]] if (willekeurig > 0) {“).
• Mogelijkheid om bereiken te gebruiken om variabele waarden te initialiseren in een “for” lus

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

• Automatische berekening van de arraygrootte in new (“new double[]{1,2,3}”);
• Het attribuut ‘[[no_unique_address]]’ waarin variabelen zonder gegevens geen ruimte innemen.
• Atoomwijzers (std::atomic > en std::atomair >).
• Mogelijkheid om virtuele functies aan te roepen in voorwaardelijke expressies.
• Ondersteuning voor directe functies die alleen met constanten kunnen werken.

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

  constexpr int r = sqr(100); // OK
  intx = 100;
  int r2 = sqr(x); // FOUT: 'x' kan niet als constante worden gebruikt

• Mogelijkheid om constexpr te gebruiken met virtuele functies (“constexpr virtual int f() const { return 2; }”).
• In de standaardbibliotheek:
  • Ondersteuning toegevoegd voor het type char8_t voor UTF-8-tekenreeksen.
  • Toegevoegd headerbestanden bit (bitbewerkingen) en versie.
  • Het is nu mogelijk om het voor- en achtervoegsel van tekenreeksen te controleren (begint_met, eindigt_met).
  • Std::remove_cvref, std::unwrap_reference, std::unwrap_decay_ref, std::is_nothrow_convertible en std::type_identity eigenschappen toegevoegd.
  • Functies toegevoegd std::midpoint, std::lerp, std::bind_front, std::source_location, std::visit, std::is_constant_evaluated en std::assume_aligned.
  • Ondersteuning toegevoegd voor arrays naar std::make_shared.
  • Functie std::to_array toegevoegd om array-achtige objecten naar std::array te converteren.
• Handigere opsommingsyntaxis:

  enum class rgba_color_channel {rood, groen, blauw, alpha};

  std::string_view to_string(rgba_color_channel mijn_kanaal) {
  schakelaar (mijn_kanaal) {
  met behulp van enum rgba_color_channel;
  geval rood: retour "rood";
  geval groen: retour "groen";
  geval blauw: retourneer "blauw";
  hoofdletter alfa: retourneer "alfa";
  }
  }

• In indexen is het gebruik van de bewerking “,” (“a[b,c]”) vanwege ongedefinieerd gedrag verboden. Ondersteuning voor de meeste bewerkingen met variabelen die zijn gedeclareerd met het vluchtige trefwoord is stopgezet, inclusief de bewerkingen “++” en “—” met standaardtypen.
• Het aantal situaties verminderd waarin "typenaam" vereist is om de aanwezigheid van een type aan te geven.

Bron: opennet.ru