Der Standard C++20 wurde genehmigt

Das ISO-Komitee für die Standardisierung der Sprache C++ genehmigte internationalen Standard „C++20“. Die in den Spezifikationen dargestellten Funktionen, mit Ausnahme einzelner Fälle, unterstützt: in Compilern GCC, Clang und Microsoft Visual C++. Die unterstützenden C++20-Standardbibliotheken sind im Rahmen des Projekts implementiert. eingeschränkt verwenden..

In den kommenden zwei Monaten wird die genehmigte Spezifikation in die Dokumentenvorbereitung zur Veröffentlichung übergehen, wobei eine redaktionelle Überprüfung auf Rechtschreibfehler und Druckfehler stattfinden wird. Anfang November wird die endgültige Dokumentenversion an die ISO zur Veröffentlichung unter dem formalen Namen ISO/IEC 14882:2020 gesendet. In der Zwischenzeit hat das Komitee bereits mit der Arbeit am nächsten Standard C++23 (C++2b) begonnen und wird in der nächsten virtuellen Sitzung mögliche Neuheiten.

Haupt Eigenschaften C++20 (Beispiele für Code betrachten.):

• Es wurden „Konzepte“ hinzugefügt, eine Erweiterung von Vorlagen, die es erlaubt, eine Menge von Anforderungen an die Parameter einer Vorlage zu definieren, die während der Kompilierung den Satz von Argumenten einschränken, die als Parameter akzeptiert werden können. Konzepte können verwendet werden, um logische Inkonsistenzen zwischen den Eigenschaften von Datentypen, die innerhalb der Vorlage verwendet werden, und den Eigenschaften von Datentypen der Eingabeparameter zu vermeiden.

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

• Es wurden angenommen Erweiterung zum Arbeiten mit Modulen, die anstelle von Header-Dateien verwendet werden können. Module bieten einen neuen Weg, Quelltexte basierend auf der Definition von Komponenten-Grenzen zu organisieren, ohne durch „#include“ eingebundene Header-Dateien.
• Makro __VA_OPT__ für die adaptive Entfaltung von variadic Makros basierend auf dem Vorhandensein von Tokens im variadischen Argument.
• Unterstützung des Operators „“ für dreiseitigen Vergleich.
• Unterstützung von Standard-Element-Initialisierern für Bitfelder.
• Möglichkeit des Lambda-Capturings von Ausdrücken „*this“.

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

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

• Aufruf von Elementen über Zeiger (Pointer-to-member) unter Verwendung von durch den Ausdruck „const &" definierten Zeigern auf temporäre Objekte.
• Der delete-Operator mit dem im Dokument beschriebenen Destruktor. P0722R1.
• Klassen dürfen Parameter ohne Typ in Vorlagen verwenden.

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

  template
  auto get_foo() {
  return f;
  }

  get_foo(); // verwendet impliziten Konstruktor
  get_foo();

• Nicht speicherhaltende Lambda-Ausdrücke mit Konstruktor.
• Erlaubtheit der Verwendung von Vorlagensyntax für Lambda-Ausdrücke („auto f = [](std::vector v)“).
• Möglichkeit der Verwendung von Zeichenliteralen in Vorlagenparametern.
• Unterstützung der C-Stil Initialisierungssyntax – nicht ausdrücklich im Initialisierungslisten aufgeführte Felder werden standardmäßig initialisiert.

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

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

• Unterstützung leerer Mitglieder von Datenstrukturen.
• Unterstützung der Attribute likely und unlikely zur Information des Optimierers über die Wahrscheinlichkeit des Eintretens einer Bedingung („[[likely]] if (random > 0) {“).
• Möglichkeit der Verwendung von Bereichen zur Initialisierung von Variablenwerten in der Schleife „for“

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

• Automatische Berechnung der Array-Größe in new ("new double[]{1,2,3}");
• Das Attribut "[[no_unique_address]]", bei dem Datenlose Variablen keinen Speicherplatz belegen.
• Atomare Zeiger (std::atomic<shared_ptr> und std::atomic<weak_ptr>).
• Möglichkeit, virtuelle Funktionen in Bedingungsausdrücken aufzurufen.
• Unterstützung für sofortige Funktionen, die nur mit Konstanten arbeiten können.

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

  constexpr int r = sqr(100); // OK
  int x = 100;
  int r2 = sqr(x); // FEHLER: ‚x‘ kann nicht als Konstante verwendet werden.

• Möglichkeit, constexpr mit virtuellen Funktionen zu verwenden ("constexpr virtual int f() const { return 2; }").
• In der Standardbibliothek:
  • Unterstützung für den Typ char8_t für UTF-8-Strings hinzugefügt.
  • Die Header-Dateien bit (bitweise Operationen) und version wurden hinzugefügt.
  • Möglichkeit zur Überprüfung von Präfixen und Suffixen von Strings (starts_with, ends_with).
  • Die Typen std::remove_cvref, std::unwrap_reference, std::unwrap_decay_ref, std::is_nothrow_convertible und std::type_identity wurden hinzugefügt.
  • Die Funktionen std::midpoint, std::lerp, std::bind_front, std::source_location, std::visit, std::is_constant_evaluated und std::assume_aligned wurden hinzugefügt.
  • In std::make_shared wurde die Unterstützung für Arrays hinzugefügt.
  • Die Funktion std::to_array zum Konvertieren von array-ähnlichen Objekten in std::array hinzugefügt.
• Ein benutzerfreundlicherer Syntax für Aufzählungen:

  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»;
  }
  }

• In den Indizes ist die Verwendung der Operation «,» («a[b,c]») aufgrund undefinierten Verhaltens verboten. Die Unterstützung der meisten Operationen mit Variablen, die mit dem Schlüsselwort volatile deklariert sind, wurde eingestellt, einschließlich der Operationen «++» und «—» mit Standardtypen.
• Die Anzahl der Situationen, in denen die Angabe von «typename» erforderlich ist, um auf das Vorhandensein eines Typs hinzuweisen, wurde verringert.

Quelle: opennet.ru