C++

Sprachkern, Speicherverwaltung, STL und modernes C++ (11/17/20); schneller, sicherer und gut lesbarer Code.

Was ist C++?

C++ ist eine kompilierte Sprache für hochperformante, systemnahe Entwicklung. Mit RAII, Templates und modernen Standards (C++11/14/17/20/23) unterstützt sie OOP und generische Programmierung.

Bevorzugt in Game-Engines, Embedded, Finance und HPC. Die STL (Algorithmen, Container) und Smart Pointers liefern Speichersicherheit und Performance zugleich.

TL;DR

Modernes C++: auto, move semantics, constexpr, ranges.
Build & Packaging: CMake, Abhängigkeiten mit vcpkg/Conan.
Qualität: Sanitizer, statische Analyse und Unit-Tests.

Grundlagen

Einführung in C++: Grundsyntax, Variablen, Operatoren, Schleifen und Funktionen.

Was ist C++? Erste Schritte in der Programmierung

28 Mai 2026 • Grundlagen

Lernen Sie die Grundlagen von C++, zentrale Konzepte und die ersten Schritte zur Erstellung eigener Programme.

C++ C++ Grundlagen

Weiterlesen →

C++-Compiler und IDE einrichten (Visual Studio, GCC, Clang)

28 Mai 2026 • Grundlagen

Lernen Sie die Einrichtung einer C++-Entwicklungsumgebung mit Visual Studio, GCC und Clang Schritt für Schritt.

C++ Visual Studio

Weiterlesen →

Erstes C++-Programm: Wie „Hello World“ funktioniert

28 Mai 2026 • Grundlagen

Schreiben Sie Ihr erstes C++-Programm und lernen Sie, wie „Hello World“ mit Kompilierung und Programmausführung funktioniert.

C++ C++ Grundlagen

Weiterlesen →

Variablen, Datentypen und auto in C++

28 Mai 2026 • Grundlagen

Lernen Sie Variablen, Datentypen und das Schlüsselwort auto in C++ mit praktischen Beispielen zur Typableitung.

C++ C++ Grundlagen Datentypen Variablen

Weiterlesen →

Operatoren in C++: Arithmetisch, Vergleich, Logisch

28 Mai 2026 • Grundlagen

Lernen Sie arithmetische, logische und Vergleichsoperatoren in C++ mit praktischen Beispielen kennen.

C++ C++ Grundlagen Operatoren

Weiterlesen →

Bedingte Anweisungen in C++: if, else if, switch

28 Mai 2026 • Grundlagen

Lernen Sie bedingte Anweisungen in C++ mit if, else if und switch zur Steuerung des Programmablaufs.

C++ if-Anweisung

Weiterlesen →

Schleifen in C++: for, while, do-while

28 Mai 2026 • Grundlagen

Lernen Sie Schleifen in C++ mit for, while und do-while zur Steuerung wiederholter Abläufe und Programmflüsse.

C++ for-Schleife while-Schleife

Weiterlesen →

Einführung in Funktionen in C++: Definieren, Aufrufen, Parameter

28 Mai 2026 • Grundlagen

Lernen Sie Funktionen in C++ mit Definition, Aufruf und Parametern für modulare und wiederverwendbare Programme.

C++ C++ Grundlagen

Weiterlesen →

Gültigkeitsbereich (Scope) und Lebensdauer in C++

28 Mai 2026 • Grundlagen

Lernen Sie Scope und Lebensdauer in C++, um Variablenzugriff und Objektlebenszyklen zu verstehen.

C++

Weiterlesen →

String-Verarbeitung in C++: C-Style und std::string

28 Mai 2026 • Grundlagen

Lernen Sie String-Verarbeitung in C++ mit C-Style-Strings und std::string anhand praktischer Beispiele.

C++ String-Operationen

Weiterlesen →

In C++ ist vector.empty() besser geeignet, um zu prüfen, ob ein Container leer ist, als size() == 0, da die Absicht klarer ist.


std::vector<int> numbers;

// weniger klar
if (numbers.size() == 0)
{
    // leer
}

// klarer und empfohlen
if (numbers.empty())
{
    // leer
}

In C++ helfen einfache Fehlerprüfungen vor der Verwendung von Werten, Abstürze zu vermeiden und Fehler schneller zu finden.


// riskant: keine Prüfung
int result = divide(a, b);

// sicherer: einfache Prüfung
if (b == 0)
{
    return;
}

int result = divide(a, b);

In C++ verbessern aussagekräftige Variablennamen die Lesbarkeit des Codes und machen zusätzliche Kommentare oft überflüssig.


// unklar
int x;
int y;

// aussagekräftig
int totalCount;
int maxRetries;

In C++ sorgt eine range-based for-Schleife für bessere Lesbarkeit, da Index- oder Iterator-Fehler vermieden werden.


std::vector<int> numbers = {1, 2, 3, 4};

// klassische Schleife
for (size_t i = 0; i < numbers.size(); i++)
{
    std::cout << numbers[i] << std::endl;
}

// range-based for (empfohlen)
for (int value : numbers)
{
    std::cout << value << std::endl;
}

In C++ verbessert auto die Lesbarkeit, wenn der Typ offensichtlich oder sehr lang ist. Der Fokus liegt dann auf der Logik statt auf dem Typ.


std::map<int, std::string> users;

// lang und unübersichtlich
std::map<int, std::string>::iterator it = users.begin();

// übersichtlicher
auto it = users.begin();

In C++ muss das Ergebnis von std::find immer überprüft werden. Wenn kein Element gefunden wird, entspricht der Iterator end().


std::vector<int> numbers = {1, 2, 3};

auto it = std::find(numbers.begin(), numbers.end(), 5);

if (it != numbers.end())
{
    std::cout << "Gefunden: " << *it << std::endl;
}
else
{
    std::cout << "Nicht gefunden" << std::endl;
}

In C++ verbessert ein früher return aus einer Funktion die Lesbarkeit, da verschachtelte Bedingungen vermieden werden.


// verschachtelte Bedingungen
void process(int value)
{
    if (value > 0)
    {
        if (value < 100)
        {
            doWork(value);
        }
    }
}

// früher return
void process(int value)
{
    if (value <= 0)
    {
        return;
    }

    if (value >= 100)
    {
        return;
    }

    doWork(value);
}

In C++ erhöht es die Lesbarkeit, konstante Werte vor der Schleife zu definieren.


// schwer lesbar
for (int i = 0; i < 10; i++)
{
    process(i);
}

// übersichtlicher
const int limit = 10;
for (int i = 0; i < limit; i++)
{
    process(i);
}

In C++ wird const auto& häufig verwendet, um unnötige Kopien zu vermeiden und gleichzeitig den Code übersichtlich zu halten.


std::vector<std::string> names = {"Alice", "Bob", "Charlie"};

// Kopien werden erstellt
for (auto name : names)
{
    std::cout << name << std::endl;
}

// keine Kopie, effizienter
for (const auto& name : names)
{
    std::cout << name << std::endl;
}

In C++ verbessert das Vermeiden unnötiger else-Blöcke die Lesbarkeit, da verschachtelter Code reduziert wird.


bool isValid = false;

// schwerer zu lesen
if (isValid)
{
    std::cout << "Gültig";
}
else
{
    return;
}

// übersichtlicher
if (!isValid)
{
    return;
}

std::cout << "Gültig";