C++ Spickzettel

Q: Sollte ich new/delete oder Smart Pointer verwenden?

Bevorzuge Smart Pointer. `std::unique_ptr` und `std::shared_ptr` (über `make_unique`/`make_shared`) geben ihren Speicher automatisch frei, wenn sie den Gültigkeitsbereich verlassen, was die Lecks und Double-Frees verhindert, die mit manuellem `new`/`delete` einhergehen. Greife nur in Low-Level-Code mit einem konkreten Grund zu rohem `new`/`delete`.

Zuletzt aktualisiert 27. Mai 2026

Live im C++-Playground ausprobieren C++ kostenlos lernen

Hello World & Programmaufbau

Die Ausführung beginnt bei main, das ein int zurückgibt.

Element	Code
Einen Header einbinden	`#include <iostream>`
Einstiegspunkt	`int main() { ... }`
Eine Zeile ausgeben	`std::cout << "Hello, World!" << std::endl;`
Eingabe lesen	`std::cin >> x;`
Den std-Namensraum verwenden	`using namespace std;`
Erfolg zurückgeben	`return 0;`
Kommentare	`// line` und `/* block */`

Datentypen

Typ	Beschreibung
`int`	Ganzzahl (meist 32 Bit)
`long` / `long long`	Breitere Ganzzahlen
`float` / `double`	Gleitkommazahlen
`char`	Einzelnes Byte / Zeichen
`bool`	`true` oder `false`
`std::string`	Dynamischer Text aus `<string>`
`auto`	Der Compiler leitet den Typ ab
`std::size_t`	Vorzeichenloser Typ für Größen und Indizes

Variablen & Referenzen

Referenzen sind Aliasse; Zeiger halten Adressen.

Operation	Syntax
Deklarieren & initialisieren	`int x = 5;`
Klammer-Initialisierung	`int x{5};`
Konstante	`const double PI = 3.14159;`
Compilezeit-Konstante	`constexpr int N = 10;`
Referenz (Alias)	`int &r = x;`
Zeiger	`int *p = &x;`
Einen Zeiger dereferenzieren	`*p = 10;`
Typinferenz	`auto y = 3.14;`

Kontrollfluss

Anweisung	Syntax
If / else	`if (x > 0) { ... } else { ... }`
Switch	`switch (n) { case 1: ...; break; default: ...; }`
While-Schleife	`while (i < n) { ... }`
Do-while-Schleife	`do { ... } while (i < n);`
For-Schleife	`for (int i = 0; i < n; i++) { ... }`
Bereichsbasierte For	`for (auto x : vec) { ... }`
Bereichsbasiert per Referenz	`for (auto &x : vec) { ... }`
Break / continue	`break;` verlässt eine Schleife, `continue;` springt zur nächsten Iteration

Funktionen

Operation	Syntax
Eine Funktion definieren	`int add(int a, int b) { return a + b; }`
Kein Rückgabewert	`void greet() { ... }`
Standardargumente	`int pow(int b, int e = 2) { ... }`
Übergabe per Referenz	`void inc(int &x) { x++; }`
Const-Referenz (keine Kopie)	`void print(const std::string &s) { ... }`
Überladung	`int max(int a, int b);` und `double max(double a, double b);`
Lambda	`auto f = [](int x) { return x * 2; };`
Lambda mit Capture	`auto g = [n](int x) { return x + n; };`

Klassen & OOP

Operation	Syntax
Eine Klasse definieren	`class Dog { ... };`
Zugriffsspezifizierer	`public:`, `private:`, `protected:`
Membervariable	`std::string name;`
Konstruktor	`Dog(std::string n) : name(n) {}`
Destruktor	`~Dog() { ... }`
Memberfunktion	`void bark() { ... }`
Ein Objekt erstellen	`Dog d("Rex");`
Vererbung	`class Puppy : public Dog { ... };`
Virtuelle Funktion	`virtual void speak();`

STL-Container

Gängige Container aus der Standardbibliothek.

Container	Verwendung & Beispiel
`std::vector<int>`	Dynamisches Array: `v.push_back(1); v.size();`
`std::string`	Text: `s += "!"; s.length();`
`std::array<int, 3>`	Array fester Größe mit Größeninfo
`std::map<K, V>`	Sortierte Schlüssel-Wert: `m["a"] = 1;`
`std::unordered_map<K, V>`	Hash-Map (schnellere Suche, keine Reihenfolge)
`std::set<T>`	Sortierte eindeutige Werte: `s.insert(5);`
`std::pair<A, B>`	Zwei Werte: `make_pair(1, "x")`
`std::queue` / `std::stack`	FIFO-Queue / LIFO-Stack-Adapter

STL-Algorithmen & Iteratoren

Aus <algorithm>; die meisten erwarten einen begin/end-Iteratorbereich.

Operation	Syntax
Begin- / End-Iteratoren	`v.begin()`, `v.end()`
Sortieren	`std::sort(v.begin(), v.end());`
Absteigend sortieren	`std::sort(v.begin(), v.end(), std::greater<int>());`
Einen Wert finden	`auto it = std::find(v.begin(), v.end(), 5);`
Treffer zählen	`std::count(v.begin(), v.end(), 5);`
Min- / Max-Element	`std::max_element(v.begin(), v.end());`
Einen Bereich summieren	`std::accumulate(v.begin(), v.end(), 0);`
Jedes Element transformieren	`std::transform(v.begin(), v.end(), v.begin(), fn);`

Smart Pointer & modernes C++

Bevorzuge Smart Pointer gegenüber rohem new/delete für automatische Bereinigung.

Feature	Syntax
Eindeutiger Besitz	`auto p = std::make_unique<Dog>("Rex");`
Geteilter Besitz	`auto p = std::make_shared<Dog>("Rex");`
Nicht-besitzende Referenz	`std::weak_ptr<Dog> w = p;`
Move-Semantik	`auto v2 = std::move(v1);`
Nullptr	`int *p = nullptr;`
Strukturierte Bindungen	`auto [key, val] = *it;`
Optionaler Wert	`std::optional<int> maybe;`
Templates	`template <typename T> T add(T a, T b) { return a + b; }`

Die C++-Syntax, STL-Container und modernen Features, die du am häufigsten brauchst, auf einer Seite. Dieser C++-Spickzettel ist eine Schnellreferenz zum Schreiben von C++ - die Datentypen, Referenzen, Klassen, die Container und Algorithmen der Standardbibliothek sowie die Smart Pointer, die rohes new/delete ersetzen.

Alles hier ist Standard-C++ (C++11 und neuer) und kompiliert mit g++ oder clang++. Kopiere, was du brauchst, oder probiere jeden Codeschnipsel live im C++-Playground aus - kein Compiler zu installieren.

C++-Spickzettel FAQ

Ist dieser C++-Spickzettel kostenlos?

Ja. Dieser C++-Spickzettel ist völlig kostenlos, ohne erforderliche Anmeldung. Setze ein Lesezeichen und komm jederzeit wieder, wenn du Syntax, einen STL-Container oder einen Smart Pointer nachschlagen möchtest.

Was ist der Unterschied zwischen einem Zeiger und einer Referenz in C++?

Ein Zeiger ist eine Variable, die eine Adresse hält; er kann null sein, neu zugewiesen werden, um woanders hinzuzeigen, und du dereferenzierst ihn mit *p. Eine Referenz (int &r = x) ist ein Alias für eine bestehende Variable - sie muss bei der Deklaration gebunden werden, kann niemals null sein oder neu gebunden werden und wird wie die Variable selbst verwendet. Verwende Referenzen für sauberere Parameter per Referenz und Zeiger, wenn du optionale oder neu zuweisbare Indirektion benötigst.

Sollte ich new/delete oder Smart Pointer verwenden?

Bevorzuge Smart Pointer. std::unique_ptr und std::shared_ptr (über make_unique/make_shared) geben ihren Speicher automatisch frei, wenn sie den Gültigkeitsbereich verlassen, was die Lecks und Double-Frees verhindert, die mit manuellem new/delete einhergehen. Greife nur in Low-Level-Code mit einem konkreten Grund zu rohem new/delete.

Kann ich C++ online üben?

Ja. Öffne den C++-Playground, um jeden Codeschnipsel aus diesem Spickzettel in deinem Browser zu kompilieren und auszuführen - kein Compiler zu installieren. Wenn du Struktur möchtest, führt dich Coddys kostenloser interaktiver C++-Kurs Schritt für Schritt von Variablen und Schleifen zu Klassen und der STL.

Ist dieser Spickzettel für Anfänger geeignet?

Ja. Er ist von den häufigsten Bausteinen (Typen, Kontrollfluss, Funktionen) hin zu den fortgeschrittenen (die STL und Smart Pointer) gegliedert, sodass du die oberen Abschnitte schon am ersten Tag nutzen und in den Rest hineinwachsen kannst.