Antwoord.

const-correctness is een concept in C++ dat bepaalt hoe variabelen, pointers, referenties en methoden worden gemarkeerd als "alleen-lezen". Dit verhoogt de veiligheid van de code, maakt de interfaces van klassen duidelijker en stelt de compiler in staat om fouten op compileertijd te detecteren in plaats van tijdens de uitvoering.

Het gebruik van const-kwalificaties is belangrijk omdat:

• Het expliciet onderscheid maakt tussen welke methoden en functies het object/de gegevens niet wijzigen.
• Het voorkomt onbedoelde wijzigingen van gegevens die niet gewijzigd mogen worden.
• Het helpt de compiler om de code te optimaliseren.

Voorbeeld:

class MyArray {
public:
    int getItem(size_t idx) const { // Wijzigt het object niet
        return arr[idx];
    }
    void setItem(size_t idx, int value) {
        arr[idx] = value;
    }
private:
    int arr[10];
};

Hier garandeert de methode getItem dat het het object niet wijzigt.

Misleidende vraag.

Wat is het verschil tussen

void foo(const int* ptr);

en

void foo(int* const ptr);

?

Juiste antwoord:

• const int* ptr — een pointer naar een constante waarde, de waarde kan niet worden gewijzigd, de pointer kan dat wel.
• int* const ptr — een constante pointer naar een wijzigbare waarde, de pointer kan niet worden gewijzigd, de waarde kan dat wel.

Voorbeelden van echte fouten door gebrek aan kennis van de nuances van het onderwerp.

---

Verhaal
In een groot project werd een methode van een klasse zonder const-kwalificatie geschreven:

int MyClass::getVal();

Dit maakte het onmogelijk om een object van de klasse als const-referentie te gebruiken, bijvoorbeeld in functies die alleen met "alleen-lezen" objecten werken. Dit beperkte de herbruikbaarheid van de code en leidde tot overmatig kopiëren van objecten.

---

Verhaal
Een ontwikkelaar gaf per ongeluk een referentie naar interne gegevens terug via een niet-const methode:

int& MyClass::getInt();

Hierdoor kreeg de clientcode de mogelijkheid om een privéveld van de klasse te wijzigen, wat leidde tot onverwachte wijzigingen in de staat en moeilijk te traceren bugs.

---

Verhaal
Door een constante parameter zonder const te laten in de functie:

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

heeft iemand per ongeluk de vector in de functie voor debugging gewijzigd, vergeet deze code weer te verwijderen. Dit veroorzaakte side-effects, bijna onopgemerkt tijdens tests, en werd alleen ontdekt in productie.