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 Variablen
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;
Variablenü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.
Veränderliche Referenz
In Rust können Sie auch eine veränderliche Referenz an eine Funktion übergeben, indem Sie `&mut` verwenden.
fn main() { let mut x = 5; modify_value(&mut x); println!("{}", x); // Ausgabe: 10 } fn modify_value(value: &mut i32) { *value = 10; }
Variablenarten und Verwendungszweck
In Rust gibt es verschiedene Arten von Variablen, die für verschiedene Zwecke verwendet werden können. Hier sind einige Beispiele:
Schattenvariablen
Schattenvariablen sind Variablen, die den gleichen Namen wie eine andere Variable haben, aber in einem anderen Gültigkeitsbereich deklariert sind. Dies ermöglicht es Ihnen, den Wert einer Variablen zu ändern, ohne die ursprüngliche Variable zu ändern.
let x = 5; { let x = 10; println!("{}", x); // Ausgabe: 10 } println!("{}", x); // Ausgabe: 5
Konstanten
Konstanten sind Variablen, deren Wert nicht geändert werden kann. Sie werden mit dem Schlüsselwort `const` deklariert.
const PI: f64 = 3.14159;
Globale Variablen
Globale Variablen sind Variablen, die im gesamten Programm verfügbar sind. Sie werden mit dem Schlüsselwort `static` deklariert.
static mut COUNTER: i32 = 0;
Variablenübergabe
- Wie übergebe ich eine Variable durch Kopieren an eine Funktion?
fn main() { let x = 5; print_value(x); println!("{}", x); // Ausgabe: 5 } fn print_value(value: i32) { println!("{}", value); }
- Wie übergebe ich eine Variable durch Ausleihen an eine Funktion?
fn main() { let x = 5; print_value(&x); println!("{}", x); // Ausgabe: 5 } fn print_value(value: &i32) { println!("{}", value); }
- Wie übergebe ich eine veränderliche Referenz an eine Funktion?
fn main() { let mut x = 5; modify_value(&mut x); println!("{}", x); // Ausgabe: 10 } fn modify_value(value: &mut i32) { *value = 10; }
Lebenszeit von Variablen in Rust
In Rust ist die Lebenszeit (engl. "lifetime") einer Variablen ein wichtiges Konzept, das sicherstellt, dass Referenzen immer gültig sind. Hier sind einige grundlegende Punkte zur Lebenszeit von Variablen in Rust:
Lebenszeit von Variablen
Die Lebenszeit einer Variablen beginnt, wenn sie erstellt wird, und endet, wenn sie den Gültigkeitsbereich (Scope) verlässt. Rust stellt sicher, dass keine Referenzen auf Variablen existieren, die den Gültigkeitsbereich bereits verlassen haben.
{ let x = 5; // x ist hier gültig // x kann hier verwendet werden } // x ist hier nicht mehr gültig
Lebenszeit von Referenzen
Referenzen haben ebenfalls eine Lebenszeit, die sicherstellt, dass sie nicht länger leben als die Daten, auf die sie verweisen. Rust verwendet Lebenszeitanmerkungen, um die Lebenszeit von Referenzen explizit zu machen.
fn main() { let r; { let x = 5; r = &x; // Fehler: x lebt nicht lange genug } // println!("r: {}", r); // r ist hier nicht mehr gültig }
Lebenszeitanmerkungen
Lebenszeitanmerkungen werden verwendet, um die Lebenszeit von Referenzen in Funktionen und Strukturen explizit zu machen. Sie werden mit einem Apostroph (`'`) gefolgt von einem Namen angegeben.
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } }
Hier ist ein vollständiges Beispiel, das die Lebenszeit von Variablen und Referenzen zeigt:
fn main() { // Lebenszeit von Variablen { let x = 5; println!("x: {}", x); // x ist hier gültig } // x ist hier nicht mehr gültig // Lebenszeit von Referenzen let r; { let x = 5; r = &x; // Fehler: x lebt nicht lange genug } // println!("r: {}", r); // r ist hier nicht mehr gültig // Lebenszeitanmerkungen let string1 = String::from("abcd"); let string2 = "xyz"; let result = longest(string1.as_str(), string2); println!("The longest string is {}", result); } fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } }