C++ Programmierung für Einsteiger: Schulung modernes C++20/23

Einstieg und Toolchain

• C++ kennenlernen: Einsatzfelder von Systemsoftware bis Hochleistungsrechnen
• Was C++ ausmacht: Wertsemantik, Abstraktion ohne Laufzeitkosten, deterministische Ressourcen
• Sprachstandards von C++11 bis C++23 und was „modernes C++“ bedeutet
• Die C++-Toolchain: Präprozessor, Compiler, Linker – GCC, Clang und MSVC
• Projekte mit CMake beschreiben, CMake-Presets für Debug- und Release-Builds
• Xcode unter macOS: Apple Clang, Projekt aus CMake erzeugen, Debugger
• Visual Studio mit MSVC: Workload „Desktopentwicklung mit C++“, CMake-Ordner öffnen
• Plattformübergreifend arbeiten mit CLion oder VS Code und clangd
• Compilerwarnungen einschalten: -Wall -Wextra -Wpedantic bzw. /W4

Grundlegende Syntax

• Anatomie eines C++-Programms: main, #include, Namensräume
• Anweisungen und Ausdrücke, Seiteneffekte und Sequenzierung
• Bezeichner, Namenskonventionen und reservierte Namen
• Variablen definieren: einheitliche Initialisierung mit {}, const und constexpr
• Zeiger: Adresse, Dereferenzierung und wann ein roher Zeiger noch angemessen ist
• Referenzen als Alias und const& für Parameter
• Von primitiven Arrays zu std::array und std::vector
• C-Strings mit char* lesen können, im eigenen Code std::string verwenden
• Bedingungen mit if, if mit Initialisierer und else if-Ketten
• Mehrfachverzweigung mit switch und [[fallthrough]]
• Schleifen mit while und do … while
• Zählschleifen mit for und typische Off-by-one-Fehler
• Bereichsbasierte for-Schleife über Container und Views
• Strukturen mit Standardwerten und Designated Initializers (C++20)
• Funktionen und Klassen als erster Überblick vor der Vertiefung
• Ausgabe auf stdout: std::cout im Vergleich zu std::print aus C++23

Datentypen

• Fundamentale Typen im Überblick und statische Typisierung in C++
• Integer-Typen, Vorzeichen und Überlauf als undefiniertes Verhalten
• Integer-Größen plattformabhängig: sizeof und std::numeric_limits
• Ganzzahlen fester Breite aus <cstdint>: std::int32_t, std::uint8_t
• Fließkommatypen, Rundungsfehler und Vergleiche mit Toleranz
• Zeichentypen char und char8_t, UTF-8-Literale und ihre Tücken
• Escape-Sequenzen und Raw-String-Literale R"(…)"
• Strukturierte Daten mit struct, std::pair, std::tuple und Structured Bindings
• Bitfelder und std::bitset für kompakte Schalter und Flags
• Aufzählungen: enum class mit eigenem Gültigkeitsbereich statt klassischem enum
• Unions verstehen und durch std::variant mit std::visit ersetzen
• Typaliase mit using statt typedef, auch für Templates
• Der Typ void, void* und warum moderner C++-Code ihn kaum noch braucht
• Typableitung mit auto und decltype – wo sie hilft und wo sie verschleiert
• Eindeutige Nullzeigerkonstante nullptr statt NULL oder 0

Operatoren und Typumwandlung

• Gemeinsame Operatoren: Arithmetik, Ganzzahldivision und Rest mit %
• Zusammengesetzte Zuweisungen wie += und <<=
• Inkrement und Dekrement in Präfix- und Postfix-Form
• Relationale Operatoren und der Drei-Wege-Vergleich <=> (C++20)
• &&, || und ! mit Kurzschlussauswertung
• Bitweise Operatoren und Shifts, Hilfsfunktionen aus <bit> wie std::popcount
• Den ternären Bedingungsoperator ?: lesbar einsetzen
• new und delete verstehen – und durch std::make_unique ersetzen
• Typumwandlung mit static_cast, const_cast und reinterpret_cast statt C-Cast
• Verengende Umwandlungen erkennen: Brace-Initialisierung und -Wconversion
• sizeof, alignof und das Speicherlayout von Strukturen
• Laufzeittypinformation mit typeid und dynamic_cast
• Vorrang und Auswertungsreihenfolge – Klammern setzen statt Regeln auswendig lernen

Funktionen

• Überblick: Deklaration, Definition und Aufteilung in Header- und Quelldateien
• Eine Funktion erstellen: Signatur, Rückgabetyp und [[nodiscard]]
• Übergabe als Wert, als const& oder per Move – Faustregeln für Parameter
• Automatische und statische lokale Variablen, Lebensdauer und Initialisierung
• Mehrere Rückgabewerte über Strukturen, std::optional und Structured Bindings
• Fehler als Rückgabewert mit std::expected (C++23)
• Funktionszeiger, Lambdas mit Captures und std::function
• Funktionsnamen überladen und Standardargumente festlegen
• Variable Argumentanzahl: va_list in Altcode, Variadic Templates und std::initializer_list
• Rekursion am Beispiel von Baumstrukturen und ihre Grenzen
• constexpr- und consteval-Funktionen für Berechnungen zur Übersetzungszeit

Klassen, Objekte und RAII

• Klassen und Objekte: Kapselung, Invarianten, public und private
• Eine Klasse definieren: Deklaration im Header, Implementierung in der Quelldatei
• Datenelemente (Eigenschaften) mit Standardinitialisierung im Klassenkörper
• Methoden, const-Elementfunktionen und static-Elemente
• Konstruktoren, Initialisierungslisten, delegierende Konstruktoren und explicit
• Destruktoren und RAII: Dateien, Sperren und Speicher an Objekte binden
• Kopieren und Verschieben, Move-Semantik und die Regel der Null
• Operatoren als Elementfunktionen überladen: +=, [], ()
• Operatoren als freie Funktionen, operator<< für die Ausgabe eigener Typen
• Vergleiche per = default generieren lassen: operator== und operator<=>
• Vererbung, virtuelle Funktionen, override und final im Überblick

Speicher und Smart Pointer

• Stack und Heap, automatische und dynamische Lebensdauer von Objekten
• Exklusives Eigentum mit std::unique_ptr und Übergabe per std::move
• Geteiltes Eigentum mit std::shared_ptr, Zyklen auflösen mit std::weak_ptr
• Hängende Referenzen und ungültig gewordene Iteratoren erkennen
• std::span als Sicht auf zusammenhängende Daten statt Zeiger plus Länge

Templates und Concepts

• Templates verstehen: generischer Code und Instanziierung durch den Compiler
• Template-Funktionen und die Ableitung der Template-Argumente
• Klassentemplates und Class Template Argument Deduction (CTAD)
• Anforderungen an Typparameter mit Concepts und requires formulieren
• Abgekürzte Funktionstemplates mit auto-Parametern und Standard-Concepts

Die Standardbibliothek

• Aufbau der Standardbibliothek und die wichtigsten Header im Überblick
• Datei-E/A: Textdateien lesen und schreiben mit std::ifstream und std::ofstream
• Binäre Dateien mit std::ios::binary, read/write und Byte-Reihenfolge
• Dateiverwaltung mit std::filesystem: Pfade, Verzeichnisse, Kopieren, Löschen
• Unformatierte Zeichen-E/A mit get, put und std::getline
• Formatierte Zeichen-E/A mit std::format und std::print
• Formatangaben für Breite, Genauigkeit, Ausrichtung und eigene std::formatter
• Mit Ganzzahlen und reellen Zahlen arbeiten: <cmath>, std::numbers, std::from_chars
• String-Funktionen von std::string: find, substr, starts_with, contains
• Systemfehler behandeln: errno, std::error_code und std::system_error

STL: Container, Algorithmen und Ranges

• Überblick über die STL: Container, Iteratoren und Algorithmen
• Vektoren: Größe und Kapazität, reserve, emplace_back, Elementzugriff
• Assoziative Container: std::map, std::unordered_map und std::set
• Zeichenketten in der STL: std::string und std::string_view richtig kombinieren
• I/O-Streams: Stream-Zustände, Fehlerbits und std::stringstream
• Algorithmen aus <algorithm> zum Sortieren, Suchen und Zählen
• Ranges und Views: std::views::filter, transform und take verketten
• Ergebnisse einer Pipeline mit std::ranges::to in einen Container übernehmen
• Lambdas als Prädikate und Projektionen in Range-Algorithmen

Behandlung von Ausnahmen

• Ausnahmen werfen und fangen: throw, try und catch per Referenz
• Die Ausnahmehierarchie der Standardbibliothek und eigene Ausnahmeklassen
• Ausnahmesicherheit durch RAII, noexcept und Garantiestufen
• Ausnahme oder std::expected: Kriterien für die Fehlerstrategie eines Projekts

Testen und Codequalität

• Unit-Tests mit GoogleTest, eingebunden über CMake und ausgeführt mit CTest
• AddressSanitizer und UndefinedBehaviorSanitizer im Debug-Build einschalten
• clang-tidy mit den Prüfgruppen modernize-* und cppcoreguidelines-*
• Einheitlicher Codestil mit clang-format und einer .clang-format-Datei
• Bibliotheken einbinden mit FetchContent oder vcpkg
• Ausblick: Module mit import std; und Neuerungen aus C++26

C++ mit Coding-Agenten

• Agent baut nach jeder Änderung mit dem CMake-Preset und lässt Tests unter ASan/UBSan laufen
• C++ Core Guidelines und .clang-tidy im Repository als verbindliche Regeln für den Agenten
• Vorschläge mit rohem new, C-Casts oder reinterpret_cast gezielt zurückweisen
• Lange Template-Fehlermeldungen vom Agenten erklären und mit Concepts entschärfen lassen
• Vor dem Umbau einer Klasse auf RAII zuerst GoogleTest-Fälle vom Agenten schreiben lassen

Praxisprojekt: Turnierverwaltung für einen Schachclub

• Spieler:innen, Partien und Runden als Klassen mit std::vector und std::map modellieren
• Paarungen und Tabelle mit Range-Algorithmen berechnen, Ausgabe mit std::print
• Turnierstand als Datei speichern und laden, Fehler mit std::expected melden
• Abnahme: CMake-Build mit GoogleTest, Sanitizer-Lauf und clang-tidy ohne Befund

Lernziele

• Sie richten eine C++-Toolchain mit CMake, Compilerwarnungen und Sanitizern ein und bauen Projekte reproduzierbar
• Sie verwalten Ressourcen mit RAII, std::unique_ptr und Standardcontainern statt mit new und delete
• Sie entwerfen Klassen mit Konstruktoren, Destruktoren, Move-Semantik und überladenen Operatoren
• Sie schreiben generische Funktionen und Klassen mit Templates und Concepts
• Sie verarbeiten Daten mit STL-Containern, Algorithmen und Ranges und geben sie mit std::format aus
• Sie behandeln Fehler mit Ausnahmen oder std::expected und sichern Code mit Unit-Tests ab

Zielgruppe

• Einsteiger:innen in C++, auch mit ersten Programmiererfahrungen in einer anderen Sprache
• C-Programmierer:innen, die auf modernes C++ umsteigen
• Umsteiger:innen aus Java oder C#, die Wertsemantik und manuelle Ressourcenkontrolle verstehen wollen