Funktionen (Rust Programmiersprache)

Aus ahrensburg.city
Zur Navigation springen Zur Suche springen

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.