~/blog/2017/01/modernes-cpp-in-alten-codebasen.md

Modernes C++ in alten Codebasen

5 min
Beitragsbild: Modernes C++ in alten Codebasen

Keine Zeit? Hier die Kurzversion in 30 Sekunden.

  • C++11 und C++14 lassen sich schrittweise in gewachsenen Code einführen, ohne alles umzuschreiben.
  • Lohnende Einstiege: nullptr, override, unique_ptr statt Rohzeiger und auto_ptr, range-based for, enum class.
  • Die modernize-Checks von clang-tidy erledigen einen Teil der mechanischen Arbeit, ersetzen aber kein Review.
  • Grenzen setzen alte Compiler, ABI-Kompatibilität zu Fremdbibliotheken, Build-Systeme und gemischte Teams.
  • Mein Weg: bei Berührung modernisieren, nicht per Big Bang.

Die meisten C++-Projekte, mit denen ich zu tun hatte, sind älter als der Standard von 2011. Da liegt Code, der mit Visual C++ 6 anfing, später auf neuere Compiler gehoben wurde und heute Funktionen enthält, die niemand mehr gern anfasst. Gleichzeitig liest man überall, wie angenehm modernes C++ geworden ist. Die Frage, die sich daraus ergibt, ist weniger „Was kann die Sprache?“ als „Wie kommt das in meinen Code, ohne dass alles auseinanderfällt?“

Warum kein großer Wurf

Die verlockende Idee ist ein Umbau-Sprint: eine Woche lang alles auf C++14 heben, Rohzeiger raus, Smart Pointer rein. Ich habe das nie funktionieren sehen, und ich würde es auch nicht versuchen. Ein solcher Umbau erzeugt riesige Änderungen, die sich kaum reviewen lassen, und er vermischt mechanische Anpassungen mit echten Verhaltensänderungen. Tauchen danach Fehler auf, weiß keiner, welche Zeile schuld ist.

Mir hat eine andere Regel besser gefallen: Modernisiert wird, was ich ohnehin anfasse. Wer eine Funktion für einen Fehler oder ein Feature öffnet, darf in dieser Funktion und nur dort aufräumen. Das hält die Änderungen klein, jede Zeile hat einen Grund, und die Teile des Codes, die oft bearbeitet werden, werden zuerst besser. Der Code, der seit Jahren unverändert läuft, bleibt in Ruhe, und das ist meistens richtig so.

Die Kandidaten mit gutem Verhältnis von Nutzen und Risiko

Ein paar Sprachmittel sind fast geschenkt, weil sie wenig verändern und viel klarer machen.

nullptr statt NULL oder 0. Das Makro NULL ist in C++ meist nur eine 0, und das führt bei überladenen Funktionen zu Überraschungen. nullptr hat einen eigenen Typ und löst das. Der Austausch ist praktisch risikofrei.

override. Wer eine virtuelle Funktion überschreibt, sollte das sagen:

class Zeichner : public Basis {
public:
    void zeichne(Kontext& ctx) const override;
};

Stimmt die Signatur nicht, etwa weil in der Basisklasse ein const fehlt, meldet der Compiler das jetzt. Vorher entstand stillschweigend eine neue Funktion, und die alte wurde weiter aufgerufen. In gewachsenen Klassenhierarchien findet man mit override erstaunlich oft Stellen, an denen ein Überschreiben nur zufällig funktionierte oder eben gar nicht.

unique_ptr statt Rohzeigern mit Besitz und auto_ptr. std::auto_ptr ist seit C++11 veraltet, weil sein „Kopieren“ in Wahrheit ein Verschieben war. std::unique_ptr macht das ehrlich: nicht kopierbar, aber verschiebbar. Besitzende Rohzeiger in Membern sind der Klassiker für Speicherlecks im Fehlerfall. Hier lohnt sich die Umstellung, aber mit Augenmaß. Wo der Besitz unklar ist, zwingt unique_ptr zu einer Antwort, und die Antwort steht dann nicht unbedingt auf den ersten Blick im Code.

Range-based for statt Iterator-Schleifen, und auto dort, wo der Typ ohnehin aus der rechten Seite hervorgeht:

for (const auto& eintrag : liste) {
    verarbeite(eintrag);
}

Bei auto bin ich zurückhaltend. Für lange Iterator-Typen ist es ein Segen, bei einfachen Typen und Rückgabewerten eher nicht, denn dann muss man den Typ im Kopf nachbauen.

enum class. Klassische Enums leaken ihre Namen in den umgebenden Scope und wandeln sich still in int um. Bei neuem Code würde ich nur noch enum class nehmen. Bei altem Code ist die Umstellung aufwendiger, weil sie Aufrufstellen berührt, und deshalb ein Fall für „bei Berührung“.

Werkzeuge helfen, aber nicht blind

clang-tidy bringt unter dem Namen modernize eine Reihe von Prüfungen mit, die genau solche Umstellungen automatisch vornehmen können, etwa für nullptr, override, Schleifen und auto_ptr. Ein Aufruf sieht ungefähr so aus:

clang-tidy -checks='-*,modernize-use-nullptr' -fix datei.cpp -- -std=c++11

Voraussetzung ist, dass das Werkzeug weiß, wie die Datei gebaut wird. Bei CMake-Projekten lässt sich dafür eine compile_commands.json erzeugen, bei anderen Build-Systemen wird es mühsamer. Meine Erfahrung mit solchen Werkzeugen: Sie sind gut bei streng mechanischen Dingen, und bei allem, was Semantik berührt, will ich jede Änderung sehen. Die Ergebnisse gehören in einen eigenen Commit, getrennt von fachlichen Änderungen. Dann kann man sie schnell durchsehen, und bei einer Auffälligkeit bleibt die Fehlersuche überschaubar.

Welche Checks es gibt, hängt von der Version des Werkzeugs ab. Ein Blick in die Dokumentation der eigenen Version spart Enttäuschungen.

Wo es klemmt

Die Sprache ist nur ein Teil. Was in der Praxis bremst, steht meist woanders.

  • Compiler. Wenn irgendwo ein alter Compiler gebraucht wird, etwa wegen einer Zielplattform oder eines Kundensystems, entscheidet er, was erlaubt ist. Solange nicht alle Zielplattformen C++11 oder C++14 verstehen, gibt es keine Smart Pointer und kein override. Manchmal hilft ein Makro, das override auf nichts abbildet, aber das ist ein Notbehelf und kein Zustand, den man dauerhaft haben will.
  • ABI. Wer Bibliotheken ausliefert oder Binärkomponenten von Dritten einbindet, hat mit der Binärschnittstelle zu tun. Standardbibliothek-Typen in öffentlichen Schnittstellen sind ein Risiko, sobald nicht alle Seiten mit demselben Compiler und denselben Einstellungen gebaut sind. Ein unique_ptr in einer exportierten Funktion ist deshalb nicht überall eine gute Idee.
  • Build-Systeme. Ältere Makefiles, projektspezifische Skripte oder IDE-Projekte setzen die Sprachversion gern gar nicht oder uneinheitlich. Bevor man modernen Code schreibt, sollte klar sein, wo der Schalter für den Standard sitzt, und dass er überall gleich gesetzt ist.
  • Das Team. Das ist wahrscheinlich der unterschätzteste Punkt. Wenn die Hälfte des Teams C++11 geläufig ist und die andere nicht, entsteht Code, den nicht mehr alle lesen können. Hier helfen kurze Absprachen, welche Mittel erlaubt sind, und Reviews, die auch erklären statt nur zu korrigieren.

Und der Blick nach vorn

Der nächste Standard wird derzeit unter dem Arbeitsnamen C++1z geführt und soll voraussichtlich 2017 fertig werden. Fertig ist er nicht, und die Compiler setzen nur Teile davon um. Für Bestandsprojekte würde ich darauf nicht warten. Der Sprung von C++03 auf C++11 und C++14 ist groß genug, und er bringt den Gewinn, den man im Alltag spürt.

Was ich mitnehme

Modernisieren heißt in alten Codebasen vor allem: Risiko klein halten. Ich fange mit den Änderungen an, die der Compiler selbst absichert, also override und nullptr, gehe über zu Besitzverhältnissen mit unique_ptr und lasse alles Weitere ruhig liegen, bis ich ohnehin an der Stelle arbeite. Das sieht von außen langsam aus, aber nach ein paar Monaten sind genau die Bereiche lesbarer, in denen am meisten passiert. Und das war ja der Grund, warum man überhaupt aufräumen wollte.

Beitragsbild: Foto Bjarne Stroustrup von Julia Kryuchkova, CC BY-SA 2.5 (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.