C++20 ist verabschiedet

Keine Zeit? Hier die Kurzversion in 30 Sekunden.
- C++20 wurde im Februar 2020 technisch fertiggestellt, am 4. September einstimmig in der ISO-Abstimmung angenommen. Die offizielle Veröffentlichung steht noch aus.
- Die vier großen Neuerungen sind Concepts, Ranges, Coroutines und Modules.
- Dazu kommen viele kleinere Dinge wie der Dreiwegevergleich
<=>,std::span,std::formatundstd::jthread.- Compiler und Standardbibliotheken sind noch nicht durch: Concepts gehen schon gut, Modules und
std::formatnoch nicht.- Mein Rat: Concepts und Ranges jetzt ausprobieren, bei Modules und Coroutines abwarten.
Ich habe mir lange überlegt, wie ich diesen Beitrag anfange, und bin am Ende bei einem Rückblick gelandet. Als ich 2017 über „C++17 ist fertig“ geschrieben habe, war mein Eindruck, dass der Standard eher aufgeräumt als aufregend ist. Das war nicht als Kritik gemeint, es war eine Bestandsaufnahme: Vieles wurde bequemer, kaum etwas veränderte die Art, wie man C++ schreibt. Bei C++20 ist das anders. Hier kommen Dinge, die man nicht nur anders aufschreibt, sondern die den Zuschnitt von Programmen verändern können.
Zum Stand der Dinge: Technisch fertig wurde C++20 im Februar 2020 beim Treffen des Komitees in Prag. Seitdem lief das formelle Verfahren, und am 4. September 2020 hat die ISO-Abstimmung den Entwurf einstimmig angenommen. Die eigentliche Veröffentlichung als ISO-Norm steht noch aus, sie wird für das Ende des Jahres erwartet. Dass der Standard in diesem Jahr überhaupt so planmäßig über die Ziellinie kam, ist keine Selbstverständlichkeit. Spätere Treffen mussten aus bekannten Gründen ausfallen oder online stattfinden, und ich ziehe vor der Disziplin der Beteiligten den Hut.
Concepts: Templates mit Beschreibung
Wer Templates schreibt, kennt das Problem. Ein Template akzeptiert jeden Typ, und wenn der nicht passt, bekommt man seitenlange Fehlermeldungen aus dem Inneren irgendeiner Instanziierung. Concepts lösen das, indem sie Anforderungen an Typen benennen und prüfbar machen.
#include <concepts>
template <typename T>
concept Addierbar = requires(T a, T b) {
{ a + b } -> std::convertible_to<T>;
};
template <Addierbar T>
T summe(T a, T b) {
return a + b;
}Der requires-Ausdruck beschreibt, was ein Typ können muss. Wer summe mit einem Typ aufruft, der das nicht kann, bekommt eine Fehlermeldung, die den Namen des Concepts nennt, und nicht eine Wand aus Templatefehlern. Die Standardbibliothek bringt im Header <concepts> schon eine Reihe fertiger Bausteine mit, etwa std::integral oder std::floating_point.
Ich halte Concepts für die wichtigste Verbesserung im Alltag. Nicht, weil sie neue Fähigkeiten freischalten, sondern weil sie aus einer impliziten Konvention („der Typ muss irgendwie wie ein Iterator aussehen“) eine Aussage machen, die im Code steht und vom Compiler geprüft wird.
Ranges: Pipelines statt Iteratorpaaren
Die zweite große Sache sind Ranges. Wer die Algorithmen aus <algorithm> benutzt hat, kennt das ewige begin() und end(). Ranges fassen beides zu einem Objekt zusammen und erlauben es, Operationen mit dem Pipe-Operator zu verketten:
#include <iostream>
#include <ranges>
#include <vector>
int main() {
std::vector<int> zahlen{1, 2, 3, 4, 5, 6};
auto ergebnis = zahlen
| std::views::filter([](int n) { return n % 2 == 0; })
| std::views::transform([](int n) { return n * n; });
for (int n : ergebnis) {
std::cout << n << '\n';
}
}Das gibt 4, 16 und 36 aus. Der Clou: Views sind träge. Es wird nichts kopiert und nichts berechnet, bis man über das Ergebnis läuft. Wer von LINQ in C# oder von Streams in Java kommt, wird sich zuhause fühlen, nur dass hier keine Allokationen für Zwischenergebnisse anfallen müssen. Ob das im konkreten Fall schneller ist, habe ich nicht gemessen, und ich würde jedem raten, es bei kritischem Code selbst zu tun.
Eine Fußangel gibt es: Views verweisen auf die Daten dahinter. Wer eine View zurückgibt, deren Quelle gleich danach zerstört wird, hat ein klassisches Lebensdauerproblem. Die neue Syntax macht das Denken darüber nicht überflüssig.
Coroutines und Modules: die großen Brocken
Bei Coroutines bin ich vorsichtig. Der Standard liefert die Sprachgrundlage mit den Schlüsselwörtern co_await, co_yield und co_return, aber bewusst nicht viel Bibliothek dazu. Man bekommt einen Mechanismus, mit dem sich Generatoren oder asynchrone Aufgaben bauen lassen, muss sich aber die Typen dafür weitgehend selbst schreiben oder aus Bibliotheken holen. Das ist mächtig und für den Einstieg ziemlich sperrig. Ich rechne damit, dass es noch eine Weile dauert, bis daraus etwas wird, das man ohne Handbuch benutzt.
Modules sind das Feature, auf das viele seit Jahren warten. Die Idee: statt #include mit seinem Textkopieren, den Include-Guards und den langen Übersetzungszeiten importiert man ein Modul, das einmal übersetzt wird. Zusätzlich lässt sich festlegen, was ein Modul nach außen zeigt, und Makros lecken nicht mehr hinein. Auf dem Papier ist das ein großer Schritt, auch für den Aufbau von Build-Systemen. In der Praxis ist die Unterstützung bei allen großen Compilern noch unvollständig. Ich würde das heute bestenfalls im Experiment anfassen und mich nicht darauf verlassen.
Der Rest: viele kleine Dinge
Neben den großen Vier gibt es eine Reihe von Änderungen, die im Alltag mindestens so oft vorkommen werden:
- Dreiwegevergleich
<=>: Der „Raumschiff-Operator“ erzeugt aus einer einzigen Definition alle sechs Vergleichsoperatoren. Mitauto operator<=>(const Punkt&) const = default;bekommt man sie sogar kostenlos. - Designated Initializers: Aggregate lassen sich mit Namen initialisieren, etwa
Punkt p{.x = 1, .y = 2};. Die Reihenfolge muss der Deklaration entsprechen. Das kennt man aus C, in C++ ist es jetzt auch erlaubt. constevalundconstinit:constevalerzwingt, dass eine Funktion zur Übersetzungszeit ausgewertet wird.constinitstellt sicher, dass eine Variable konstant initialisiert wird, ohne sie unveränderlich zu machen.std::span: Eine nicht besitzende Sicht auf einen zusammenhängenden Speicherbereich. Es ersetzt viele Paare aus Zeiger und Länge.std::format: Typsichere Textformatierung im Stil von Python, stattprintfoder Stream-Operatoren.- Kalender und Zeitzonen in
<chrono>: Daten, Wochentage und Zeitzonen gehören jetzt zur Standardbibliothek. char8_t: Ein eigener Typ für UTF-8-Zeichen.using enum: Macht die Werte eines Aufzählungstyps in einem Bereich ohne Präfix sichtbar.std::jthread: Ein Thread, der im Destruktor automatisch wartet und sich über einen Stoptoken kooperativ beenden lässt.
Besonders std::jthread finde ich bemerkenswert, weil es eine Sorte Fehler beseitigt, die jeder schon einmal gemacht hat: Ein std::thread, der zerstört wird, ohne dass join aufgerufen wurde, beendet das Programm.
Und die Compiler?
Hier muss man genau hinschauen, denn „C++20 ist verabschiedet“ heißt nicht „C++20 ist verfügbar“. Nach meinem Eindruck bringen GCC 10 und Clang 10 Concepts weitgehend mit, und das reicht, um ernsthaft damit zu arbeiten. Coroutines sind bei manchen Compilern noch hinter einem eigenen Schalter versteckt. Modules sind bei allen noch unvollständig. Und std::format fehlt in den Standardbibliotheken der großen Compiler bisher ganz.
Für den letzten Punkt gibt es einen Ausweg, den ich gern empfehle: die Bibliothek {fmt}. std::format basiert direkt darauf, die Schnittstelle ist sehr ähnlich, und ein späterer Umstieg dürfte überschaubar sein. Zu Microsoft sage ich bewusst nichts Konkretes, weil ich hier keine belastbaren Versionsangaben habe. Wer mit Visual Studio arbeitet, schaut am besten in die Dokumentation seiner Version.
Wie ich es einordne
Seit Jahren gilt C++ als eine Sprache, die immer mehr Merkmale ansammelt und dabei immer schwerer wird. Ich habe dazu ein zwiespältiges Verhältnis. Einerseits stimmt es: Wer C++20 voll beherrschen will, hat viel zu lernen. Andererseits zielen viele Neuerungen in die richtige Richtung, nämlich dahin, dass man weniger Fehler machen kann und Absichten im Code klarer ausdrückt. Concepts, std::span, std::jthread und <=> sind alle von dieser Sorte.
Mein praktischer Plan sieht so aus: Concepts und Ranges probiere ich in einem kleinen Projekt aus, sobald der Compiler mitspielt, std::span und die Designated Initializers werde ich sofort nutzen. Bei Modules und Coroutines will ich zuerst sehen, wie sich die Werkzeuge entwickeln. Ein neuer Standard bringt nur etwas, wenn das Build-System, die IDE und die Bibliotheken mitziehen, und das dauert erfahrungsgemäß länger als die Abstimmung.
Wer schon ernsthaft mit Concepts oder Ranges gearbeitet hat, darf mir gern in den Kommentaren verraten, ob sich die Fehlermeldungen wirklich so gebessert haben, wie versprochen wird.
Beitragsbild: Foto Karlsbrücke in Prag von Tiia Monto, CC BY-SA 4.0 (via Wikimedia Commons; zugeschnitten auf 16:9).
Christian Ackermann
Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.