Thorsten: // via Wikitext Extension for VSCode

2025-01-29T20:41:15Z

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

==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===
<pre>
fn function_name(parameter1: type1, parameter2: type2) -> return_type {
// code
}
</pre>

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

<pre>
fn add_one(x: i32) -> i32 {
x + 1
}
</pre>

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

<pre>
fn add_one(x: &mut i32) {
*x += 1;
}
</pre>

=== Übergabe nach Slice ===
Slices sind Referenzen auf Teile von Arrays oder Strings. Sie ermöglichen den Zugriff auf eine Teilmenge der Daten ohne Kopieren.

<pre>
fn sum(slice: &[i32]) -> i32 {
slice.iter().sum()
}
</pre>

=== Übergabe nach Tuple ===
Tupel können verwendet werden, um mehrere Werte als einen einzigen Parameter zu übergeben.

<pre>
fn print_coordinates(&(x, y): &(i32, i32)) {
println!("Current location: ({}, {})", x, y);
}
</pre>

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.

<pre>
fn add_one(x: i32) -> i32 {
x + 1
}
</pre>

Der Rückgabewert wird automatisch am Ende der Funktion zurückgegeben, es ist nicht notwendig, das `return`-Schlüsselwort zu verwenden.

<pre>
fn add_one(x: i32) -> i32 {
x + 1
}
</pre>

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

<pre>
fn add_one(x: i32) -> i32 {
x + 1
}
</pre>

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

<pre>
fn first_element(slice: &[i32]) -> &i32 {
&slice[0]
}
</pre>

=== Rückgabe von Tupeln ===
Eine Funktion kann mehrere Werte als Tupel zurückgeben.

<pre>
fn swap(x: i32, y: i32) -> (i32, i32) {
(y, x)
}
</pre>

=== Rückgabe von Option ===
Eine Funktion kann einen optionalen Wert zurückgeben, der entweder `Some` (mit einem Wert) oder `None` (ohne Wert) sein kann.

<pre>
fn divide(numerator: f64, denominator: f64) -> Option<f64> {
if denominator == 0.0 {
None
} else {
Some(numerator / denominator)
}
}
</pre>

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

<pre>
fn read_file(filename: &str) -> Result<String, std::io::Error> {
std::fs::read_to_string(filename)
}
</pre>

Diese verschiedenen Arten der Rückgabewerte ermöglichen es, Funktionen flexibel und robust zu gestalten.

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

Funktionen (Rust Programmiersprache) - Versionsgeschichte

Thorsten: // via Wikitext Extension for VSCode