C++23 ist fertig – was kommt davon in der Praxis an?

Keine Zeit? Hier die Kurzversion in 30 Sekunden.
- Das Komitee hat C++23 im Februar 2023 in Issaquah technisch abgeschlossen; die formale ISO-Veröffentlichung steht noch aus.
- Die größten Neuerungen:
std::expected,std::print/std::println,std::mdspan, „deducing this“ und die Standardbibliothek als Modul (import std;).- Dazu kommen Ranges-Ergänzungen (
views::zip,views::chunk,ranges::to),std::generator,std::flat_mapundstd::stacktrace.- Die Compiler-Unterstützung ist lückenhaft; GCC 13 und Visual Studio 2022 bieten Teile,
import stdam ehesten MSVC.- Wer mit C++Builder arbeitet, bleibt vorerst bei C++17 und teils C++20.
Es gibt Standards, auf die man wartet, und welche, die einfach irgendwann da sind. C++23 gehört für mich zur zweiten Sorte. Anders als C++11 oder C++20 hat es kein einzelnes Schlagwort, das alle im Mund führen. Es ist eher ein großes Paket aus Nachbesserungen, Lückenfüllern und ein paar echten Neuerungen. Genau deshalb finde ich es interessant, mal zu schauen, was davon im Alltag überhaupt ankommt.
Der Stand, soweit ich ihn kenne: Das Komitee hat im Februar 2023 bei seinem Treffen in Issaquah die technische Arbeit abgeschlossen. Die formale Veröffentlichung durch die ISO steht noch aus, das ist ein Verwaltungsvorgang und dauert eben. Inhaltlich ist der Funktionsumfang aber festgelegt.
Ein Standard der kleinen Schritte
Als ich 2017 über C++17 geschrieben habe, ging es um std::optional, std::variant und strukturierte Bindungen, lauter Dinge, die den Code spürbar entschlackten. Bei C++20 drei Jahre später waren es Concepts, Ranges, Coroutines und Module, also ein echter Sprung, der noch lange verdaut werden muss. C++23 knüpft da an und macht vieles davon erst richtig brauchbar. Ranges bekommen Zubehör, Coroutines bekommen einen ersten fertigen Typ, Module bekommen die Standardbibliothek.
Das ist kein Nachteil. Ich habe den Eindruck, dass dieser Standard das ist, was C++20 hätte sein sollen, wenn die Zeit gereicht hätte.
Fehlerbehandlung und Ausgabe
Die für mich praktischste Neuerung ist std::expected. Eine Funktion liefert entweder einen Wert oder einen Fehler zurück, ohne Exceptions und ohne Ausgabeparameter:
#include <expected>
#include <string>
#include <charconv>
std::expected<int, std::string> parse(const std::string& s) {
int wert{};
auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), wert);
if (ec != std::errc{}) {
return std::unexpected("keine Zahl: " + s);
}
return wert;
}Wer Rust kennt, erkennt das Muster sofort. Der Aufrufer prüft mit if (auto r = parse("42")) und greift per *r oder r.value() auf den Wert zu, bei einem Fehler liefert r.error() die Meldung. Dazu gibt es monadische Operationen wie and_then und transform, die sich auch bei std::optional finden. Ob das den Exceptions das Wasser abgräbt, bezweifle ich, aber für erwartbare Fehler, etwa fehlerhafte Eingaben, ist es ein deutlich ehrlicheres Werkzeug.
Die zweite Sache ist banal und trotzdem überfällig: std::print und std::println.
#include <print>
int main() {
std::println("Hallo {}, du bist Nummer {}", "Welt", 23);
}Das nutzt die Formatierung aus C++20 (std::format) und ersetzt in vielen Fällen std::cout mit den ewigen <<-Ketten. Ich mochte Streams nie besonders, und mir geht es vermutlich nicht allein so.
Sprachkleinigkeiten, die Spaß machen
Einige Änderungen betreffen die Sprache selbst. „Deducing this“ erlaubt es, den impliziten Objektparameter einer Memberfunktion explizit hinzuschreiben. Klingt abstrakt, hilft aber, den klassischen Doppelpack aus const– und Nicht-const-Variante einer Funktion in eine einzige Vorlage zu gießen. Bei rekursiven Lambdas ist es ebenfalls nützlich. Ich vermute, dass es vor allem Bibliotheksautoren glücklich macht und im Anwendungscode eher selten auftaucht.
Dann gibt es if consteval, mit dem man zwischen Auswertung zur Compile-Zeit und zur Laufzeit unterscheiden kann, ohne std::is_constant_evaluated() zu bemühen. Der Indexoperator darf jetzt mehrere Argumente nehmen, m[i, j] statt m(i, j) oder m[i][j]. Das ist die Vorarbeit für std::mdspan, eine nicht besitzende Sicht auf mehrdimensionale Daten, die vor allem im numerischen Umfeld gebraucht wird.
Kleinkram, der trotzdem auffällt: #elifdef und #elifndef ergänzen den Präprozessor. Und das Literal-Suffix uz erzeugt einen std::size_t, sodass Schleifen mit auto i = 0uz nicht mehr mit Vergleichen zwischen vorzeichenbehafteten und vorzeichenlosen Zahlen nerven. Das ist eine Zeile Änderung, die mir in der Praxis vermutlich mehr Warnungen erspart als manche große Funktion.
Bibliothek: Ranges, Container, Stacktrace
Bei den Ranges war C++20 ehrlich gesagt ein halbes Geschenk. Man konnte filtern und transformieren, aber das Ergebnis wieder in einen std::vector zu bekommen, ging nicht direkt. Das behebt std::ranges::to. Dazu kommen views::zip zum paarweisen Durchlaufen mehrerer Bereiche und views::chunk, das eine Folge in Stücke fester Größe teilt. Wer Python gewohnt ist, wird hier vieles wiedererkennen.
Weiter gibt es:
std::flat_mapundstd::flat_set, Container auf Basis sortierter, zusammenhängender Speicher, die bei kleinen und lesenlastigen Daten oft schneller sind als baumbasierte Variantenstd::generator, der erste fertige Coroutine-Typ in der Standardbibliothek, sodass man nicht mehr den Unterbau selbst schreiben mussstd::stacktracezum Auslesen des Aufrufstapels, etwa für Fehlerberichte
Bei Performance-Versprechen bin ich vorsichtig. Wie viel flat_map bringt, hängt von Datenmenge und Zugriffsmuster ab, und ohne Messung im eigenen Projekt würde ich nichts behaupten.
Die Standardbibliothek als Modul
Das Thema, das mich am meisten interessiert, ist import std;. Statt unzähliger #include-Zeilen ein einziger Import. Das soll Übersetzungszeiten drücken und Makro-Probleme entschärfen. C++20 hatte die Module eingeführt, aber ohne Standardbibliothek als Modul fühlte sich das Ganze halbfertig an. Jetzt gibt es import std; und import std.compat;.
Die Praxis sieht allerdings anders aus als die Theorie. Von den großen Compilern ist nach meinem Eindruck Visual Studio 2022 am weitesten, bei GCC und Clang sind Module nach wie vor ein Baustellenthema, auch mit der Build-Unterstützung der Werkzeuge. Ob man heute produktiv darauf bauen kann, hängt stark von der Toolchain ab. Ich würde es für eigene Experimente nutzen, nicht für ein Projekt mit mehreren Plattformen.
Was heute schon geht
Die Compiler-Unterstützung ist lückenhaft, und das ist bei einem so jungen Standard normal. GCC 13 und Visual Studio 2022 bieten Teile von C++23, aber eben nur Teile, und die Listen sind bei jedem Hersteller unterschiedlich. Ein Blick in die Übersichtsseite zur Compiler-Unterstützung lohnt sich, bevor man auf ein Feature setzt. Meist sind die Bibliotheksteile später dran als die Sprachfeatures.
Aus meiner Sicht kann man jetzt schon mit Kleinkram anfangen: uz, #elifdef, if consteval, den neuen Ranges-Ergänzungen und, je nach Compiler, std::expected. Alles, was auf Module oder neue Containerklassen setzt, würde ich eher als Spielwiese betrachten.
Für alle, die mit C++Builder arbeiten, ist das ohnehin ein anderer Planet. Dort ist C++17, teils auch C++20, der Stand, an dem man sich orientieren kann, und selbst da lohnt der Blick in die Doku der eigenen Version. C++23 ist für diese Umgebung vorerst Zukunftsmusik, und das ist in Ordnung. Wer heute sauber C++17 schreibt, ist für die nächsten Schritte gut vorbereitet.
Mein Eindruck
C++23 ist kein Standard, der die Sprache neu erfindet. Er räumt auf, macht ein paar Dinge bequemer und liefert Bausteine, die C++20 versprochen, aber nicht ganz eingelöst hat. Ich finde, das ist ein gutes Zeichen. Eine Sprache, die über Jahrzehnte gewachsen ist, braucht solche Zwischenstände.
Ich werde in den nächsten Wochen std::expected und std::println in ein kleines Testprojekt einbauen und schauen, wie sich beides anfühlt. Welche Neuerung ist bei euch schon im Code gelandet, oder wartet ihr noch auf den Compiler?
Beitragsbild: ISO-C++-Logo von Jeremy Kratz, gemeinfrei (via Wikimedia Commons; unverändert auf eigenem Hintergrund). Die Marke gehört ihrem Inhaber.
Christian Ackermann
Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.