Immutable vs const in Rust: Was ist der Unterschied? Leitfaden 2025

Immutable vs const in Rust: Warum selbst erfahrene Entwickler verwirrt sind?

Haben Sie jemals in Rust programmiert und plötzlich gedacht: «Stopp, ich habe eine Variable mit let deklariert, sie ist unveränderlich. Und const ist doch auch irgendwie eine Konstante. Was ist dann der Unterschied?». Wenn ja, sind Sie nicht allein. Die Frage «What is the difference between immutable and const variables in Rust?» hat auf Stack Overflow tausende Aufrufe erhalten. Und das ist kein Zufall.

Auf den ersten Blick scheinen sowohl let x = 5 als auch const X: i32 = 5 dasselbe zu tun: Sie verbieten, den Wert zu ändern. Aber in Rust, einer Sprache, in der Speichersicherheit und Performance an erster Stelle stehen, steckt der Teufel im Detail. Im Jahr 2025 ist das Verständnis dieser Details nicht nur Theorie, sondern eine Notwendigkeit, um effizienten und idiomatischen Code zu schreiben.

In diesem Artikel klären wir ein für alle Mal: Was ist der Unterschied zwischen einer immutable Variable und einer Konstante, wann verwendet man was, und welche Best Practices sind aktuell relevant? Los geht's!

1. Grundlegendes Verständnis: Was sagt der Compiler?

Beginnen wir mit dem Einfachsten. In Rust sind Variablen standardmäßig immutable (unveränderlich). Das bedeutet, dass Sie den Wert nach der Zuweisung nicht überschreiben können.

fn main() {\n    let x = 5;\n    // x = 6; // Fehler! Kann immutable Variable nicht ändern\n    println!("x = {}", x);\n}

Und hier ein Beispiel mit einer Konstante:

const MAX_POINTS: u32 = 100_000;\n\nfn main() {\n    println!("MAX_POINTS = {}", MAX_POINTS);\n}

Optisch ähnlich. Aber der Rust-Compiler behandelt sie völlig unterschiedlich. Und hier wird es interessant.

1.1. Wesentlicher Unterschied Nr. 1: Wo leben sie?

\n
• let – deklariert eine Variable. Sie existiert auf dem Stack (oder Heap, wenn es sich um Box, String usw. handelt) und hat eine Speicheradresse. Man kann Referenzen darauf nehmen, sie an Funktionen übergeben, verschieben.
\n
• const – deklariert eine Konstante. Sie hat keine feste Speicheradresse. Der Compiler inlined (fügt) ihren Wert direkt an der Stelle der Verwendung in den Code ein.
\n

Dies ist ein grundlegender Unterschied. const ist keine Variable, sondern ein benannter Wert, der zur Compile-Zeit eingesetzt wird.

fn main() {\n    let x = 42;\n    let y = &x; // Ok, Referenz auf Variable nehmen\n\n    const Z: i32 = 100;\n    // let w = &Z; // Fehler! Konstante hat keine Adresse, kann keine Referenz nehmen\n}

2. Tiefergehende Betrachtung: Performance und Semantik

Nachdem wir nun den «Wohnort» kennen, betrachten wir andere wichtige Aspekte.

2.1. Lebensdauer und Sichtbarkeitsbereich

Konstanten leben im globalen Sichtbarkeitsbereich (oder innerhalb einer Funktion, aber mit static-Lebensdauer). Sie existieren während der gesamten Programmlaufzeit. Sie können außerhalb einer Funktion deklariert werden und sind überall verfügbar.

Immutable Variablen leben nur innerhalb eines Blocks (Funktion, Schleife, if). Sobald der Block endet, wird der Speicher freigegeben.

const GLOBAL_CONST: i32 = 10;\n\nfn main() {\n    let local_var = 20;\n    // local_var lebt nur innerhalb von main\n}\n// local_var existiert nicht mehr\n// GLOBAL_CONST ist weiterhin verfügbar

2.2. Typ und Annotationen

Für const ist die Angabe des Datentyps zwingend erforderlich. Bei let leitet der Compiler ihn selbst her.

const PI: f64 = 3.14159; // Erforderlich: const NAME: Typ = Wert;\nlet pi = 3.14159; // Compiler erkennt selbst, dass es f64 ist

2.3. Berechnung zur Compile-Zeit (CTFE)

Der Wert von const muss zur Compile-Zeit berechnet werden.