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;
  }