Variablen und Mutabilität (Rust Programmiersprache) - Versionsgeschichte

Thorsten: // via Wikitext Extension for VSCode

2025-01-28T23:28:39Z

// via Wikitext Extension for VSCode

@@ Zeile 138: / Zeile 138: @@
+   }
    </pre>
 Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).

Thorsten: // via Wikitext Extension for VSCode

2025-01-28T23:15:19Z

// via Wikitext Extension for VSCode

@@ Zeile 17: / Zeile 17: @@
 let mut x = 5;
 x = 10;
 </pre>
@@ Zeile 141: / Zeile 97: @@
 </pre>
 ===Variablenübergabe===

Thorsten: // via Wikitext Extension for VSCode

2025-01-28T23:02:44Z

// via Wikitext Extension for VSCode

@@ Zeile 19: / Zeile 19: @@
 </pre>
-===Kontrolle über die Lebensdauer und den Gültigkeitsbereich von Daten in der Rust Programmiersprache===
+===Kontrolle über die Lebensdauer und den Gültigkeitsbereich von Daten in der Rust-Programmiersprache===
 ===Datentypen===
@@ Zeile 113: / Zeile 113: @@
      *value = 10;
+}
 </pre>

Thorsten: // via Wikitext Extension for VSCode

2025-01-28T22:48:59Z

// via Wikitext Extension for VSCode

@@ Zeile 12: / Zeile 12: @@
 </pre>
-===Veränderliche Variable===
+===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.
 <pre>
@@ Zeile 18: / Zeile 18: @@
 x = 10;
 </pre>
 ===Datentypen===
 In Rust gibt es verschiedene Arten von Datentypen, die verwendet werden können:
@@ Zeile 49: / Zeile 52: @@
 <pre>
 let x: char = 'a';
 let y: char = '😀';
@@ Zeile 61: / Zeile 63: @@
 </pre>
-==Variiablenübergabe==
+==Variablenübergabe==
 In Rust können Variablen auf zwei Arten übergeben werden: durch Kopieren oder durch Ausleihen.
@@ Zeile 97: / Zeile 99: @@
 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.
 In Rust können Sie auch eine veränderliche Referenz an eine Funktion übergeben, indem Sie `&mut` verwenden.
@@ Zeile 104: / Zeile 106: @@
 fn main() {
      let mut x = 5;
-     print_value(&mut x);
+     modify_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.
 Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).

Thorsten: // via Wikitext Extension for VSCode

2025-01-28T22:32:30Z

// via Wikitext Extension for VSCode

← Nächstältere Version		Version vom 28. Januar 2025, 22:32 Uhr
Zeile 97:		Zeile 97:

	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.		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.

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

	==Fazit==		==Fazit==

Thorsten: // via Wikitext Extension for VSCode

2025-01-28T22:28:28Z

// via Wikitext Extension for VSCode

Neue Seite

Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).

==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.

<pre>
let x = 5;
</pre>

===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.
<pre>
let mut x = 5;
x = 10;
</pre>
===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.

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

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

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

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

<pre>
let x: bool = true;
let y: bool = false;
</pre>

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

<pre>

let x: char = 'a';
let y: char = '😀';
</pre>

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

<pre>
let x: String = "Hello, World!".to_string();
</pre>

==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.

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

fn print_value(value: i32) {
println!("{}", value);
}
</pre>

===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.

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

fn print_value(value: &i32) {
println!("{}", value);
}
</pre>

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.

==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.

Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).