C++ const und Konstanten: const, constexpr und consteval

Warum es Konstanten gibt

Eine Konstante ist ein Wert, den du nach dem Festlegen versprichst, nie wieder zu ändern. Etwas als const zu markieren erfüllt zwei Aufgaben gleichzeitig: Es dokumentiert deine Absicht für jeden, der den Code liest, und es erlaubt dem Compiler, diese Absicht zu erzwingen – jede Zeile, die versucht, den Wert zu ändern, wird zu einem Compilefehler statt zu einem stillen Laufzeitfehler.

Während das Schlüsselwort auto den Compiler den Typ einer Variablen ableiten lässt, schränkt const ein, was du mit dieser Variablen tun darfst. Beide lassen sich frei kombinieren: const auto limit = 100; ist ein schreibgeschützter int.

Einen const-Wert deklarieren

Setze const vor den Typ. Eine const-Variable muss in derselben Zeile initialisiert werden, denn es gibt keinen späteren Moment, in dem es dir erlaubt wäre, ihr etwas zuzuweisen.

#include <iostream>
using namespace std;

int main() {
    const int maxUsers = 100;
    const double pi = 3.14159;

    cout << "Max users: " << maxUsers << "\n";
    cout << "Pi: " << pi << "\n";

    // maxUsers = 200; // Fehler: Zuweisung an eine schreibgeschützte Variable
    return 0;
}

Kommentiere die Zuweisung aus, und das Programm lässt sich nicht kompilieren – der Compiler meldet „assignment of read-only variable". Genau das ist der Sinn: Der Fehler wird abgefangen, bevor das Programm überhaupt läuft.

Eine verbreitete, aus C übernommene Anfängergewohnheit ist #define MAX_USERS 100. Vermeide das. Ein Makro ist eine blinde Textersetzung ohne Typ und ohne Rücksicht auf den Gültigkeitsbereich, daher lässt es sich in einem Debugger nicht inspizieren und erzeugt verwirrende Fehlermeldungen. Eine const- (oder constexpr-)Variable wird wie alles andere typgeprüft und hat einen Gültigkeitsbereich.

const vs constexpr

Beide Schlüsselwörter geben dir einen Wert, der sich nicht ändern kann, aber sie beantworten unterschiedliche Fragen. const sagt „das ändert sich nach dem Festlegen nie mehr". constexpr sagt das Stärkere: „das kann zur Compilezeit berechnet werden" – und alles, was constexpr ist, ist automatisch auch const.

#include <iostream>
using namespace std;

int main() {
    int n = 5;
    const int a = n;          // OK: Laufzeitwert, nur schreibgeschützt
    constexpr int b = 10;     // OK: zur Compilezeit bekannt
    // constexpr int c = n;   // Fehler: n ist keine Compilezeit-Konstante

    int grid[b];              // zulässig: die Array-Größe muss eine Compilezeit-Konstante sein
    cout << "Array length: " << sizeof(grid) / sizeof(grid[0]) << "\n";
    cout << a << " " << b << "\n";
    return 0;
}

Die Faustregel: Greife zu constexpr, wann immer der Wert ein festes Literal oder eine Berechnung ist, die der Compiler durchführen kann (Array-Größen, Pufferlängen, switch-Labels, Template-Argumente). Verwende einfaches const, wenn der Wert zur Laufzeit feststeht, sich danach aber nicht ändern soll – etwa eine const-Kopie eines Funktionsarguments.

Seit C++20 gibt es außerdem consteval, das bei Funktionen verwendet wird, die zur Compilezeit ausgeführt werden müssen:

consteval int square(int x) { return x * x; }
constexpr int area = square(8); // während der Kompilierung berechnet

Eine constexpr-Funktion darf zur Compilezeit laufen; eine consteval-Funktion muss es immer, sonst ist es ein Fehler.

Zeiger und const: von rechts nach links lesen

Hier bringt const die Leute durcheinander, denn das Schlüsselwort kann auf beiden Seiten des * stehen, und die beiden Bedeutungen sind entgegengesetzt. Der Trick besteht darin, die Deklaration von rechts nach links zu lesen.

#include <iostream>
using namespace std;

int main() {
    int x = 1, y = 2;

    const int* p1 = &x;   // Zeiger auf const int: kann umgebogen werden, *p1 nicht änderbar
    p1 = &y;              // OK
    // *p1 = 5;           // Fehler: *p1 ist const

    int* const p2 = &x;   // const-Zeiger auf int: *p2 änderbar, kann nicht umgebogen werden
    *p2 = 99;             // OK
    // p2 = &y;           // Fehler: p2 ist const

    const int* const p3 = &x; // const-Zeiger auf const int: beides nicht erlaubt

    cout << *p1 << " " << *p2 << " " << *p3 << "\n";
    return 0;
}

Lies int* const p2 von rechts nach links: „p2 ist ein const-Zeiger auf int". Lies const int* p1 als „p1 ist ein Zeiger auf const int". Verstehst du das falsch, verbringst du echte Zeit verwirrt mit einem Fehler, der dir sagt, dass du etwas nicht ändern darfst, das du für veränderbar gehalten hast.

Ein praktischer Fallstrick: Nimm niemals die Adresse eines const und wirf das const per Cast weg, um das zugrunde liegende Objekt zu ändern. Das ist undefiniertes Verhalten, wenn das ursprüngliche Objekt wirklich const war, und der Compiler darf annehmen, dass sich der Wert nie ändert – dein „Schreibvorgang" wird vielleicht einfach ignoriert.

const-Referenzen als Funktionsparameter

Der häufigste alltägliche Einsatz von const ist das Übergeben großer Objekte per Referenz, ohne sie zu kopieren. Ein const&-Parameter vermeidet die Kopie und verspricht, dass die Funktion das Argument des Aufrufers nicht ändert.

#include <iostream>
#include <string>
using namespace std;

// Es wird keine Kopie des Strings erstellt, und wir können ihn nicht versehentlich verändern.
void greet(const string& name) {
    // name += "!"; // Fehler: name ist const
    cout << "Hello, " << name << "!\n";
}

int main() {
    string user = "Ada";
    greet(user);
    greet("Grace"); // const& bindet auch an ein temporäres Literal
    return 0;
}

Die Übergabe per const& ist die Standardwahl für jeden Parameter, der größer als ein paar Bytes ist (Strings, Vektoren, deine eigenen Klassen). Beachte, dass sie der Funktion auch erlaubt, ein Temporäres wie "Grace" anzunehmen – eine einfache nicht-const Referenz kann nicht an ein Temporäres binden, das Weglassen des const würde hier also den zweiten Aufruf zurückweisen.

const-Memberfunktionen

Wenn du eine Klasse schreibst, markiere jede Methode, die das Objekt nicht ändert, mit einem nachgestellten const. Das macht die Methode auf const-Instanzen und const&-Parametern aufrufbar – ohne dies kannst du dein eigenes Objekt nicht über ein const-Handle lesen.

#include <iostream>
#include <string>
using namespace std;

class Account {
    double balance = 0;
public:
    void deposit(double amount) { balance += amount; } // ändert -> nicht const
    double getBalance() const { return balance; }       // schreibgeschützt -> const
};

int main() {
    Account a;
    a.deposit(50);

    const Account& ref = a;        // eine schreibgeschützte Sicht
    cout << ref.getBalance() << "\n"; // funktioniert nur, weil getBalance() const ist
    // ref.deposit(10);            // Fehler: deposit() ist nicht const
    return 0;
}

Die Disziplin, schreibgeschützte Methoden mit const zu markieren, nennt man const correctness. Mach es von Anfang an richtig – eine Methode, die const hätte sein sollen, lässt sich leicht ergänzen, aber const später in einer großen Codebasis nachzurüsten ist schmerzhaft, weil jeder Aufrufer über eine const-Referenz davon abhängt.

Weiter: Operatoren

Jetzt, da deine Werte mit const festgezurrt werden können, ist der nächste Schritt, etwas mit ihnen zu tun. Die Seite zu den Operatoren behandelt arithmetische, vergleichende, logische und Zuweisungsoperatoren – einschließlich der Fallstricke rund um die Ganzzahldivision, der Operatorpräzedenz und der Frage, wie const mit den Zuweisungsoperatoren interagiert, die du nicht verwenden darfst.