Funktionen (Rust Programmiersprache)
Funktionen (Rust Programmiersprache)
Funktionen sind in Rust sehr ähnlich zu Funktionen in anderen Programmiersprachen. Sie können Parameter entgegennehmen und Werte zurückgeben. Funktionen in Rust beginnen mit dem Schlüsselwort `fn` gefolgt von dem Namen der Funktion
Syntax
fn function_name(parameter1: type1, parameter2: type2) -> return_type { // code }
Parameterübergabe in der Programmiersprache Rust
In Rust können Funktionen Parameter entgegennehmen, die beim Aufruf der Funktion übergeben werden. Es gibt verschiedene Arten der Parameterübergabe:
Übergabe nach Wert
Bei der Übergabe nach Wert wird eine Kopie des Wertes an die Funktion übergeben. Änderungen am Parameter innerhalb der Funktion haben keine Auswirkungen auf das Original.
fn add_one(x: i32) -> i32 { x + 1 }
Übergabe nach Referenz
Bei der Übergabe nach Referenz wird eine Referenz auf den Wert an die Funktion übergeben. Änderungen am Parameter innerhalb der Funktion können das Original beeinflussen. Referenzen werden mit dem `&`-Symbol angegeben.
fn add_one(x: &mut i32) { *x += 1; }
Übergabe nach Slice
Slices sind Referenzen auf Teile von Arrays oder Strings. Sie ermöglichen den Zugriff auf eine Teilmenge der Daten ohne Kopieren.
fn sum(slice: &[i32]) -> i32 { slice.iter().sum() }
Übergabe nach Tuple
Tupel können verwendet werden, um mehrere Werte als einen einzigen Parameter zu übergeben.
fn print_coordinates(&(x, y): &(i32, i32)) { println!("Current location: ({}, {})", x, y); }
Diese verschiedenen Arten der Parameterübergabe ermöglichen es, Funktionen flexibel und effizient zu gestalten.
Rückgabewerte in der Programmiersprache Rust
Funktionen in Rust können Werte zurückgeben, die vom Aufrufer verwendet werden können. Der Rückgabetyp wird mit einem Pfeil `->` nach den Parametern angegeben.
fn add_one(x: i32) -> i32 { x + 1 }
Der Rückgabewert wird automatisch am Ende der Funktion zurückgegeben, es ist nicht notwendig, das `return`-Schlüsselwort zu verwenden.
fn add_one(x: i32) -> i32 { x + 1 }
Rückgabewerte in der Programmiersprache Rust
Funktionen in Rust können verschiedene Arten von Werten zurückgeben. Der Rückgabetyp wird mit einem Pfeil `->` nach den Parametern angegeben.
Einfache Rückgabewerte
Eine Funktion kann einen einfachen Wert wie eine Ganzzahl, einen Gleitkommawert oder einen booleschen Wert zurückgeben.
fn add_one(x: i32) -> i32 { x + 1 }
Rückgabe von Referenzen
Eine Funktion kann auch eine Referenz auf einen Wert zurückgeben. Dies ist nützlich, wenn Sie möchten, dass die Funktion auf Daten verweist, die außerhalb der Funktion existieren.
fn first_element(slice: &[i32]) -> &i32 { &slice[0] }
Rückgabe von Tupeln
Eine Funktion kann mehrere Werte als Tupel zurückgeben.
fn swap(x: i32, y: i32) -> (i32, i32) { (y, x) }
Rückgabe von Option
Eine Funktion kann einen optionalen Wert zurückgeben, der entweder `Some` (mit einem Wert) oder `None` (ohne Wert) sein kann.
fn divide(numerator: f64, denominator: f64) -> Option<f64> { if denominator == 0.0 { None } else { Some(numerator / denominator) } }
Rückgabe von Result
Eine Funktion kann ein Ergebnis zurückgeben, das entweder `Ok` (mit einem Wert) oder `Err` (mit einem Fehler) sein kann. Dies ist nützlich für die Fehlerbehandlung.
fn read_file(filename: &str) -> Result<String, std::io::Error> { std::fs::read_to_string(filename) }
Diese verschiedenen Arten der Rückgabewerte ermöglichen es, Funktionen flexibel und robust zu gestalten.