Modernes C++

This is about computer mechanics… What happens when you take your favoured programming language and send it to the shop for a 60000 mile tune-up?

— Bjarne Stroustrup¹⁾

Seit 2011 wird das „klassische“ C++98²⁾ im 3-Jahres-Rhythmus weiterentwickelt (siehe Zeitleiste). Aktuelle Compiler unterstützen „modernes“ C++11, C++14, C++17 (fast) vollständig und C++20, C++23, C++26 zunehmend. Technische Spezifikationen (TS) und andere Vorschläge können in den nächsten Entwurf (C++29) einfließen. Die folgenden Listen sind unvollständig und in ihrer Reihenfolge subjektiv.

C++ crossed a Rubicon: it handed us the keys to its own machinery.
— Herb Sutter³⁾

• Static reflection
• kein undefiniertes Verhalten beim Lesen uninitialisierter lokaler Variablen
• Unterstrich als Platzhalter für unbenutzte Variablen: auto [x,_,z] = f();
• <contracts> : Vor- und Nachbedingungen, Zusicherungen
• <debugging> : Breakpoints im Quellcode setzen, Debugger-Unterstützung
• std::execution : Sender/Receiver-Modell für konkurrente und parallele Verarbeitung⁴⁾
• <hive> : Container für Elemente, die häufig entstehen und verschwinden (inspiriert von plf::colony)
• <linalg> : lineare Algebra mit BLAS-Funktionen
• <simd> : Datentypen für parallele Datenverarbeitung
• Ganzzahlen ohne Überlauf ("saturation arithmetic")
• Zufallszahlengenerator std::philox_engine, std::ranges::generate_random()
• std::views::concat, std::views::cache_latest

“Pandemic Edition” … not slowing down.
— Herb Sutter⁵⁾

• import std; für Module der Standard-Bibliothek
• <ranges>: Temporäre Werte in range-based for leben länger (P2644).
  • std::ranges::to<Container> (P1206)
  • std::views::enumerate⁶⁾, as_const, as_rvalue, cartesian_product, chunk[_by], join_with, repeat, slide, stride, adjacent[_transform], pairwise[_transform], zip[_transform]
  • Algorithmen: iota(), shift_left(), shift_right(), starts_with(), ends_with(), contains(), fold()
• std::generator<T> für Coroutinen
• std::print() wirkt wie std::cout << format(), std::println(),
• an Python angelehnte Ausgabe (P2286): std::print("{}", std::vector{1,2,3,1}); → [1, 2, 3, 1], std::print("{}", std::set{1,2,3,1}); → {1, 2, 3}
• s.contains("C++") für string und string_view
• std::mdspan: mehrdimensionale Feldindizes a[i,j]
• std::expected<Result,Error> und std::optional<T> mit monadischen Operationen transform(), and_then(), or_else()
• Quelltext in UTF-8, Unicode Annex 31 für Bezeichner: int 💩 = 23;
• Literalsuffix (vorzeichenloser) size_t: for (auto i = 0zu, s = v.size(); i < s; ++i) …
• cachefreundliche Container std::flat_[multi]map<K,V>, std::flat_[multi]set<T>
• std::stacktrace hilft bei der Fehlersuche.

… our biggest nine-year-cycle yet … in terms of new features added.

— Herb Sutter⁷⁾

• Module⁸⁾ überwinden Probleme des #include-Mechanismus (Präprozessor, Makros). import-Anweisungen beschleunigen das Übersetzen, übergangsweise auch import <iostream>; Die Modularisierung der Standard-Bibliothek erfolgt erst mit C++23 (P0581).
• <ranges> modernisiert <algorithm>, z.B. std::ranges::sort(v); kombinierbare Views filter(odd) | transform(sqr) | take(3) verarbeiten Wertfolgen „lazy“⁹⁾.
• Concepts beschränken Schablonen, ersparen SFINAE-Tricks, erleichtern den Compilern die Auswahl der passenden generischen Funktion und sorgen für hilfreichere Fehlermeldungen, falls v nicht sortierbar ist. Generische Funktionen mit auto-Parametern sind auch ohne den Vorsatz template … Schablonen.
• <coroutine> verzahnt Prozeduren ineinander. Typen wie task<T> oder generator<T> fehlen leider noch¹⁰⁾.
• <format>: Typsichere, schnelle und flexible Aufbereitung von Ausgaben mit std::format("C++{}", 20) erleichtert die Internationalisierung.
• <chrono> erhält Zeitzonen und Kalender.
• <compare>: Drei-Wege-Vergleich mit dem "spaceship operator" a <=> b. std::rel_ops wird geächtet.
• <barrier>, <latch>, <semaphore>, <stoptoken> und RAII-konforme std::jthread (joining threads) ergänzen die Möglichkeiten zur nebenläufigen Verarbeitung.
• <bit>: Bits zählen, rotieren, bit_cast<T>(x) statt dem undefiniertem Verhalten von &reinterpret_cast<T*>(&x)
• <numbers> : mathematische Konstanten $\pi$, $e$, $\sqrt{2}$ u.a.
• <span> zeigt auf einen Bereich von aufeinanderfolgenden Elementen, ohne ihn zu besitzen (Zeiger und Anzahl der Elemente).
• <syncstream> garantiert in nebenläufigen Prozessen Ausgaben ohne Wettrennen.
• <version> ersetzt <ciso646> zur Versionserkennung, <source_location> löst __FILE__, __LINE__ etc. ab.
• Typen char8_t, u8string, u8string_view für UTF-8-kodierten Unicode-Text, Methoden s.starts_with(…) und s.ends_with(…) für string und string_view
• Initialisierungsteil in for (int i=0; auto e:seq) ... (enumerate?)
• bezeichnete Struktur-Initialisierer struct A { int x,y,z; }; A a{.x=1, .z=3}; aus C übernommen
• Funktionen
  • std::erase(container, value) anstelle von c.erase(std::remove(c.begin(), c.end(), value), c.end()) und
  • std::erase_if(container, predicate) statt c.erase(std::remove_if(c.begin(), c.end(), predicate), c.end()) für Container,
  • std::midpoint(a, b) und Interpolieren mit std::lerp(a, b, t) als a + t*(b-a) in <numeric>
  • std::shift_left(first,last,n) und std::shift_right(first,last,n) in <algorithm>

If you can look at a screenful of code and tell that it’s C++17, then we’ve changed the way we program C++.

— Herb Sutter¹¹⁾

  std::pair p{1, 'a'};            // pair<int,char>
  auto [n, c] = p;                // structured bindings 
  for (auto [key, value] : mymap) /* ... */;
  if (auto [it, success] = mymap.insert({key, value}); success) use(it);

• Erschließen von Template-Argumenten aus Konstruktorparametern (CTAD) macht Hilfsfunktionen wie make_pair() und make_tuple() überflüssig.
• Structured bindings¹²⁾ entpacken zusammengesetzte Werte, auch in for-Anweisungen sowie if und switch, die um einen Initialisierungsteil erweitert wurden.
• <filesystem>: Zugriff auf das Dateisystem
• std::optional<T> als Kapsel für ein evtl. vorhandenes Objekt, std::any und std::variant<T1,...,Tn> als typsicherer Ersatz für void* und union
• std::string_view als einheitliche lesende Schnittstelle zur Inspektion von std::string und anderen Zeichenketten, std::byte für Bitoperationen
• ggT und kgV benötigten 2300 Jahre¹³⁾ aus den Elementen nach C++: std::gcd(m,n)*std::lcm(m,n) == m*n
• Pythagoras in 3D std::hypot(x,y,z), Wertbegrenzung std::clamp(x,1,10) und zufällige Stichproben einer Sequenz std::sample(first, last, out, n, rng)
• parallelisierte Algorithmen und "spezielle" mathematische Funktionen: elliptische Integrale, Kugel- und Zylinderfunktionen, Hermite-, Laguerre-, Legendre-Polynome…
• geschachtelte Namensräume namespace A::B {…} für namespace A { namespace B {…} }
• if constexpr (expression) erleichtert das Schreiben von Funktionsschablonen ohne SFINAE-Tricks.
• Umhängen von einzelnen Knoten zwischen [unordered_][multi_]set|map und set1.merge(set2) zum Verschmelzen assoziativer Container
• Funktionsargumente werden stets v.l.n.r. ausgewertet, unnötige Kopien garantiert vermieden (copy elision), C11 statt C99 wird Schwestersprache.
• Die Regeln der Initialisiererliste wurden geändert: auto answer{42}; ist nun endlich eine Ganzzahl.

…completes C++11.

— ISO C++ FAQ

• Binärliterale 0b101010 und Stellentrennzeichen 1'234'567
• Literalsuffixe "Hallo"s für <string>, 1.0 + 2.0i für <complex>, 23h+56min+4s für Zeitdauern in <chrono>
• automatisches Erkennen des Ergebnistyps von Funktionen, generische Lambda-Ausdrücke und Lambda-capture-Ausdrücke
• make_unique(), const-iterator-Funktionen cbegin(), cend()
• Funktionsobjekte std::greater<> ohne Typangabe möglich
• std::quoted(s) für Ein- und Ausgabe von Zeichenketten mit Begrenzungszeichen ("Gänsefüßchen")
• Variablen-Templates

It feels like a new language.

— Bjarne Stroustrup

• neue Schlüsselwörter, auto-Variablen, range-based for, Lambda-Ausdrücke
• Initialisiererliste, Startwerte und Konstruktorparameter in geschweiften Klammern (einheitliche Schreibweise zur Anfangswertbelegung)
• Attribut-Initialisierung: Startwerte für Member-Variablen, zu- und abschaltbare spezielle Methoden, Konstruktor-Delegation
• Rvalue-Referenzen: Unterscheidung von Kopier- und Verschiebesemantik
• >> am Ende verschachtelter Templates ohne Leerzeichen dazwischen, variadische Templates
• raw strings, nullptr statt Ganzzahl 0, Attributspezifizierer
• Bibliotheken für
  • <thread>, <mutex>, <condition_variable>, <atomic>, <future>: Nebenläufigkeit
  • <memory>: intelligente Zeiger shared_ptr<T>, unique_ptr<T>
  • <array>, <forward_list>, <initializer_list>, <unordered_map>, <unordered_set>: neue Container
  • <regex>: reguläre Ausdrücke
  • <tuple>: Tupel
  • <random>: Zufallszahlgeneratoren
  • <ratio>: Verhältniszahlen
  • <chrono>: Uhren, Zeitpunkte, Zeitintervalle