Variablen und Mutabilität (Rust Programmiersprache)

Variablenarten und -typen in Rust

In Rust gibt es verschiedene Arten von Variablen und Typen, die verwendet werden können:

Unveränderliche Variablen

Standardmäßig sind Variablen in Rust unveränderlich. Das bedeutet, dass der Wert einer Variablen nach ihrer Initialisierung nicht mehr geändert werden kann. Dies hilft, Fehler zu vermeiden und den Code sicherer zu machen.

let x = 5;

Veränderliche Variable

Wenn Sie eine Variable verändern möchten, können Sie das Schlüsselwort `mut` verwenden, um eine veränderliche Variable zu erstellen.

let mut x = 5;
x = 10;

Datentypen

In Rust gibt es verschiedene Arten von Datentypen, die verwendet werden können:

Ganzzahlen

Ganzzahlen können sowohl vorzeichenbehaftet als auch vorzeichenlos sein. Die Größe der Ganzzahlen kann variieren, abhängig von der Anzahl der Bits, die sie verwenden.

let x: i32 = 5; // vorzeichenbehaftete 32-Bit-Ganzzahl
let y: u32 = 10; // vorzeichenlose 32-Bit-Ganzzahl

Fließkommazahlen

Fließkommazahlen repräsentieren Zahlen mit Dezimalstellen. Sie können entweder einfacher Genauigkeit (f32) oder doppelter Genauigkeit (f64) sein.

let x: f32 = 5.0; // einfache Genauigkeit
let y: f64 = 10.0; // doppelte Genauigkeit

Boolesche Werte

Boolesche Werte können entweder `true` oder `false` sein.

let x: bool = true;
let y: bool = false;

Zeichen

Zeichen repräsentieren Unicode-Zeichen und werden in Rust als `char`-Typ definiert.

let x: char = 'a';
let y: char = '😀';

Zeichenketten

Zeichenketten sind eine Sequenz von Zeichen und werden in Rust als `String`-Typ definiert.

let x: String = "Hello, World!".to_string();

Variiablenübergabe

In Rust können Variablen auf zwei Arten übergeben werden: durch Kopieren oder durch Ausleihen.

Kopieren

Wenn eine Variable an eine Funktion übergeben wird, wird standardmäßig eine Kopie der Variable erstellt. Dies bedeutet, dass die ursprüngliche Variable nach dem Aufruf der Funktion unverändert bleibt.

fn main() {
    let x = 5;
    print_value(x);
    println!("{}", x); // Ausgabe: 5
}

fn print_value(value: i32) {
    println!("{}", value);
}

Ausleihen

Wenn Sie möchten, dass eine Funktion auf den Wert einer Variablen zugreifen kann, ohne eine Kopie zu erstellen, können Sie einen Verweis auf die Variable übergeben. Dies wird als "Ausleihen" bezeichnet.

fn main() {
    let x = 5;
    print_value(&x);
    println!("{}", x); // Ausgabe: 5
}

fn print_value(value: &i32) {
    println!("{}", value);
}

In diesem Beispiel wird die Funktion `print_value` einen Verweis auf die Variable `x` anstelle einer Kopie erhalten. Dadurch kann die Funktion auf den Wert von `x` zugreifen, ohne eine Kopie zu erstellen.

By Mutable Reference

In Rust können Sie auch eine veränderliche Referenz an eine Funktion übergeben, indem Sie `&mut` verwenden.

fn main() {
    let mut x = 5;
    print_value(&mut x);
    println!("{}", x); // Ausgabe: 10
}

Fazit
In Rust gibt es verschiedene Arten von Variablen und Typen, die verwendet werden können. Durch die Verwendung von unveränderlichen Variablen und Typen können Sie sicherstellen, dass Ihr Code sicherer und fehlerfreier ist. Durch die Verwendung von veränderlichen Variablen können Sie den Wert einer Variablen ändern, wenn dies erforderlich ist. Durch die Verwendung von verschiedenen Datentypen können Sie verschiedene Arten von Daten in Ihrem Code repräsentieren. Durch die Verwendung von Kopien oder Ausleihen können Sie Variablen auf verschiedene Weisen übergeben und auf sie zugreifen.