Top-Fehler von C++-Anfängern: Von A bis Z

Einleitung: Warum stolpern Anfänger über C++?

C++ ist eine mächtige, aber anspruchsvolle Sprache. Sie gibt dem Entwickler die vollständige Kontrolle über Speicher und Leistung, aber diese Freiheit bringt viele Fallstricke mit sich. Laut Stack Overflow-Umfragen stoßen mehr als 60% der C++-Anfänger in den ersten Monaten auf Speicherlecks und undefiniertes Verhalten (undefined behavior).

In diesem Artikel analysieren wir die Top-Fehler von C++-Anfängern – von der Speicherverwaltung bis zu den Feinheiten der Arbeit mit Zeigern. Sie erfahren, wie Sie diese vermeiden und sichereren und effizienteren Code schreiben können.

1. Speicherlecks und falsche Ressourcenverwaltung

Der häufigste Fehler ist, den über new zugewiesenen Speicher nicht freizugeben. C++ hat keinen Garbage Collector, daher erfordert jedes new ein passendes delete.

Beispiel für falschen Code:

void leakyFunction() {\n    int* ptr = new int(42);\n    // ... irgendein Code, der eine Exception werfen könnte\n    // delete ptr; vergessen\n}

Wenn in der Funktion vor dem delete eine Exception auftritt, bleibt der Speicher für immer verloren.

Wie man es korrigiert:

\n
• Verwenden Sie Smart Pointer (std::unique_ptr, std::shared_ptr) – sie geben den Speicher automatisch frei.
\n
• RAII (Resource Acquisition Is Initialization) – Ressourcen im Konstruktor anfordern, im Destruktor freigeben.
\n

#include <memory>\nvoid safeFunction() {\n    std::unique_ptr<int> ptr = std::make_unique<int>(42);\n    // Speicher wird automatisch freigegeben, wenn der Gültigkeitsbereich verlassen wird\n}

2. Undefiniertes Verhalten (Undefined Behavior)

C++ ist voll von Situationen, in denen Code kompiliert, aber alles Mögliche tut – von korrekter Arbeit bis zum Absturz oder Formatieren der Festplatte. Anfänger ignorieren diese "Kleinigkeiten" oft.

Typische Fälle:

\n
• Verwendung nicht initialisierter Variablen – ihr Wert kann beliebig sein (Müll).
\n
• Array-Index außerhalb der Grenzen – arr[10] bei einer Größe von 10 Elementen.
\n
• Dereferenzieren eines Nullzeigers – int* p = nullptr; *p = 5;
\n
• Überlauf von vorzeichenbehafteten Ganzzahlen – int x = INT_MAX; x++;
\n

Beispiel mit einer nicht initialisierten Variable:

int main() {\n    int x; // nicht initialisiert\n    std::cout << x; // UB: kann 0, 42 ausgeben oder das Programm zum Absturz bringen\n    return 0;\n}

Lösung: Initialisieren Sie Variablen immer. Verwenden Sie int x = 0; oder int x{}; (value-initialization).

3. Fehler mit Zeigern und Referenzen

Zeiger sind eines der schwierigsten Themen für Anfänger. Fehler hier führen zu Abstürzen und schwer zu findenden Bugs.

Top-3-Fehler:

\n
• Hängende Zeiger (dangling pointers) – der Zeiger verweist auf bereits freigegebenen Speicher.
\n
• Speicherleck durch Zeiger auf lokale Variable – Rückgabe der Adresse einer lokalen Variable aus einer Funktion.
\n
• Verwechslung von Zeiger und Referenz – eine Referenz kann nicht neu zugewiesen werden, ein Zeiger schon.
\n

Beispiel für die Rückgabe der Adresse einer lokalen Variable:

int* badFunction() {\n    int local = 10;\n    return &local; // FEHLER: local wird nach Verlassen der Funktion zerstört\n}\n\nint main() {\n    int* ptr = badFunction();\n    std::cout << *ptr; // UB: hängender Zeiger\n}

Richtiger Ansatz: Geben Sie den Wert per Kopie zurück, verwenden Sie std::unique_ptr oder übergeben Sie das Ergebnis über einen Referenzparameter.

void safeFunction(int& result) {\n    result = 10; // Übergabe per Referenz\n}