C++-Dokumentation
Kompakte, beispielorientierte C++-Referenz. Konzept lesen, Code ansehen, dann in einem Coddy-Lernweg üben.
Geführten C++-Lernweg startenErste Schritte
- Was ist C++Was C++ wirklich ist, warum es direkt zu nativem Maschinencode kompiliert und welche Arten von Hochleistungssoftware damit gebaut werden.
- C++ installierenSo installierst du einen C++-Compiler (GCC, Clang oder MSVC), wählst eine Toolchain für dein Betriebssystem und prüfst über die Kommandozeile, ob er funktioniert.
- C++ kompilierenWie C++ aus .cpp-Quellcode eine native ausführbare Datei macht: mit g++ (oder clang++/MSVC) kompilieren, das Binary ausführen und Compiler-Fehler lesen, wenn etwas schiefgeht.
- C++-SyntaxDie grundlegenden Syntaxregeln eines C++-Programms - Anweisungen und Semikolons, Blöcke in geschweiften Klammern, die main-Funktion und wie die Ausgabe funktioniert - erklärt anhand eines ersten Programms.
- KommentareWie man in C++ Kommentare schreibt - einzeilige //-Notizen und mehrzeilige /* */-Blöcke - sowie wie man Code auskommentiert, warum Blockkommentare sich nicht verschachteln lassen und was einen Kommentar wertvoll macht.
Variablen & Typen
- VariablenWie Variablen in C++ funktionieren - die Deklaration mit einem Typ, der Unterschied zwischen Zuweisung und Initialisierung, die Klammer-Initialisierung, Namensregeln und der Gültigkeitsbereich, der entscheidet, wo eine Variable lebt und stirbt.
- DatentypenEin praktischer Rundgang durch die grundlegenden Datentypen von C++ - Ganzzahlen, Gleitkomma, char und bool - sowie Größen, signed vs. unsigned, Literale und Suffixe, Überlauf und wie man den richtigen Typ wählt.
- auto-SchlüsselwortWie das Schlüsselwort `auto` den Compiler den Typ einer Variablen für dich ableiten lässt - was es verwirft, wo es glänzt und die Fallstricke, die Anfänger erwischen.
- Konstanten & constWie man in C++ schreibgeschützte Werte mit const deklariert, der Unterschied zwischen const und constexpr, const-Zeiger im Vergleich zu Zeigern auf const sowie const-Memberfunktionen.
- OperatorenLerne die C++-Operatoren kennen - arithmetische, Vergleichs-, logische, Zuweisungs- und Bit-Operatoren - sowie die Fallstricke rund um Ganzzahldivision, Vorrang und Kurzschlussauswertung.
- TypumwandlungWie Typumwandlung in C++ funktioniert: implizite Konvertierungen, die Falle der Ganzzahldivision und die vier benannten Casts (static_cast, const_cast, reinterpret_cast, dynamic_cast) - mit den Fallstricken, die zu stillem Datenverlust führen.
Kontrollfluss
- if-elseWie man in C++ mit if, else if und else Entscheidungen trifft - Bedingungen, das Verketten von Zweigen, Verschachtelung, der ternäre Operator, if mit Initialisierer und die Stolperfallen, über die viele stolpern.
- switchDie switch-Anweisung in C++ erklärt: case-Marken, break und Fall-Through, der default-Zweig, das Zusammenfassen von Fällen, switch über Enums und die Fallstricke bei Deklarationen innerhalb von cases.
- for-SchleifeWie man Code mit der C++ for-Schleife wiederholt - der dreiteilige Kopf, hoch- und runterzählen, über Arrays iterieren, verschachteln, break und continue sowie die Off-by-one- und Unsigned-Bugs, die jeden erwischen.
- while-SchleifenDie C++ while-Schleife erklärt: das while, das die Bedingung zuerst prüft, das do-while, das mindestens einmal läuft, Schleifen bis zu einem Sentinel-Wert, break und continue sowie wie man Endlosschleifen vermeidet.
- Range-based forDie C++ range-based for-Schleife erklärt: sauberes Iterieren über Arrays, Vektoren, Strings und Maps, warum du auto& und const auto& verwenden solltest und welche Kopier- und Iterator-Invalidierungs-Fallen du vermeiden musst.
Funktionen
- FunktionenWie man Funktionen in C++ schreibt – die Anatomie aus Rückgabetyp/Name/Parametern, Deklaration vs. Definition, Werte zurückgeben, void-Funktionen und Stolperfallen wie fehlendes return oder vergessene Prototypen.
- FunktionsparameterWie Argumente in C++-Funktionen gelangen - Übergabe per Wert oder per Referenz, const-Referenzen für günstigen Nur-Lese-Zugriff, Standardargumente, Zeiger und die Kopierkosten-Fallen, die Programme unbemerkt verlangsamen.
- ReferenzenC++-Referenzen erklärt: wie das & bei einem Parameter einen Alias erzeugt, warum die Übergabe per Referenz Kopien vermeidet und einer Funktion erlaubt, die Variablen des Aufrufers zu ändern, und wann man const& und Referenzen statt der Rückgabe per Wert einsetzt.
- FunktionsüberladungDie Funktionsüberladung in C++ erlaubt es mehreren Funktionen, sich einen Namen zu teilen, solange sich ihre Parameterlisten unterscheiden. Lerne, wie die Überladungsauflösung die passende Variante wählt, warum der Rückgabetyp allein nicht zählt und welche Fallen bei Mehrdeutigkeit und Standardargumenten du vermeiden solltest.
- LambdasSchreibe mit C++-Lambdas kleine Inline-Funktionen direkt an Ort und Stelle - die Syntax, wie Captures funktionieren, wann du `mutable` brauchst und die Falle des hängenden Captures, in die jeder tappt.
Zeiger & Speicher
- ZeigerC++-Zeiger von Grund auf erklärt: einen Zeiger deklarieren, die Operatoren & (Adresse von) und * (Dereferenzierung), nullptr, Zeiger auf Arrays sowie die Fallen mit hängenden und nicht initialisierten Zeigern, die zu Abstürzen führen.
- Referenzen vs. ZeigerEin praktischer Vergleich von Referenzen und Zeigern in C++ - was sie gemeinsam haben, wo sie sich unterscheiden (Neubindung, Null, Arithmetik) und eine klare Regel, zu welchem man im Alltagscode greift.
- Dynamischer SpeicherWie man zur Laufzeit mit `new` Speicher reserviert, ihn mit `delete` freigibt und die Lecks, hängenden Zeiger und doppelten Freigaben vermeidet, die mit der manuellen Verwaltung des Heaps einhergehen.
- Smart PointerSmart Pointer besitzen Heap-Speicher und geben ihn automatisch frei. Lerne `unique_ptr`, `shared_ptr`, `make_unique` und `make_shared` kennen – und warum du fast nie wieder `new`/`delete` schreiben solltest.
Strings & E/A
- StringsWie man `std::string` in C++ verwendet - Text sicher aufbauen, zusammenfügen, durchsuchen und zerschneiden, und warum man für echte Arbeit fast nie ein rohes `char*` will.
- Ein- und AusgabeWie Konsolen-E/A in C++ funktioniert: Ausgabe mit cout, Einlesen mit cin, der klassische Zeilenumbruch-Bug bei getline nach cin und wie man sich erholt, wenn die Eingabe fehlschlägt.
- String-StreamsWie man std::stringstream, istringstream und ostringstream verwendet, um Text zu parsen, Zeichenketten an Leerzeichen aufzuteilen, zwischen Zeichenketten und Zahlen zu konvertieren und formatierte Zeichenketten im Speicher zu erstellen.
STL-Container
- ArraysC++-Roh-Arrays erklärt: wie man sie deklariert und initialisiert, sicher indiziert, mit ihrer Größe durchläuft, die Array-zu-Zeiger-Decay-Falle und warum std::array und vector ihnen meist überlegen sind.
- vectorstd::vector ist das größenveränderliche Array von C++ - der Container, zu dem du standardmäßig greifen solltest. Lerne, wie man einen vector erstellt, darauf zugreift, ihn wachsen lässt und durchläuft, sowie die Fallstricke der Iterator-Invalidierung und des Zugriffs außerhalb der Grenzen.
- mapDie C++ std::map erklärt – ein nach Schlüssel sortierter Schlüssel-Wert-Container mit logarithmischer Suche. Einfügen, finden, iterieren und die klassische operator[]-Falle vermeiden, die heimlich Schlüssel anlegt.
- unordered_mapLerne std::unordered_map in C++ - das auf einer Hashtabelle basierende Geschwister von map, das Einfügen und Nachschlagen im Durchschnitt in O(1) bietet. Behandelt die grundlegenden Operationen, die Auto-Insert-Falle von [], count im Vergleich zu find und wann du es einer geordneten map vorziehst.
- setWie std::set in C++ eindeutige, automatisch sortierte Werte speichert: Einfügen, Mitgliedschaft mit count und find prüfen, in Reihenfolge iterieren und die Unterschiede zwischen set, multiset und unordered_set.
- pair und tupleWie `std::pair` und `std::tuple` zwei oder mehr Werte in einem Objekt bündeln: wie man sie erzeugt, auf die Felder zugreift, Structured Bindings und wofür sich jedes eignet.
- IteratorenWie C++-Iteratoren als verallgemeinerte Zeiger in Container funktionieren - begin() und end(), Dereferenzieren, Vorrücken, die const-/reverse-Varianten sowie die Stolperfallen der Invalidierung und des Dereferenzierens von end(), die zu undefiniertem Verhalten führen.
STL-Algorithmen & Templates
- AlgorithmenNutze die C++-Standardalgorithmen - `find`, `count_if`, `transform`, `accumulate`, `remove` -, um echte Arbeit über Bereiche zu erledigen, ohne Schleifen von Hand zu schreiben, samt der Stolperfallen rund um das Iterator-Paar und das erase-remove-Idiom.
- SortierenSortiere Vektoren und Arrays in C++ mit `std::sort`: Standardreihenfolge, eigene Vergleichsfunktionen, Structs nach einem Feld sortieren und die Strict-Weak-Ordering-Falle, die Abstürze verursacht.
- TemplatesSchreibe den Code einmal und lass ihn mit C++-Templates für jeden Typ funktionieren - Funktions-Templates, Klassen-Templates, Typ-Deduktion und die verwirrenden Compilerfehler, die sie verursachen.
Klassen & Objekte
- KlassenLerne, wie C++-Klassen Daten und Verhalten zu wiederverwendbaren Typen bündeln - Membervariablen und Methoden deklarieren, Objekte erstellen, die Trennung public/private und Fallstricke wie nicht initialisierte Member und der this-Zeiger.
- KonstruktorenEin Konstruktor ist die spezielle Member-Funktion, die ausgeführt wird, wenn ein Objekt erzeugt wird. Lerne Standard-, parametrisierte und Kopierkonstruktoren, Member-Initialisierungslisten und wie du halb initialisierte Objekte vermeidest.
- DestruktorenEin Destruktor läuft automatisch, wenn ein Objekt zerstört wird. Lerne die `~Klassenname()`-Syntax, wann er ausgelöst wird, warum er Ressourcen freigibt, und die Dreier-/Fünferregel.
- VererbungLerne, wie die Vererbung in C++ einer abgeleiteten Klasse erlaubt, eine Basisklasse wiederzuverwenden und zu erweitern: die Syntax, öffentliche vs. private Vererbung, die Reihenfolge von Konstruktoren und Destruktoren sowie Fallstricke wie das Object Slicing.
- Virtuelle FunktionenVirtuelle Funktionen ermöglichen es einem Basisklassen-Zeiger, zur Laufzeit die Methodenversion der abgeleiteten Klasse aufzurufen. Lerne `virtual`, `override`, abstrakte Klassen und warum ein Basis-Destruktor virtuell sein muss.
- OperatorüberladungDie Operatorüberladung in C++ lässt deine eigenen Typen mit eingebauten Operatoren wie +, == und << arbeiten. Lerne die Regeln für Member- vs. Nicht-Member-Funktionen, wie du Vergleichs- und Stream-Operatoren überlädst und welche Fallstricke es rund um Rückgabetypen und den Zuweisungsoperator gibt.
- ZugriffsspezifiziererWie public, private und protected steuern, wer die Member einer Klasse in C++ anfassen darf - die Grundlage der Kapselung, mit Gettern, Settern und dem friend-Notausgang.
- StructsC++-Structs erklärt: wie du zusammengehörige Variablen zu einem einzigen Typ bündelst, Struct-Objekte deklarierst und initialisierst, einem Struct Member-Funktionen und Konstruktoren gibst und worin sich struct wirklich von class unterscheidet.
- enumsLerne C++ Enums: wie man sie deklariert, warum das gekapselte enum class sicherer ist als das einfache enum, eigene zugrunde liegende Werte, switch über Enumeratoren und die Umwandlung von und zu Ganzzahlen.
Fehler & Debugging
- AusnahmenAusnahmen melden Fehler, die eine Funktion lokal nicht behandeln kann. Lerne, wie man `throw` verwendet, welche Standard-Ausnahmetypen es gibt, was die `what()`-Nachricht ist und warum Ausnahmen bei den wirklich wichtigen Fehlern besser sind als Rückgabecodes.
- try-catchUmschließe riskanten Code mit `try`, reagiere im `catch`. Lerne, Ausnahmen per const-Referenz abzufangen, mehrere Handler zu ordnen, `catch (...)` zu nutzen und erneut auszulösen - ohne Ressourcen zu verlieren.
- Undefiniertes VerhaltenUndefiniertes Verhalten (UB) ist Code, für den der C++-Standard keinerlei Regeln festlegt – er kann abstürzen, Daten beschädigen oder scheinbar funktionieren. Lerne die häufigen Ursachen, warum "es lief problemlos" nichts beweist und welche Werkzeuge UB aufspüren.
