Menü

Programmiersprache: Der Entwurf von C++20 ist abgeschlossen

Die spannendsten, auf dem jüngsten Meeting beschlossenen Neuerungen des kommenden C++-Standards sind Koroutinen und Module.

Lesezeit: 1 Min.
In Pocket speichern
vorlesen Druckansicht Kommentare lesen 309 Beiträge
Von

Vor einer knappen Woche haben die Teilnehmer des ISO C++ Meeting in Kona (Hawaii) den Sprachumfang von C++20 festgelegt. Im nächsten Meeting in Köln stehen noch die Abschlussarbeiten an, bevor es dann in die Abstimmungsphase geht. Um es mit den Worten von Bryce Adelstein Lelbach kurz und bündig auszudrücken: "C++20 mag ein genauso großes Release werden wie C++11". Damit steht C++20 in der Tradition der großen C++-Standards C++98 und C++11.

Die wohl wichtigsten Features, die in Kona zum aktuellen C++20 Entwurf hinzu kamen, waren Module und Koroutinen. Mehrere Implementierungen und Proposals waren vor der Verabschiedung notwendig. Module stellen eine Alternative zu Header-Dateien dar und versprechen viele Verbesserung:

  • Die Trennung von Header- und Sourcedateien aufzulösen,
  • Präprozessor-Anweisungen zu eliminieren,
  • Abhängigkeiten von include-Anweisungen zu beseitigen,
  • bessere Kompilierungszeiten zu erzielen und
  • einfacher Pakete zu schnüren.

Aus der Anwenderperspektive unterscheiden sich Module nicht stark von include-Anweisungen. Eine einfache import-Deklaration genügt:

import std; // import declaration
int main() {
std::cout << "Hello World" << std::endl; }

Mit Koroutinen unterstützt C++20 die asynchrone Programmierung. Es handelt sich um erweiterte Funktionen, die ihre Ausführung anhalten und wieder aufnehmen können. Damit werden sich in C++20 kooperatives Multitasking, unendliche Datenströme, Event-Schleifen oder auch Pipelines elegant umsetzen lassen. Das folgende Beispiel stellt einen einfachen Server vor, der blockiert, bis er seine Clientanfragen bedient hat.

Acceptor accept{443};
while (true){
Socket so = accept.accept(); // block
auto req = so.read(); // block
auto resp = handleRequest(req);
so.write(resp); // block
}

Dank Koroutinen wird aus dem ressourcenhungrigen Blockieren ein ressourcenschonendes Warten.

Acceptor accept{443};
while (true){
Socket so = co_await accept.accept();
auto req = co_await so.read();
auto resp = handleRequest(req);
co_await so.write(resp);
}

Ein Aufruf wie auto req = so.read(); wartet nicht, bis die Daten vom Client verfügbar sind, sondern kommt sofort zurück und setzt seine Arbeit erst dann fort, wenn die Daten tatsächlich vorliegen. Dank Koroutinen lässt sich damit selbst ein Single-Threaded Server schreiben, der sehr gut skaliert.

Die Übersicht zeigt die wichtigsten Neuerungen der jeweiligen C++-Standards.

Neben den beiden in Kona beschlossenen Neuzugängen gehören zu den Highlights von C++20 aus Sicht des Autors:

  • Concepts,
  • Contracts,
  • Ranges,
  • Vergleichsoperator <=> und
  • viele constexpr-Features.

Eine schöne Zusammenstellung aller C++20 Feature bietet der reddit-Artikel von Bryce Adelstein Lelbach. Wer es ein wenig wortreicher bevorzugt, kann den Trip-Report von Herb Sutter lesen. (Rainer Grimm) / (rme)