C++14: kleines Update, große Wirkung

Keine Zeit? Hier die Kurzversion in 30 Sekunden.
- C++14 wurde im August 2014 einstimmig angenommen; die ISO-Veröffentlichung folgt im Dezember. Es ist ein Feinschliff an C++11, kein neuer Sprung.
- Wichtig im Alltag: generische Lambdas, Init-Capture mit
std::move, Rückgabetyp-Deduktion,std::make_unique.- Dazu kommen Binärliterale, Zifferntrenner, großzügigere
constexpr-Funktionen und das Attribut[[deprecated]].- GCC 4.9 und Clang 3.4/3.5 beherrschen das meiste; Visual C++ 2013 nur teilweise.
2011 habe ich über C++11 geschrieben, und damals war das Gefühl: Die Sprache hat sich neu erfunden. Drei Jahre später ist C++14 fertig, und es ist das Gegenteil davon. Das Komitee hat im August den Entwurf einstimmig angenommen, die Veröffentlichung als ISO-Norm steht für Dezember an. Es ist kein Standard, der alles umkrempelt, sondern einer, der die Ecken von C++11 abschleift. Ich finde gerade das sympathisch.
Der Standard hieß lange „C++1y“, so wie C++11 vorher „C++0x“ hieß. Die Zahl im Namen blieb also lange ein Wunsch, der erst spät feststand. Diesmal ging es allerdings deutlich schneller als beim großen Vorgänger. Mein Eindruck ist, dass man bewusst kleinere Pakete in kürzeren Abständen liefern will, statt wieder ein Jahrzehnt auf den nächsten Standard zu warten. Ob das auf Dauer klappt, wird man sehen, für den Moment ist es angenehm.
Generische Lambdas
Lambdas aus C++11 hatten eine Schwäche: Die Parametertypen mussten ausgeschrieben werden. Jetzt darf man auto verwenden, und der Compiler macht aus dem Lambda einen Funktionsaufruf-Operator mit Template-Parameter:
#include <algorithm>
#include <string>
#include <vector>
std::vector<std::string> namen = { "Eva", "Alexander", "Tom" };
std::sort(namen.begin(), namen.end(),
[](const auto& a, const auto& b) { return a.size() < b.size(); });
auto addiere = [](auto x, auto y) { return x + y; };
int i = addiere(2, 3);
double d = addiere(1.5, 2.0);Dasselbe Lambda funktioniert also mit verschiedenen Typen. Das spart Schreibarbeit und macht vor allem bei verschachtelten Containertypen den Code lesbarer. Wer Templates kennt, versteht den Mechanismus sofort: Es ist ein Template, nur ohne die Schreibweise. Man sollte sich dessen bewusst sein, weil sich Fehlermeldungen entsprechend verhalten. Passt ein Typ nicht zum Rumpf, meldet der Compiler das erst bei der Verwendung, und die Meldung ist dann nicht kürzer als bei einer gewöhnlichen Template-Funktion.
Init-Capture und make_unique
Bei C++11 konnte ein Lambda nur Variablen kopieren oder referenzieren. Ein std::unique_ptr lässt sich aber nicht kopieren, also kam man schlecht an ihn heran. Die Init-Capture löst das, indem sie im Capture-Block eine neue Variable anlegen und initialisieren lässt:
#include <memory>
#include <utility>
auto p = std::make_unique<int>(42);
auto f = [q = std::move(p)] { return *q; };
// p ist jetzt leer, f besitzt den ZeigerMit dabei ist std::make_unique, das in C++11 vergessen wurde. Wer bisher std::unique_ptr<T>(new T(...)) geschrieben hat, schreibt jetzt std::make_unique<T>(...), sauberer und ohne ein nacktes new im Code.
Rückgabetyp-Deduktion
Auch normale Funktionen dürfen jetzt auto als Rückgabetyp haben. Der Compiler leitet ihn aus der return-Anweisung ab:
auto quadrat(int x)
{
return x * x;
}Das klingt nach Kleinigkeit, hat aber Folgen: Die Funktion muss vor der Verwendung definiert sein, und bei mehreren return-Anweisungen müssen alle denselben Typ liefern. Ich setze es sparsam ein, am ehesten bei kleinen Hilfsfunktionen und bei Lambdas, wo der Typ ohnehin aus dem Rumpf offensichtlich ist. Bei rekursiven Funktionen muss vor dem rekursiven Aufruf schon eine return-Anweisung stehen, aus der sich der Typ ableiten lässt. Bei öffentlichen Schnittstellen halte ich den ausgeschriebenen Typ für die bessere Dokumentation.
Kleinere Dinge, die man mag
Binärliterale und Zifferntrenner sind unscheinbar und praktisch, wenn man mit Bitmasken oder großen Zahlen arbeitet:
int maske = 0b1010'0110;
long long millionen = 1'000'000;Das Hochkomma wird vom Compiler ignoriert und dient nur dem Auge. Wer schon einmal eine Hexmaske oder eine Zahl mit neun Nullen im Code überprüfen musste, wird die Neuerung zu schätzen wissen. Es ist ein typischer Fall von Feature, das man in Vorträgen kaum erwähnt und im Alltag ständig benutzt.
Bei constexpr sind die Regeln gelockert. In C++11 durfte eine solche Funktion praktisch nur aus einer return-Anweisung bestehen, was Rekursion erzwang. Jetzt sind lokale Variablen und Schleifen erlaubt:
constexpr int fakultaet(int n)
{
int ergebnis = 1;
for (int i = 2; i <= n; ++i)
ergebnis *= i;
return ergebnis;
}
static_assert(fakultaet(5) == 120, "falsch gerechnet");Der Nutzen liegt darin, dass solche Berechnungen zur Übersetzungszeit stattfinden können, zum Beispiel für Tabellen oder Konstanten. Man muss dafür nicht mehr die Rekursion bemühen, was die Funktion lesbarer macht. Die gleiche Funktion lässt sich außerdem zur Laufzeit mit normalen Werten aufrufen.
Und mit [[deprecated]] kann man Funktionen, die nicht mehr verwendet werden sollen, so markieren, dass der Compiler warnt:
[[deprecated("bitte neueFunktion() nehmen")]]
void alteFunktion();Bei größeren Codebasen ist das ein ordentliches Werkzeug für Übergänge: Man führt die neue Schnittstelle ein, markiert die alte, und die Warnungen zeigen, wo noch umgestellt werden muss. Vorher half man sich dazu mit herstellerspezifischen Attributen, die je nach Compiler anders hießen.
Der Compilerstand
Hier muss man genau hinsehen. GCC 4.9 unterstützt die wichtigsten Neuerungen, bisher noch unter dem Schalter -std=c++1y. Bei Clang ist es ähnlich: Version 3.4 bringt das meiste, 3.5 ist näher am fertigen Standard, dort gibt es auch -std=c++14. Bei der Standardbibliothek hängt die Unterstützung vom jeweiligen System ab; ich würde im Zweifel einen kleinen Test kompilieren, statt sich auf Tabellen zu verlassen.
Visual C++ 2013 kann C++14 nur teilweise. Einzelnes wie make_unique ist dabei, bei den Sprachmerkmalen sieht es dünner aus. Wer auf Windows mit Microsoft-Compiler arbeitet, muss deshalb bei den neuen Features abwarten.
Bei C++Builder ist die Lage getrennt zu betrachten. Der klassische 32-Bit-Compiler bcc32 kennt schon C++11 nur lückenhaft. Der 64-Bit-Compiler basiert auf Clang und kann deshalb deutlich mehr moderne Sprachmittel. Wie weit C++14 dort reicht, kann ich nicht sagen, das hängt von der Version ab. Wer es braucht, sollte es einfach ausprobieren.
Was bleibt
Für mich ist C++14 ein Update, das man im Alltag schnell zu schätzen lernt: Generische Lambdas und make_unique benutze ich praktisch sofort, wenn der Compiler es hergibt. Der große Wurf sind die Neuerungen nicht, und das ist keine Kritik. C++11 hat die Sprache verändert, C++14 macht sie angenehmer. Die Frage, die mich mehr beschäftigt als der Standard selbst: Wie lange dauert es, bis das, was in der Norm steht, in den Compilern steckt, die wir tatsächlich im Projekt haben? Das war bei C++11 schon so, und bei Werkzeugen, die in manchen Projekten Jahre alt sind, wird es wieder so sein.
Beitragsbild: eigene Grafik mit Logo von Wikimedia Commons (ISO-C++-Logo: Jeremy Kratz, gemeinfrei); die Marke gehört ihrem Inhaber.
Christian Ackermann
Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.