C++ Programmieren Grundlagen

Einleitung

Dieses Seminar vermittelt die fundamentalen Konzepte der Programmiersprache C++. Teilnehmer erlernen die prozedurale Syntax, den Umgang mit der Speicherverwaltung (Zeiger und Referenzen) sowie die objektorientierte Programmierung (OOP) inklusive Vererbung, Polymorphie und Operatorüberladung. Ziel ist es, ein solides Verständnis für die Entwicklung robuster und performanter C++ Anwendungen zu schaffen.

Zielgruppe / Voraussetzung

Zielgruppe: Angehende Softwareentwickler, Systemprogrammierer, Ingenieure und Umsteiger aus anderen Programmiersprachen.
Voraussetzung: Allgemeines technisches Verständnis. Erste Programmiererfahrungen (z. B. in Skriptsprachen) sind hilfreich, aber nicht zwingend erforderlich.

Detaillierte Inhalte

Einführung und Entwicklungsumgebung

Historie und Eigenschaften von C++ (Kompilierung vs. Interpretation)
Der Build-Prozess: Präprozessor, Compiler, Linker
Einrichtung der Entwicklungsumgebung (z. B. Visual Studio, CLion, GCC/Clang)
Aufbau eines C++ Programms: Die main()-Funktion und Namespaces (std)
Standard-Ein-/Ausgabe mit Streams (std::cout, std::cin, std::endl)

Variablen, Datentypen und Operatoren

Primitive Datentypen (int, char, float, double, bool)
Typ-Modifizierer und Konstanten (const, constexpr)
Automatische Typableitung mit auto
Operatoren: Arithmetisch, relational, logisch und bitweise
Typumwandlung (Type Casting): static_cast im Vergleich zum C-Style Cast

Kontrollstrukturen und Ablaufsteuerung

Bedingte Anweisungen: if, else if, else
Mehrfachverzweigungen: Das switch-Statement
Schleifenkonstrukte: while, do-while, for
Bereichsbasierte Schleifen (Range-based for-loop)
Schleifensteuerung (break, continue)

Funktionen und Modularisierung

Definition, Deklaration und Funktionsprototypen
Parameterübergabe: Call-by-Value vs. Call-by-Reference
Rückgabewerte und der Datentyp void
Funktionsüberladung (Function Overloading)
Inline-Funktionen zur Performance-Optimierung
Standardwerte (Default-Parameter) für Funktionen

Speicherverwaltung, Zeiger und Referenzen

Konzept des Arbeitsspeichers: Stack vs. Heap
Zeiger (Pointers): Deklaration, Adressoperator (&) und Dereferenzierung (*)
Referenzen (&): Unterschiede und Vorteile gegenüber Zeigern
Dynamische Speicherverwaltung: new und delete
Fehlervermeidung: Memory Leaks und Einführung in Smart Pointers (std::unique_ptr)

Komplexe Datenstrukturen und Strings

Statische Arrays (C-Style) vs. std::array
Dynamische Arrays: Einführung in std::vector
Zeichenketten: C-Strings (char[]) vs. die std::string-Klasse
Gruppierung von Daten mit Strukturen (struct)
Aufzählungstypen: enum und die typsichere Variante enum class

Objektorientierte Programmierung (OOP) – Einstieg

Klassen und Objekte definieren
Datenkapselung und Sichtbarkeits-Modifizierer (public, private, protected)
Konstruktoren (Standard, Parametrisiert) und Destruktoren
Initialisierungslisten (Member Initializer Lists)
Trennung von Deklaration (Header-Dateien .h/.hpp) und Implementierung (.cpp)

OOP – Vererbung und Polymorphie

Vererbungshierarchien entwerfen: Basis- und abgeleitete Klassen
Zugriff auf Basisklassen-Member und Konstruktor-Verkettung
Methoden überschreiben: virtual und override
Polymorphie über Basisklassen-Zeiger und -Referenzen
Abstrakte Klassen und rein virtuelle Funktionen (Interfaces)
Virtuelle Destruktoren — warum sie bei Vererbung Pflicht sind
Vererbung gezielt begrenzen mit final

OOP – Operatorüberladung und Kopiersemantik

Operatoren überladen: arithmetische und Vergleichs-Operatoren
Member-Funktionen vs. freie Funktionen (friend)
Stream-Operatoren (<<, >>) für eigene Klassen
Kopierkonstruktor und Zuweisungsoperator verstehen
Die "Rule of Three" — wann eigene Kopiersemantik nötig ist

Fehlerbehandlung (Exception Handling)

Konzepte der Ausnahmebehandlung
try, catch und throw Blöcke implementieren
Standard-Exceptions der C++ Bibliothek (<stdexcept>) nutzen