~/blog/2019/03/cpp-builder-10-3-rio-cpp17-mit-cla.md

C++Builder 10.3 Rio: C++17 mit Clang

6 min
Beitragsbild: C++Builder 10.3 Rio: C++17 mit Clang

Keine Zeit? Hier die Kurzversion in 30 Sekunden.

  • C++Builder 10.3 Rio (November 2018) hebt den Clang-basierten Win32-Compiler auf einen neueren Stand und bringt damit C++17.
  • Im Alltag nützlich: structured bindings, std::optional, if constexpr und std::string_view.
  • Der klassische bcc32 bleibt ein Auslaufmodell. Wer noch auf ihm sitzt, sollte die Migration jetzt testen.
  • Strengere Diagnosen des Clang-Compilers decken alten Code auf, der bisher nur zufällig lief.
  • Drittanbieter-Komponenten sind der häufigste Stolperstein, nicht der Compiler.

Ich hatte mir fest vorgenommen, mit dem Update auf 10.3 nicht gleich alles umzukrempeln. Dann habe ich an einem Sonntag ein kleines Testprojekt angelegt, den Sprachstandard hochgestellt, und eine halbe Stunde später saß ich mit std::optional in einem VCL-Formular. So geht das also, wenn man nur mal kurz schauen will.

Bei C++Builder 10.3 Rio, im November 2018 erschienen, wird viel über die Delphi-Seite geredet. Inline-Variablen und Typinferenz bei Variablen sind schöne Neuerungen, aber eben für Delphi. Für C++ ist das Interessante etwas anderes: Der Clang-basierte Win32-Compiler wurde auf einen deutlich neueren Clang-Stand gehoben, nach meinem Wissen Clang 5, und kann damit C++17.

Was sich um die IDE herum geändert hat

Kurz zum Drumherum, weil man es sofort sieht. Die IDE hat einen neuen, flacheren Look bekommen, und es gibt ein neues dunkles Theme. Ich arbeite gern mit dunklen Oberflächen, deshalb war das für mich ein Pluspunkt, auch wenn es mit dem Compiler nichts zu tun hat. Ein erstes Update für 10.3 ist inzwischen ebenfalls erschienen, wer also noch wartet, bis die ersten Kinderkrankheiten behoben sind, hat dafür jetzt eine gute Gelegenheit.

Dazu kommt, dass es seit Juli 2018 eine kostenlose C++Builder Community Edition gibt. Für Hobbyprojekte und zum Ausprobieren ist das eine niedrige Hürde. Ich nehme an, dass auch deshalb wieder mehr Leute neugierig auf den C++-Teil der Produktfamilie schauen.

C++17 im Alltag: was nützt mir das mit der VCL?

C++17 ist kein Revolutionsstandard, eher eine Sammlung von Dingen, die den Code kürzer und sicherer machen. Ein paar Beispiele, die ich in einem VCL-Umfeld tatsächlich nutzen würde.

Structured bindings. Wer über eine Map iteriert, kennt das Gefummel mit it->first und it->second. Jetzt geht es lesbarer:

std::map<std::string, int> anzahl {{"Rot", 3}, {"Blau", 5}};

for (const auto& [farbe, menge] : anzahl) {
    ListBox1->Items->Add(String(farbe.c_str()) + ": " + IntToStr(menge));
}

Die Umwandlung nach String ist noch altbekannte Handarbeit, aber die Schleife selbst ist deutlich verständlicher.

std::optional. Funktionen, die manchmal kein Ergebnis haben, mussten bisher mit Rückgabewerten wie -1, Nullzeigern oder einem Ausgabeparameter arbeiten. Mit std::optional sagt der Typ, was Sache ist:

#include <optional>
#include <string>
#include <vector>

std::optional<std::size_t> finde(const std::vector<std::string>& liste,
                                 const std::string& gesucht)
{
    for (std::size_t i = 0; i < liste.size(); ++i) {
        if (liste[i] == gesucht) return i;
    }
    return std::nullopt;
}

// Aufruf
if (auto pos = finde(namen, "Meier")) {
    // *pos ist gültig
}

Das if mit Initialisierung ist übrigens ebenfalls C++17 und hilft, Variablen auf den Block zu beschränken, in dem man sie braucht.

if constexpr. Das ist eher etwas für Templates. Statt mit Spezialisierungen oder Tricks verschiedene Pfade zu bauen, entscheidet der Compiler zur Übersetzungszeit, welcher Zweig überhaupt übersetzt wird. Wer eigene Hilfsfunktionen für verschiedene Typen schreibt, spart sich einiges an Boilerplate.

std::string_view. Eine Sicht auf eine Zeichenkette, ohne zu kopieren. Praktisch für Parameter, bei denen man nur lesen will. Man sollte nur nicht vergessen, dass die Sicht auf etwas zeigt, das noch leben muss. Bei temporären Strings kann das schiefgehen, und der Compiler warnt nicht immer.

Ob ich das alles gleich im großen Stil einsetze? Eher nicht. Ich glaube, der Gewinn liegt im Kleinen: ein paar Stellen, an denen der Code spürbar aufgeräumter wird, ohne dass man Architektur anfassen muss.

Alter Compiler gegen Clang

Das eigentliche Thema hinter all dem ist die Frage, welcher Compiler im Projekt arbeitet. C++Builder hat seit einigen Versionen zwei Welten nebeneinander. Der klassische bcc32 ist der Compiler, den es seit Ewigkeiten gibt. Er kennt kein modernes C++ und wird nicht mehr weiterentwickelt. Daneben steht der Clang-basierte Compiler, der die neueren Standards mitbringt und der es ist, in den Embarcadero weiter investiert.

Wer Bestandscode hat, steht vor einer ehrlichen Abwägung. Der alte Compiler schluckt Dinge, die streng genommen nie hätten durchgehen dürfen. Clang ist da pingeliger. Strengere Diagnosen heißen konkret: Warnungen und Fehler an Stellen, an denen bisher nichts passierte. Dazu zählen uninitialisierte Variablen, implizite Konvertierungen, Vergleiche mit falschem Typ. Das kann am Anfang nerven, aber ich sehe es auch als Geschenk. Manche dieser Meldungen zeigen echte Fehler, die man sonst nur zufällig bemerkt hat.

Bei den Kompilierzeiten hatte ich beim Ausprobieren den Eindruck, dass es je nach Projekt Unterschiede gibt, und zwar in beide Richtungen. Zahlen kann ich dazu nicht liefern, dafür habe ich zu wenig sauber gemessen. Wer es genau wissen will, muss das an seinem eigenen Projekt prüfen.

Migration: so würde ich vorgehen

Ein Umstieg auf den neuen Compiler ist in meinen Augen kein Wochenendprojekt, aber auch kein Hexenwerk. Meine Reihenfolge:

  1. Kopie des Projekts anlegen und dort umstellen, nicht im Original.
  2. Erst ohne neuen Sprachstandard kompilieren. Es geht zuerst darum, ob der Code überhaupt mit dem Clang-Compiler baut.
  3. Warnungen abarbeiten. Nicht alle auf einmal ausschalten, sondern anschauen. Einige davon sind wertvoll.
  4. Dann den Standard hochstellen und prüfen, ob etwas bricht. In den Projektoptionen gibt es die Einstellung für die Sprachversion.
  5. Neue Features nur dort einsetzen, wo sie lohnen. Ein Sprachstandard ist kein Auftrag zum Umschreiben.

Für Win64 muss man genau hinschauen, was unterstützt wird. Ich möchte dazu keine pauschale Aussage machen, weil ich es selbst nicht gründlich genug geprüft habe. Wer 64-Bit-Anwendungen baut, sollte die Dokumentation und die Release Notes zur Hand nehmen und mit einem kleinen Test anfangen.

Drittanbieter-Komponenten

Und dann kommen die Komponenten. In jedem größeren VCL-Projekt hängt irgendetwas, das nicht aus eigener Hand stammt: Grids, Diagramme, Berichtsgeneratoren, Kommunikationsbibliotheken. Manche gibt es nur als vorkompilierte Pakete, manche sind seit Jahren nicht mehr gepflegt.

Bei der Migration zeigt sich das als Erstes. Vorkompilierte Bibliotheken müssen zum Compiler passen, sonst gibt es Linkerfehler, die auf den ersten Blick nichts mit Clang zu tun haben. Mein Rat: Vor dem Umstieg eine Liste aller Komponenten machen und bei den Herstellern nachsehen, ob es Versionen für 10.3 und den Clang-Compiler gibt. Wer Quellcode der Komponenten besitzt, ist klar im Vorteil.

Was ich vorerst lasse

Zur Ehrlichkeit gehört auch, was ich nicht anfasse. Ich stelle keine funktionierende Anwendung nur deshalb um, weil es jetzt geht. Wenn ein Projekt seit Jahren stabil mit dem alten Compiler läuft und niemand neue Features braucht, ist die Umstellung zunächst Aufwand ohne sichtbaren Nutzen. Anders sieht es aus, sobald neue Bibliotheken ins Spiel kommen, die modernes C++ voraussetzen, oder sobald man Code teilen möchte, der auch mit anderen Compilern gebaut wird. Dann zahlt sich ein einheitlicher Standard schnell aus.

Auch Schulungen und Teams sollte man bedenken. Wer jahrelang in einem älteren C++-Stil geschrieben hat, braucht etwas Zeit, bis die neuen Mittel selbstverständlich werden. Ein Code-Review, in dem man sich gegenseitig die neuen Möglichkeiten zeigt, hilft mehr als jede Richtlinie.

Einordnung

Ich finde es gut, dass sich beim C++-Teil von C++Builder etwas bewegt. Lange hatte man das Gefühl, dass die Sprache bei der Pflege hinterherhinkt, während alle anderen längst von C++14 oder C++17 reden. Dass der Clang-Compiler nun aktueller ist, macht das Produkt für Neues deutlich attraktiver.

Für bestehende Projekte bleibt es dennoch Arbeit. Ich würde nicht auf den Tag warten, an dem es unvermeidlich wird, sondern lieber jetzt in Ruhe eine Kopie umstellen und sehen, wo die Probleme liegen. Dann kann man später entspannt entscheiden, statt unter Zeitdruck zu migrieren.

Habt ihr schon Erfahrungen mit dem Wechsel gemacht, vielleicht gerade mit Drittanbieter-Komponenten? Mich würde interessieren, wo es bei euch gehakt hat.

Beitragsbild: Foto Rio de Janeiro mit Zuckerhut von Acediscovery, CC BY 4.0 (via Wikimedia Commons; zugeschnitten auf 16:9).

$ whoami
Christian Ackermann

Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.