Zum Inhalt springen
Lernsafari

C++ lernen: Einstieg, moderne Standards und Klassiker-Bücher

Von der Lernsafari-Redaktion Stand 10 Minuten Lesezeit

Aufgeräumter Schreibtisch mit Laptop, auf dem Bildschirm abstrakte Codeblöcke mit geschweiften Klammern, daneben ein Notizbuch mit einer Skizze aus Kästchen und Pfeilen, eine kleine Platine und ein Gamecontroller

C++ ist schwerer als Python. Das sagen wir gleich vorweg, weil es dir Frust erspart. Wer C++ lernen will, bekommt es mit strengen Fehlermeldungen beim Übersetzen zu tun, mit Datentypen, die du selbst festlegst, und mit Speicher, um den sich niemand automatisch kümmert. Der wichtigste Unterschied zu Python: Eine Garbage Collection, die nicht mehr benötigten Speicher selbst aufräumt, gibt es nicht. Dafür bekommst du eine Programmiersprache, in der bekannte Spiele-Engines und Firmware für Mikrocontroller geschrieben sind, also Software, bei der jede Millisekunde zählt.

Konkret heißt das: Wenn du Spiele oder schnelle Desktop-Anwendungen bauen willst, an eingebetteten Systemen arbeitest oder verstehen möchtest, was der Rechner unter der Haube tut, lohnt sich der Aufwand. Willst du nur Daten auswerten oder Webseiten bauen, gibt es leichtere Wege. Für Unternehmenssoftware und Backends ist Java als Einstieg die naheliegende Alternative. Unsicher? Dann hilft dir zuerst unser Ratgeber Welche Programmiersprache lernen?.

Dieser Ratgeber führt dich in sieben Schritten anhand von Beispielen durch modernes C++ im Standard C++20. Jedes Beispiel haben wir mit Apple clang 16 und dem Schalter -std=c++20 übersetzt und ausgeführt. Die Ausgaben stehen direkt unter dem Code.

Schritt 1: Compiler einrichten

Ein Compiler übersetzt deinen Quelltext in ein Programm, das der Rechner ausführen kann. Weit verbreitet sind GCC mit dem Befehl g++, Clang mit clang++ und MSVC von Microsoft in Visual Studio. Für den Einstieg reicht einer davon, am besten der, den dein System ohnehin anbietet.

System Werkzeug So kommst du dran
macOS clang++ xcode-select --install im Terminal installiert die Command Line Tools
Linux (Debian, Ubuntu) g++ sudo apt install g++
Windows Visual Studio Community im Installer die Arbeitsauslastung „Desktopentwicklung mit C++“ wählen

Der Haken auf dem Mac: g++ ist dort nur ein anderer Name für Clang. Das stört nicht, du solltest es nur wissen, wenn eine Fehlermeldung anders aussieht als im Tutorial. Als Editor genügt zunächst Visual Studio Code mit der C++-Erweiterung, eine schlanke Anwendung, die du auch für andere Sprachen verwenden kannst. Unter Windows bringt Visual Studio den Debugger gleich mit.

Schritt 2: Das erste Programm

Das klassische erste Beispiel gibt „Hallo Welt“ aus, unseres grüßt die Lernsafari. Jedes C++-Programm braucht genau eine Funktion main, dort startet die Ausführung. Lege eine Datei hallo.cpp an:

#include <iostream>

int main() {
    std::cout << "Hallo, Lernsafari!\n";
    return 0;
}

Übersetzen und zum Ausführen des Programms starten:

clang++ -std=c++20 -Wall -Wextra hallo.cpp -o hallo
./hallo
Hallo, Lernsafari!

#include <iostream> holt die Ein- und Ausgabe aus der Standardbibliothek. std::cout schreibt auf den Bildschirm, std:: ist der Namensraum der Standardbibliothek. Die Schalter -Wall -Wextra lassen dich mehr Warnungen sehen. Gewöhn dir das von Tag eins an, denn so fallen viele Fehler auf, bevor das Programm überhaupt läuft.

In vielen Tutorials steht statt '\n' ein std::endl. Das bricht die Zeile ebenfalls um, leert aber zusätzlich den Ausgabepuffer und ist deshalb etwas langsamer. Ab hier lassen wir die #include-Zeilen weg, um Platz zu sparen. Welche Header ein Beispiel braucht, steht als Kommentar in der ersten Zeile. Zum Ausführen schreibst du sie als #include <…> an den Anfang.

Schritt 3: Typen und Referenzen

In C++ hat jede Variable einen festen Typ: int für ganze Zahlen, double für Kommazahlen, char für ein einzelnes Zeichen wie 'B', std::string für Text. Mit auto ermittelt C++ ihn selbst. Wichtiger für die ersten Wochen ist die Referenz, in der Syntax mit & geschrieben. Sie ist ein zweiter Name für eine vorhandene Variable.

// Header: <iostream>, <string>

void verdopple(int& zahl) {      // Referenz: verändert das Original
    zahl *= 2;
}

int main() {
    int punkte = 21;              // Typ int: ganze Zahl
    double preis = 19.99;
    char note = 'B';
    std::string spieler = "Ada";
    auto anzahl = 3;              // auto: der Compiler leitet int ab

    verdopple(punkte);
    const std::string& ansicht = spieler;   // Referenz ohne Kopie, nur lesen

    std::cout << spieler << " hat " << punkte << " Punkte, Note " << note << '\n'
              << ansicht.size() << " Buchstaben, " << anzahl * preis << " Euro\n";
}
Ada hat 42 Punkte, Note B
3 Buchstaben, 59.97 Euro

verdopple arbeitet direkt auf der Variablen des Aufrufers. Deshalb steht danach 42 in punkte. Ohne & bekäme die Funktion nur eine Kopie des Werts. Mit const std::string& übergibst du umfangreiche Objekte, ohne sie zu kopieren und ohne sie ändern zu können. Diese Form wirst du in fast jedem Programm sehen.

Schritt 4: Klassen und RAII

Eine Klasse bündelt Daten und Funktionen, sie ist die Grundlage der objektorientierten Programmierung in C++. Später lernst du auch, Operatoren wie + oder == für eigene Klassen zu definieren. Solche überladenen Operatoren verwenden auch std::string und std::vector. Der Konstruktor läuft beim Anlegen eines Objekts, der Destruktor (mit ~ davor) beim Verlassen seines Gültigkeitsbereichs. Auf diesem Verhalten beruht RAII, kurz für „Resource Acquisition Is Initialization“: Wer eine Ressource öffnet, gibt sie im Destruktor wieder frei.

// Header: <iostream>, <string>, <utility>

class Protokoll {
public:
    explicit Protokoll(std::string pfad) : pfad_(std::move(pfad)) {
        std::cout << "öffne " << pfad_ << '\n';
    }
    ~Protokoll() {
        std::cout << "schließe " << pfad_ << '\n';
    }
private:
    std::string pfad_;
};

int main() {
    Protokoll a{"spielstand.txt"};
    {
        Protokoll b{"level-2.txt"};
        std::cout << "arbeite mit beiden Dateien\n";
    }   // hier endet der Block, b räumt sich selbst auf
    std::cout << "Ende von main\n";
}
öffne spielstand.txt
öffne level-2.txt
arbeite mit beiden Dateien
schließe level-2.txt
Ende von main
schließe spielstand.txt

Achte auf die Reihenfolge: b wird am Ende des inneren Blocks geschlossen, a erst ganz zum Schluss. Das passiert auch, wenn zwischendurch ein Fehler eine Ausnahme auslöst. Nach demselben Muster gibt modernes C++ Netzwerkverbindungen oder Sperren frei, während das Programm weiterläuft: sobald der Block endet.

Schritt 5: Speicherverwaltung mit Smart Pointern statt new und delete

Ältere Tutorials legen Objekte mit new an und geben sie mit delete frei. Vergisst du das delete, verliert dein Programm Speicher. Rufst du es zweimal auf, stürzt es im besten Fall ab. Seit C++11 gibt es std::unique_ptr, seit C++14 die Hilfsfunktion std::make_unique. Ein unique_ptr besitzt sein Objekt allein und gibt es automatisch frei, wieder nach dem RAII-Prinzip.

// Header: <iostream>, <memory>, <string>, <vector>

struct Gegner {
    std::string art;
    int leben;
    ~Gegner() { std::cout << art << " freigegeben\n"; }
};

int main() {
    std::vector<std::unique_ptr<Gegner>> welle;
    welle.push_back(std::make_unique<Gegner>("Ork", 30));
    welle.push_back(std::make_unique<Gegner>("Troll", 80));

    auto boss = std::move(welle.back());   // Besitz wandert weiter
    welle.pop_back();

    std::cout << "Boss: " << boss->art << " mit " << boss->leben << " Leben, "
              << "in der Welle: " << welle.size() << '\n';
}   // kein delete nötig
Boss: Troll mit 80 Leben, in der Welle: 1
Troll freigegeben
Ork freigegeben

Kopieren lässt sich ein unique_ptr nicht, nur mit std::move weitergeben. Brauchen mehrere Stellen dasselbe Objekt, nimmst du std::shared_ptr, der mitzählt, wie viele Besitzer es gibt. Für Arrays nimmst du std::array mit fester oder std::vector mit wachsender Länge statt roher C-Arrays. Rohe Zeiger solltest du trotzdem verstehen, denn in älterem Code und in Bibliotheken für Mikrocontroller begegnen sie dir ständig.

Illustration einer Schachtel, die von einer Hand an eine zweite Hand weitergereicht wird, dahinter leere Regalfächer
Ein unique_ptr hat immer genau einen Besitzer. Mit std::move wechselt er die Hand.

Schritt 6: STL-Container und Algorithmen

Die Standardbibliothek, oft STL genannt, liefert fertige Container wie std::vector und std::map und Dutzende Algorithmen, etwa zum Sortieren oder Zählen. Wer sie kennt, schreibt kaum noch eigene Schleifen für Standardaufgaben.

// Header: <algorithm>, <iostream>, <map>, <numeric>, <string>, <vector>

int main() {
    std::vector<int> zeiten{42, 17, 93, 8, 55};

    std::ranges::sort(zeiten);                                  // C++20 Ranges
    int summe = std::accumulate(zeiten.begin(), zeiten.end(), 0);
    auto schnell = std::ranges::count_if(zeiten, [](int t) { return t < 50; });

    std::map<std::string, int> highscore{{"Mia", 1200}, {"Ben", 950}};
    highscore["Lea"] = 1430;

    for (int t : zeiten) std::cout << t << ' ';
    std::cout << "\nSumme: " << summe << ", unter 50: " << schnell << '\n';
    for (const auto& [wer, punkte] : highscore)                 // Structured Bindings, C++17
        std::cout << wer << ": " << punkte << '\n';
}
8 17 42 55 93 
Summe: 215, unter 50: 3
Ben: 950
Lea: 1430
Mia: 1200

std::map hält seine Schlüssel sortiert, deshalb steht Ben vor Lea und Mia. Der Ausdruck in eckigen Klammern hinter count_if ist ein Lambda, eine kleine Funktion ohne Namen. Unsere Empfehlung: Nimm std::vector als Standardcontainer und greif erst zu anderen, wenn du einen Grund hast.

Schritt 7: Templates in Kürze

Templates sind Vorlagen, aus denen beim Übersetzen Funktionen oder Klassen für verschiedene Typen entstehen. Diese generische Programmierung verwenden fast alle Bibliotheken. std::vector<int> ist selbst ein Template. Seit C++20 kannst du mit Concepts festlegen, welche Typen erlaubt sind.

// Header: <concepts>, <iostream>, <string>

template <typename T>
T groesser(T a, T b) {
    return a > b ? a : b;
}

// C++20-Concept: nur ganze Zahlen erlaubt
auto quadrat(std::integral auto x) {
    return x * x;
}

int main() {
    std::cout << groesser(3, 7) << ' ' << groesser(2.5, 1.5) << ' '
              << groesser(std::string{"Apfel"}, std::string{"Birne"}) << ' '
              << quadrat(12) << '\n';
    // quadrat(1.5);  // Fehler beim Kompilieren: double ist kein integral-Typ
}
7 2.5 Birne 144

Nimmst du den Kommentar vor quadrat(1.5) weg, bricht Clang mit der Meldung ab, dass double das Concept integral nicht erfüllt. Früher hätte dich an dieser Stelle eine seitenlange Fehlermeldung erwartet. Für den Einstieg reicht es, solche Vorlagen lesen zu können. Eigene schreibst du später.

Modernes C++: die Standards im Überblick

„Modernes C++“ meint meist alles ab C++11. Seitdem erscheint alle drei Jahre ein neuer Standard der ISO. Die wichtigsten Neuerungen:

Standard Wichtigste Neuerungen
C++11 auto, Range-for, Lambdas, Move-Semantik, nullptr, std::unique_ptr, Threads
C++14 generische Lambdas, std::make_unique, Rückgabetyp-Ableitung, Binärliterale
C++17 Structured Bindings, if constexpr, std::optional, std::variant, std::filesystem
C++20 Concepts, Module, Coroutinen, Ranges, std::format, Drei-Wege-Vergleich <=>
C++23 std::print, std::expected, Modul std, std::flat_map, „deducing this“

C++20 wurde laut cppreference.com im Dezember 2020 veröffentlicht. Lerne mit C++20 als Grundlage: GCC, Clang und MSVC setzen den Standard weitgehend um, und die meisten aktuellen Lehrbücher bauen darauf auf. Was ein Standard genau mitbringt, kannst du auf cppreference.com für jede Version nachlesen und erfahren, ab wann eine Funktion verfügbar ist. Von dieser Möglichkeit wirst du spätestens Gebrauch machen, wenn ein Beispiel aus einem älteren Buch nicht kompiliert.

Lernplan: C++ lernen in 20 Wochen

Arbeite die sieben Schritte wie die Kapitel eines Lehrbuchs nacheinander ab, jedes Kapitel mit einer eigenen Übung. Für Python setzen wir bei etwa fünf Stunden pro Woche rund zwölf Wochen an. Bei C++ planen wir als Richtwert 20 Wochen, weil du dich zusätzlich um Speicher kümmerst und Build-Werkzeuge wie CMake lernst.

Wochen Thema Übung
1–2 Werkzeuge, erstes Programm, Variablen, if, Schleifen Zahlenraten im Terminal
3–5 Funktionen, Referenzen, const, std::string, std::vector Notenrechner
6–9 Klassen, Konstruktoren, Destruktoren, RAII Konto-Klasse mit Protokoll
10–12 Zeiger verstehen, Smart Pointer, Move-Semantik Inventar für ein Spiel
13–15 STL-Container, Algorithmen, Lambdas, Ranges Highscore-Liste speichern und laden
16–17 Templates, Concepts, Ausnahmen eigener kleiner Container
18–20 CMake, Debugger, eigenes Projekt kleines Spiel oder Werkzeug
Infografik zum 20-Wochen-Lernplan für C++ mit sieben Etappen von den Grundlagen bis zum eigenen Projekt
Der Lernplan auf einen Blick: Richtwert etwa fünf Stunden pro Woche.

Willst du danach Spiele bauen, findest du im Lernpfad Spiele programmieren lernen den Vergleich von Unity, Godot und Unreal. Die Unreal Engine wird in C++ programmiert, deine 20 Wochen zahlen sich dort direkt aus.

Zwei Bücher: ein Überblick und ein Klassiker

A Tour of C++ von Bjarne Stroustrup stammt vom Erfinder der Sprache. Die 3. Auflage ist 2022 bei Addison-Wesley erschienen und behandelt C++20 mit Modulen, Concepts, Coroutinen und Ranges, dazu einige Teile der Bibliothek, die erst mit C++23 kamen. Pearson gibt rund 320 Seiten an. Stroustrup schreibt für Leser, die schon programmieren können. Eine Einführung ins Programmieren ist das Buch nicht. Auf Deutsch gibt es bei mitp „Eine Tour durch C++“ (2023), übersetzt nach der 3. Auflage. Unsere Einschätzung: Greif ab Woche 10 dazu, wenn die Grundlagen sitzen.

Modern C++ Design von Andrei Alexandrescu erschien 2001 bei Addison-Wesley. Es zeigt Policy-based Design und Template-Metaprogrammierung, der Code steckt in der Bibliothek Loki. Ehrlich eingeordnet: Das Buch entstand zehn Jahre vor C++11. Das „modern“ im Titel meint den Stand von 2001, manche Technik wie die Typlisten löst man heute mit variadischen Vorlagen aus C++11 kürzer. Am besten passt es zu Fortgeschrittenen, die verstehen wollen, woher viele Template-Tricks in heutigen Bibliotheken kommen.

Beide Titel findest du mit Kurzporträt in unserem Bücherregal.

Kurz beantwortet

Sollte ich erst C lernen? Nein. Modernes C++ unterscheidet sich im Stil stark von C. Wer mit C anfängt, gewöhnt sich malloc und rohe Zeiger an, die du in C++ meist vermeidest.

Wie lange dauert es, C++ programmieren zu lernen? Für die Grundlagen rechnen wir mit etwa 20 Wochen bei fünf Stunden pro Woche. Sicher wird man in C++ über Jahre, weil die Sprache groß ist.

Welcher Compiler ist der beste für Anfänger? Der, der auf deinem System am leichtesten läuft: Clang auf dem Mac, GCC unter Linux, Visual Studio unter Windows. Entscheidend ist nur, dass er C++20 kann und du die Warnungen einschaltest.

Mehr aus Programmieren lernen