Antwort.

const-Correctness ist ein Konzept in C++, das definiert, wie Variablen, Zeiger, Referenzen und Methoden als "nur lesbar" gekennzeichnet werden. Dies erhöht die Sicherheit des Codes, macht die Schnittstellen von Klassen verständlicher und ermöglicht es dem Compiler, Fehler zur Compile-Zeit anstatt zur Laufzeit zu erkennen.

Die Verwendung von const-Qualifikatoren ist wichtig, weil:

• Es explizit ermöglicht, welche Methoden und Funktionen das Objekt/die Daten nicht ändern.
• Es verhindert, dass Daten, die nicht geändert werden sollten, versehentlich modifiziert werden.
• Es hilft dem Compiler, den Code zu optimieren.

Beispiel:

class MyArray {
public:
    int getItem(size_t idx) const { // Ändert das Objekt nicht
        return arr[idx];
    }
    void setItem(size_t idx, int value) {
        arr[idx] = value;
    }
private:
    int arr[10];
};

Hier stellt die Methode getItem sicher, dass sie das Objekt nicht ändert.

Fangfrage.

Was ist der Unterschied zwischen

void foo(const int* ptr);

und

void foo(int* const ptr);

?

Richtige Antwort:

• const int* ptr — ein Zeiger auf einen konstanten Wert, Wert kann nicht geändert werden, Zeiger kann.
• int* const ptr — konstanter Zeiger auf einen veränderbaren Wert, Zeiger kann nicht geändert werden, Wert kann.

Beispiele für reale Fehler aufgrund von Unkenntnis der Feinheiten des Themas.

---

Geschichte
In einem großen Projekt wurde eine Methode der Klasse ohne const-Qualifikator geschrieben:

int MyClass::getVal();

Dadurch konnte das Objekt der Klasse nicht als const-Referenz verwendet werden, z.B. in Funktionen, die nur mit "nur lesbaren" Objekten arbeiten. Dies beschränkte die Wiederverwendbarkeit des Codes und führte zu übermäßigem Kopieren von Objekten.

---

Geschichte
Ein Entwickler gab versehentlich eine Referenz auf interne Daten über eine nicht-konstante Methode zurück:

int& MyClass::getInt();

In der Folge erhielt der Client-Code die Möglichkeit, ein privates Feld der Klasse zu ändern, was zu unerwarteten Zustandsänderungen und schwer fassbaren Bugs führte.

---

Geschichte
Indem er einen konstanten Parameter in einer Funktion ohne const ließ:

void printVector(std::vector<int>& v);

änderte jemand versehentlich den Vektor direkt in der Funktion für Debugging-Zwecke, ohne diesen Code zu entfernen. Dies führte zu einem Side-Effect, der in den Tests fast unbemerkt blieb und erst in der Produktion erkannt wurde.