Der Standard C++20 wurde genehmigt

Der ISO-Ausschuss für die Standardisierung der Programmiersprache C++ genehmigte den internationalen Standard „C++20“. Die in der Spezifikation beschriebenen Möglichkeiten werden, mit Ausnahme einzelner Fälle, von den Compilern GCC Clang, Microsoft Visual C++ und . Die C++20 unterstützenden Standardbibliotheken sind im Rahmen des ProjektsBoost In den nächsten zwei Monaten wird die genehmigte Spezifikation in der Phase der Dokumentenvorbereitung zur Veröffentlichung sein, in der an der redaktionellen Bearbeitung von Rechtschreibfehlern und Druckfehlern gearbeitet wird. Anfang November wird die resultierende Version des Dokuments zur Veröffentlichung an die ISO unter dem formalen Namen ISO/IEC 14882:2020 gesendet. In der Zwischenzeit hat der Ausschuss bereits mit der Arbeit am nächsten Standard C++23 (C++2b) begonnen und wird beim nächsten virtuellen Treffen mögliche.

Merkmale Neuheiten.

Haupt- Beispielcodes C++20 („Konzepte“ hinzugefügt, die Vorlagen erweitern und es ermöglichen, eine Reihe von Anforderungen an die Vorlagenparameter zu definieren, die beim Kompilieren die Menge der Argumente einschränken, die als Vorlagenparameter akzeptiert werden können. Konzepte können verwendet werden, um logische Inkonsistenzen zwischen den Eigenschaften der Datentypen, die innerhalb der Vorlage verwendet werden, und den Eigenschaften der Datentypen der Eingabeparameter zu vermeiden.):

• template

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

• Erweiterungen für die Arbeit mit Modulen, die anstelle von Header-Dateien verwendet werden können. Module bieten einen neuen Weg zur Organisation von Quelltexten, basierend auf der Definition von Komponentenbereichen, ohne über „#include“ eingebundene Header-Dateien. Das Makro __VA_OPT__ für die adaptive Entfaltung variabler Makros in Abhängigkeit von der Verfügbarkeit von Tokens im variablen Argument.
• Unterstützung des Operators „“ für den dreifachen Vergleich.
• Unterstützung von Standardwertinitialisierern für Bitfelder.
• Möglichkeit des Lambda-Zugriffs auf Ausdrücke „*this“.
• struct int_value {

  int n = 0;
  auto getter_fn() {
  return [=, *this]() { return n; };
  // BAD:
  // return [=]() { return n; };

  // GOOD:
  Aufruf von Elementen über einen Zeiger (Pointer-to-member), unter Verwendung von über den Ausdruck „const &“ definierten Zeigern auf temporäre Objekte.
  }
  };

• Der Operator delete mit einem im Dokument beschriebenen Destruktor
• P0722R1 Klassen ist die Verwendung von Vorlagenparametern ohne Typ erlaubt..
• struct foo {

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

  template
  auto get_foo() {
  return f;
  }

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

• Nicht speicherbare Lambda-Ausdrücke mit Konstruktor.
• Zulässigkeit der Verwendung von Vorlagen-Syntax für Lambda-Ausdrücke ("auto f = [](std::vector v)").
• Möglichkeit der Verwendung von String-Literalen in Vorlagen-Parametern.
• Unterstützung der C-Stil Initialisierungssyntax – nicht explizit aufgelistete Felder in der Initialisierungsliste 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 in Datenstrukturen.
• Unterstützung der Attribute likely und unlikely zur Informierung des Optimierers über die Wahrscheinlichkeit des Eintretens einer Bedingung ("[[likely]] if (random > 0) {").
• Möglichkeit, Bereiche zur Initialisierung von Variablenwerten in der "for"-Schleife zu verwenden

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

• Automatische Berechnung der Array-Größe bei new ("new double[]{1,2,3}");
• Attribut "[[no_unique_address]]", wobei variablen ohne Daten keinen Platz beanspruchen.
• Atomare Zeiger (std::atomic<shared_ptr> und std::atomic<weak_ptr>).
• Möglichkeit, virtuelle Funktionen in bedingten Ausdrü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 wurde 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 Typideen std::remove_cvref, std::unwrap_reference, std::unwrap_decay_ref, std::is_nothrow_convertible und std::type_identity wurden hinzugefügt.
  • Funktionen wie std::midpoint, std::lerp, std::bind_front, std::source_location, std::visit, std::is_constant_evaluated und std::assume_aligned wurden hinzugefügt.
  • std::make_shared unterstützt jetzt Arrays.
  • Die Funktion std::to_array wurde hinzugefügt, um array-ähnliche Objekte in std::array zu konvertieren.
• 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 unbestimmten Verhaltens verboten. Die Unterstützung für die 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 „typename“ zur Information über die Existenz eines Typs angegeben werden muss, wurde reduziert.

Quelle: opennet.ru