C++ Programmieren Grundlagen

Dieses Seminar vermittelt dir in drei Tagen die fundamentalen Konzepte der Programmiersprache C++. Du lernst die prozedurale Syntax, den Umgang mit der Speicherverwaltung (Zeiger und Referenzen, RAII) sowie die objektorientierte Programmierung (OOP) inklusive Vererbung, Polymorphie, Kopier-/Move-Semantik und Operatorüberladung. Am Ende hast du ein solides Verständnis für die Entwicklung robuster und performanter C++-Anwendungen.

Für wen ist dieses Seminar

Angehende Softwareentwickler, Systemprogrammierer, Ingenieure und Umsteiger aus anderen Programmiersprachen.

Das Angebot richtet sich an Unternehmen, Behörden und Selbstständige.

Was du mitbringen solltest

Allgemeines technisches Verständnis. Erste Programmiererfahrungen (z. B. in Skriptsprachen) sind hilfreich, aber nicht zwingend erforderlich. Wer noch keinerlei Programmiererfahrung hat, findet in C Programmieren Einführung einen passenden vorbereitenden Einstieg in prozedurale Konzepte.

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)
Projekte mit CMake konfigurieren und bauen
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 (Memory Management), 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
RAII (Resource Acquisition Is Initialization) als Grundprinzip der Ressourcenverwaltung in C++
Fehlervermeidung: Memory Leaks und Smart Pointers (std::unique_ptr, std::shared_ptr)

Komplexe Datenstrukturen und Strings

Statische Arrays (C-Style) vs. std::array
Dynamische Arrays: Einführung in std::vector
Weitere STL-Container im Überblick: std::map, std::set, std::list
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 – Kopier- und Move-Semantik, Operatorüberladung

Operatoren überladen: arithmetische und Vergleichs-Operatoren
Member-Funktionen vs. freie Funktionen (friend)
Stream-Operatoren (<<, >>) für eigene Klassen
Kopierkonstruktor und Zuweisungsoperator verstehen
Move-Semantik: Rvalue-Referenzen (&&), std::move und Verschiebekonstruktor
Die „Rule of Three" und „Rule of Five" — wann eigene Kopier- und Move-Semantik nötig ist

Templates und STL-Algorithmen – Einstieg

Funktions-Templates mit einfachen Typparametern
Klassen-Templates im Grundprinzip
Standardalgorithmen der STL (std::sort, std::find, std::for_each)
Lambda-Ausdrücke als Übergabe an Algorithmen

Fehlerbehandlung (Exception Handling)

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

Dauer: 3 Tage

Was du danach kannst

C++-Programme mit Zeigern, Referenzen und RAII sicher entwickeln
Klassen mit Vererbung, Polymorphie und Operatorüberladung entwerfen
Kopier- und Move-Semantik korrekt implementieren (Rule of Five)
Smart Pointer (std::unique_ptr, std::shared_ptr) statt manueller Speicherverwaltung einsetzen
Mit STL-Containern über vector hinaus, Algorithmen und Lambdas arbeiten
Projekte mit CMake konfigurieren und bauen

Dein Dozent

Frank Glück schult seit mehr als 30 Jahren und programmiert seit fast 40 Jahren. Seit 1999 ist er auch als Dozent für die GFU tätig. Er legt besonderen Wert auf saubere Objektarchitektur und ressourcenschonende Implementierung.

Häufige Fragen (FAQ)

Welche Vorkenntnisse sind für die C++ Grundlagen erforderlich?

Grundlegendes Verständnis prozeduraler Programmierung oder Vorkenntnisse in einer beliebigen Sprache sind hilfreich. Der Kurs führt strukturiert von elementaren Konzepten zur objektorientierten Programmierung (OOP) und modernen C++-Mechanismen.

Warum ist die „Rule of Three" (bzw. Rule of Five) in C++ wichtig?

Sobald eine Klasse Ressourcen (wie dynamischen Speicher oder Dateihandles) selbst verwaltet, müssen Destruktor, Kopierkonstruktor und Zuweisungsoperator explizit definiert werden — bei modernem C++ zusätzlich Move-Konstruktor und Move-Zuweisungsoperator (Rule of Five). Andernfalls drohen doppelte Freigaben (Double Free) und undefiniertes Verhalten.

Welche C++ Version wird im Praxiskurs geschult?

Der Schwerpunkt liegt auf modernem C++ (ab C++11 bis C++20). Behandelt werden Smart Pointer (std::unique_ptr, std::shared_ptr), RAII, Move-Semantik, Lambda-Ausdrücke, ein Einstieg in Templates und die Standard Template Library (STL) für sicheren, wartbaren Code.