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;

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();

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;

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.

Fragen zu Variablen und Datentypen in Rust

Hier sind einige häufige Fragen zu Variablen und Datentypen in Rust, die in einem Spickzettel nützlich sein könnten:

Unveränderliche und veränderliche Variablen

• Wie deklariere ich eine unveränderliche Variable in Rust?

  let x = 5;
  

• Wie deklariere ich eine veränderliche Variable in Rust?

  let mut x = 5;
  x = 10;
  

Datentypen

• Welche Datentypen gibt es in Rust für Ganzzahlen?

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

• Wie deklariere ich eine Fließkommazahl in Rust?

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

• Wie deklariere ich einen booleschen Wert in Rust?

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

• Wie deklariere ich ein Zeichen in Rust?

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

• Wie deklariere ich eine Zeichenkette in Rust?

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

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