Variablen

Variablen und Konstanten in Rust haben gemeinsam, dass sie im Quelltext per Namen verwendet werden. Variablen werden mit dem Schlüsselwort let eingeleitet, vor Konstanten findet man ein const.

fn main() {
    let x = 5;  // Initialisierung einer Variable
    const C: i32 = 1;  // Initialisierung einer Konstanten
}

Übrigens ist Text, der sich hinter // befindet ein Kommentar und wird vom Compiler ignoriert. Wir können Variablen auch erst deklarieren und später initialisieren.

#![allow(unused)]
fn main() {
let x;
x = 5;
}

Wenn wir versuchen auf nicht-initialisierte Variablen zuzugreifen, verweigert der Compiler jedoch die Übersetzung.

#![allow(unused)]
fn main() {
let x;
let y = x;
x = 5;
}

Laufzeit vs. Kompilierzeit

Variablen sind Adressen im Speicher zugewiesen. So kann während der Laufzeit des Programms der Wert einer Variablen geändert werden, in dem der Wert an dieser Speicheradresse geändert wird. Konstanten werden bereits während des Kompilierens ausgewertet. Sie können zur Laufzeit weder geändert noch initialisiert werden. Oft wird der Wert einer Konstante während des Kompilierens direkt verwendet.

Geltungsbereich

Nicht nur in Rust bezeichnet der Geltungsbereich (engl. scope) einer Variable oder Konstante den Bereich im Programmquelltext, in dem sie mit ihrem Namen referenziert werden kann. Beispielsweise meint der globale Geltungsbereich, dass die Verwendung der Variable an beliebiger Stelle möglich ist.

In Rust können Konstanten in beliebigem Geltungsbereich initialisiert werden. Das Anlegen globaler Variablen mit let ist jedoch nicht möglich.

let x = 5;  // unzulässig
const C: i32 = 1;  // Initialisierung einer Konstanten
fn main() {
}

Die Konstante im vorherigen Schnipsel benötigt eine sogenannte Typannotation : i32. Mit primitiven Typen werden wir uns im nächsten Kapitel beschäftigen.

Wir können mit geschweiften Klammern einen neuen Geltungsbereich definieren. Beispielsweise verfügt das Programm

fn main() {
    let x = 5;
    {
        let x = 4;
        println!("{x}");
    }
    println!("{x}");
}

über einen weiteren inneren Geltungsbereich innerhalb des Geltungsbereichs der Funktion main.

Sind Variablen wirklich variabel?

Wenn wir in Rust versuchen einer existierenden Variable einen neuen Wert zuzuweisen, dann funktioniert das nicht.

fn main() {
    let x = 5;
    x = 4;
}

Der Compiler wird die Übersetzung mit dem Hinweis

cannot assign twice to immutable variable

verweigern. Wir können also standarmäßig einer Variablen kein zweites Mal einen Wert zuweisen. Um das Variieren einer Variablen zu ermöglichen, benötigen wir zusätzlich zu let das Schlüsselwort mut, das für das englische mutable steht.

fn main() {
    let mut x = 5;
    x = 4;
}

Das Deklarieren und Initialisieren einer neuen Variable mit einem bereits verbrauchten Namen ist ebenfalls möglich. Die alte Variable wird dann nicht mehr verfügbar sein.

fn main() {
    let x = 5;
    let x = x + 1;
}

Die zweite Verwendunge von x überschattet (engl. shadows) die Erste. Wir haben die Variable x im Beispiel also nicht geändert, sondern eine neue Variable x mit gleichem Namen angelegt.