C++: von C with Classes zum modernen C++

C++ nimmt in der Geschichte der Programmiersprachen eine besondere Stellung ein. Seit Ende der 1970er-Jahre verfolgt die Sprache ein anspruchsvolles Ziel: mächtige Abstraktionen ermöglichen, ohne die direkte Kontrolle über Ressourcen oder maschinennahe Leistung aufzugeben.

Diese Spannung zwischen Abstraktion und Kontrolle prägt ihre Entwicklung. C++ hat Klassen, generische Programmierung, eine umfangreiche Standardbibliothek, funktionale Techniken und Nebenläufigkeit aufgenommen und zugleich eine starke Kontinuität zu C und zu jahrzehntealter Software bewahrt.

Das Ergebnis ist ebenso leistungsfähig wie komplex. Die Geschichte zeigt, dass diese Komplexität nicht nur zufällig angewachsen ist. Häufig entsteht sie aus bewussten Kompromissen zwischen Kompatibilität, Leistung und dem Anspruch, sehr unterschiedliche Softwareklassen abzudecken.

Von C zu C with Classes

Anfang der 1970er-Jahre erwies sich C in den Bell Labs als besonders wirksames Werkzeug für die Entwicklung von Unix. Dennis Ritchies Sprache verband relative Portabilität mit direktem Speicherzugriff und einem einfachen Ausführungsmodell und wurde schnell zu einer tragenden Säule der Systemprogrammierung.

Mit wachsenden Softwaresystemen stellte sich jedoch eine neue Frage: Wie lassen sich große Programme strukturieren, ohne die Eigenschaften aufzugeben, die C so nützlich machten?

Ende der 1970er-Jahre arbeitete Bjarne Stroustrup in Cambridge mit Simula. Er schätzte dessen Klassen und Abstraktionsmechanismen, doch die verfügbare Leistung seiner damaligen Umgebung genügte nicht allen Anforderungen.

Nach seinem Wechsel zu den Bell Labs 1979 suchte er deshalb eine Verbindung: Effizienz und Ökosystem von C sollten erhalten bleiben, ergänzt um Abstraktionen, die unter anderem von Simula inspiriert waren. Das Projekt hieß C with Classes.

Frühe Versionen boten Klassen, Konstruktoren und Destruktoren, Zugriffskontrolle und Vererbung. Stroustrup entwickelte außerdem Cfront, das die neue Sprache zunächst in C übersetzte, bevor ein vorhandener C-Compiler das endgültige Programm erzeugte. Diese pragmatische Strategie erleichterte Experimente und den Einsatz auf Systemen mit bestehenden C-Werkzeugketten.

1983: Aus C with Classes wird C++

1983 erhielt die Sprache den Namen C++, vorgeschlagen von Rick Mascitti. In C erhöht ++ einen Wert; der Name deutet also eher ein „inkrementiertes“ C als einen vollständigen Ersatz an.

Nach und nach kamen virtuelle Funktionen, Funktions- und Operatorüberladung, Referenzen, Konstanten und eine stärkere Typprüfung hinzu. 1985 begleitete die erste Ausgabe von The C++ Programming Language die Verbreitung über das experimentelle Umfeld der Bell Labs hinaus.

Die Nähe zu C war strategisch wertvoll: Entwickler konnten Wissen, Bibliotheken und Werkzeuge weiterverwenden. Sie brachte aber auch eine dauerhafte Belastung mit sich, denn C++ musste neue Mechanismen mit einem Erbe vereinbaren, das älter war als die Sprache selbst.

Objektorientiert, aber nie nur objektorientiert

In den 1980er- und 1990er-Jahren verbreitete sich objektorientierte Programmierung stark. C++ trug dazu bei, Klassen, Kapselung, Vererbung und virtuelle Funktionen für dynamischen Polymorphismus populär zu machen.

C++ lediglich als „C mit Objekten“ zu beschreiben, wurde jedoch schnell unzureichend. Die Sprache schrieb nie ein einziges Modell vor. Freie Funktionen, Werttypen, Klassen, Vererbung, generische Programmierung und direkter Ressourcenzugriff können nebeneinander verwendet werden.

Diese Mehrparadigmenausrichtung unterscheidet C++ von Sprachen mit einem einheitlicheren Objektmodell.

Zero-overhead-Abstraktionen

Eine Formulierung fasst einen großen Teil der C++-Philosophie zusammen: zero-overhead abstractions.

Nicht verwendete Funktionen sollen möglichst keinen Preis verursachen. Verwendete Abstraktionen sollen wiederum nicht wesentlich ineffizienter sein als eine gut geschriebene manuelle Umsetzung derselben Aufgabe.

Das bedeutet nicht, dass jede C++-Abstraktion buchstäblich kostenlos ist. Die Sprache versucht vielmehr, höherstufige Konzepte auszudrücken, ohne grundsätzlich eine virtuelle Maschine, Garbage Collection oder ein schwereres Laufzeitmodell vorzuschreiben.

Dieser Anspruch erklärt sowohl die Effizienz als auch einen Teil der Schwierigkeit von C++. Repräsentation, Lebensdauer und Kosten präzise kontrollierbar zu halten erfordert mehr Konzepte als in Umgebungen, die solche Entscheidungen bewusst verbergen.

RAII: Lebensdauer als Werkzeug

Konstruktoren und Destruktoren führten zu einem der charakteristischsten C++-Idiome: RAII (Resource Acquisition Is Initialization).

Eine Ressource wird an die Lebensdauer eines Objekts gebunden. Der Konstruktor kann sie erwerben, der Destruktor gibt sie automatisch frei, wenn das Objekt seinen Gültigkeitsbereich verlässt. Das kann Speicher sein, aber ebenso eine Datei, eine Sperre, eine Verbindung oder ein Betriebssystem-Handle.

RAII macht die deterministische Zerstörung von Objekten zu einem allgemeinen Mechanismus für Ressourcenverwaltung. Das Prinzip ist bis heute zentral und erklärt, warum modernes C++ verstreute manuelle Aufrufe von new und delete möglichst vermeidet.

Templates und generische Programmierung

Ende der 1980er- und Anfang der 1990er-Jahre gaben Templates C++ eine weitere Identität. Funktionen und Typen konnten durch andere Typen parametrisiert werden, sodass Algorithmen und Datenstrukturen generisch formulierbar wurden.

Damit war C++ nicht länger nur C plus Objektorientierung, sondern wurde zu einer wichtigen Heimat der generischen Programmierung.

Die Arbeiten von Alexander Stepanov und seinen Kollegen führten zur Standard Template Library, der STL. Ihre grundlegende Idee besteht darin, Container und die auf ihnen arbeitenden Algorithmen über generische Schnittstellen, insbesondere Iteratoren, voneinander zu entkoppeln.

Container wie vector und map können dadurch mit standardisierten Sortier-, Such- und Transformationsalgorithmen zusammenarbeiten, ohne für jeden Container einen eigenen Algorithmus zu benötigen.

Die STL zeigte, dass Generizität, Wiederverwendung, Abstraktion und Leistung miteinander vereinbar sind. Sie wurde ein wesentlicher Bestandteil der Standardbibliothek und veränderte idiomatisches C++ nachhaltig.

1998: ein ISO-Standard

Mit der wachsenden Zahl von Compilern stieg das Risiko inkompatibler Dialekte. Internationale Standardisierung wurde notwendig.

1998 erhielt C++ seinen ersten vollständigen ISO-Standard. C++98 formalisierte Sprache und Standardbibliothek und integrierte die STL. C++03 folgte als korrigierende Überarbeitung.

Die Standardisierung veränderte auch die Governance. Die Entwicklung lief nun über ein internationales Gremium, Vorschläge, Implementierungen und Kompromisse zwischen vielen Beteiligten.

Die Stabilität förderte den industriellen Einsatz. Zugleich verfestigte sich in den 2000er-Jahren der Ruf von C++ als schwierige Sprache: manuelle Speicherverwaltung, ungültige Zeiger, Lecks, komplexe Syntax und schwer verständliche Template-Diagnosen waren häufige Kritikpunkte.

C++11 und das moderne C++

Der nächste große Wendepunkt kam 2011. C++11 war so umfassend, dass man üblicherweise von einer neuen Ära des modernen C++ spricht.

Zu den wichtigen Neuerungen gehörten:

• Lambdas;
• Typinferenz mit auto;
• nullptr;
• bereichsbasierte for-Schleifen;
• standardisierte Smart Pointer;
• Rvalue-Referenzen und Move-Semantik;
• constexpr;
• variadische Templates;
• bessere Unterstützung für Nebenläufigkeit.

Diese Funktionen verkürzten nicht nur Code, sondern veränderten empfohlene Praktiken.

Die Move-Semantik ermöglicht beispielsweise, Ressourcen eines nicht mehr benötigten Objekts zu übertragen, statt sie zu kopieren. Smart Pointer wie std::unique_ptr und std::shared_ptr machen zusammen mit RAII Eigentum und Objektlebensdauer klarer ausdrückbar.

Modernes C++ verlangt daher weniger manuelle Verwaltung jedes einzelnen Ressourcenschritts und setzt stärker auf Abstraktionen mit kontrollierbarer Lebensdauer und vorhersehbaren Kosten.

Ein regelmäßigerer Entwicklungsrhythmus

Nach C++11 etablierte sich ein Standardisierungszyklus von ungefähr drei Jahren.

C++14 verfeinerte viele Neuerungen von C++11. C++17 brachte unter anderem std::optional, std::variant, std::filesystem und weitere Verbesserungen für generische Programmierung.

C++20 war ein weiterer großer Schritt mit Concepts, Ranges, Coroutines und Modules. Concepts machen Anforderungen an generische Parameter expliziter, Ranges erleichtern die Komposition von Sequenzoperationen, Coroutines unterstützen bestimmte asynchrone Modelle und Modules sollen unter anderem Organisation und Übersetzung gegenüber dem historischen Header-Modell verbessern.

C++23 führte diese Entwicklung mit weiteren Erweiterungen von Sprache und Bibliothek fort. Die Grundstrategie bleibt gleich: modernisieren, ohne einen harten Bruch mit der riesigen installierten Basis zu erzwingen.

Warum bleibt C++ so komplex?

Mehrere Ursachen verstärken sich gegenseitig.

C++ bewahrt erhebliche historische Kompatibilität, unterstützt verschiedene Paradigmen und legt Repräsentations- und Lebensdauerdetails offen, die andere Umgebungen verbergen. Zugleich soll es sowohl für normale Anwendungen als auch für Systeme geeignet sein, in denen wenige Bytes, Mikrosekunden oder das Fehlen einer verpflichtenden Laufzeitumgebung tatsächlich entscheidend sind.

Diese Freiheit bedeutet, dass es häufig mehrere Lösungen für dasselbe Problem gibt. Altes C++, modernes C++ und C-artiger Code können in derselben Codebasis nebeneinanderstehen.

Moderne Bibliotheken und Richtlinien versuchen deshalb, den gefährlichen Teil dieses Spielraums einzugrenzen: Standardcontainer statt manueller Arrays, wo sinnvoll, RAII für Ressourcen, Smart Pointer bei dynamischem Eigentum sowie ausdrucksstarke Algorithmen und Typen statt wiederholter manueller Verwaltung.

C++, Java und unterschiedliche Kompromisse

Java zeigte in den 1990er-Jahren eine andere Antwort auf manche Probleme von C++-Entwicklern. Es behielt eine vertraute Syntax bei, setzte aber auf virtuelle Maschine und Garbage Collection und schränkte mehrere Low-Level-Mechanismen ein.

C++ bevorzugt direkte Kontrolle über Repräsentation, deterministische Ressourcenverwaltung und möglichst keine verpflichtenden Kosten für ungenutzte Funktionen. Java akzeptiert eine stärker strukturierende Laufzeitumgebung im Austausch für ein einheitlicheres Modell.

Keiner dieser Kompromisse ist universell überlegen; beide Sprachen bedienen teilweise unterschiedliche Anforderungen.

Wo C++ weiterhin wichtig ist

Trotz vieler neuerer Konkurrenten bleibt C++ wichtig, wenn Leistung, Latenz, Speicherkontrolle, native Portabilität oder Hardwarezugriff zählen.

Die Sprache findet sich in Spiele-Engines, Browsern, Datenbanken, Kreativwerkzeugen, wissenschaftlicher Software, eingebetteten Systemen, Low-Latency-Infrastruktur und Bibliotheken, die von anderen Sprachen genutzt werden.

Ihr Alter ist dabei Nachteil und Stärke zugleich. Jahrzehnte an Compilern, Bibliotheken, Fachwissen und industrieller Software bilden ein Ökosystem, das sich nicht auf einmal ersetzen lässt.

Neuere Sprachen, insbesondere Rust, bieten andere Kompromisse bei Speichersicherheit und Systemprogrammierung. Sie können C++ in bestimmten Bereichen Konkurrenz machen, ohne dessen riesige Softwarebasis obsolet zu machen.

Was die Geschichte von C++ zeigt

C++ entwickelte sich nicht geradlinig von einer alten zu einer völlig neu entworfenen Sprache. Es wuchs in Schichten: C with Classes, Objektorientierung, Templates, STL, Standardisierung, modernes C++ und schließlich ein regelmäßiger Zyklus neuer Standards.

Manche dieser Schichten erhöhen die Komplexität. Andere liefern gerade die Abstraktionen, mit denen ältere Praktiken durch sichereren und ausdrucksstärkeren Code ersetzt werden können, ohne die Eigenschaften aufzugeben, die C++ ursprünglich wertvoll machten.

Seine Langlebigkeit beruht deshalb auf einem ungewöhnlichen Gleichgewicht: genug verändern, um relevant zu bleiben, aber nicht so viel, dass die Sprache mit der bereits von ihr getragenen Welt bricht.

Zeitleiste

• 1979: Bjarne Stroustrup beginnt C with Classes bei Bell Labs.
• 1983: die Sprache erhält den Namen C++.
• 1985: erste Ausgabe von The C++ Programming Language und erste kommerzielle Verbreitung.
• Ende der 1980er–1990er: Entwicklung von Templates und generischer Programmierung.
• 1990er: Alexander Stepanovs STL fließt in die Standardisierung ein.
• 1998: erster ISO-Standard, C++98.
• 2003: korrigierende Revision C++03.
• 2011: C++11 eröffnet die Ära des modernen C++.
• 2014: C++14.
• 2017: C++17.
• 2020: C++20 bringt unter anderem Concepts, Ranges, Coroutines und Modules.
• 2023: C++23 setzt die Entwicklung fort.
• Heute: C++ entwickelt sich im ISO-Prozess weiter und bleibt in leistungskritischer Software weit verbreitet.

Häufige Fragen

Ist C++ einfach eine objektorientierte Version von C?

Nein. Objektorientierung war in der Frühgeschichte wichtig, doch Templates, STL, RAII und generische Programmierung wurden ebenso prägend. C++ ist eine Mehrparadigmensprache.

Warum bleibt C++ mit C kompatibel?

C++ wurde als pragmatische Weiterentwicklung von C entworfen und profitierte von dessen Ökosystem. Diese Kontinuität erleichterte die Einführung. Die Kompatibilität ist allerdings nicht vollständig: Gültiger C-Code ist nicht zwangsläufig gültiger C++-Code.

Was bedeutet „modernes C++“?

Gemeint sind meist Praktiken und Funktionen ab C++11: konsequentes RAII, Standardcontainer und -algorithmen, Smart Pointer, Move-Semantik, Lambdas und weitere Werkzeuge für ausdrucksstärkeren und sichereren Code.

Warum schreibt C++ keine Garbage Collection vor?

Die Sprache bevorzugt deterministische Ressourcenkontrolle und will nicht jedem Programm die Kosten eines Collectors oder einer bestimmten Laufzeitumgebung auferlegen. RAII, Container und Smart Pointer automatisieren viel Ressourcenverwaltung ohne verpflichtende Garbage Collection.

Ist C++ neben Rust und neueren Sprachen noch relevant?

Ja. Ökosystem, Leistung, native Portabilität und die enorme bestehende Softwarebasis bleiben große Stärken. Rust bietet andere Garantien für Speichersicherheit und ist für manche neuen Systemprojekte eine wichtige Alternative, doch beide Sprachen existieren in vielen Bereichen nebeneinander.

Warum entfernt C++ bei seiner Weiterentwicklung nicht mehr alte Funktionen?

Weil die Kompatibilität mit jahrzehntealter Software einen hohen Wert besitzt. Das Standardisierungsgremium bevorzugt häufig neue, bessere Mechanismen und veränderte Empfehlungen, statt große Mengen bestehenden Codes abrupt ungültig zu machen.