Getter

Teil des Abschnitts Objektorientierte Programmierung der Rust-Journey von Coddy. Lektion 11 von 61.

Mit privaten Feldern kann externer Code nicht direkt auf die Daten deiner Struktur zugreifen. Manchmal musst du anderen jedoch erlauben, die Daten zu lesen, ohne ihnen die Möglichkeit zu geben, sie zu ändern. Hier kommen Getter-Methoden ins Spiel.

Ein getter ist einfach eine öffentliche Methode, die eine Referenz auf ein privates Feld zurückgibt:

// wallet.rs
pub struct Wallet {
    balance: f64,
}

impl Wallet {
    pub fn new(initial: f64) -> Wallet {
        Wallet { balance: initial }
    }
    
    pub fn balance(&self) -> f64 {
        self.balance
    }
}

Die Methode balance() nimmt &self (schreibgeschützter Zugriff) entgegen und gibt den Wert des privaten Felds zurück. In Rust werden getter üblicherweise nach dem Feld selbst benannt: Kein Präfix get_ erforderlich.

Jetzt kann externer Code das Guthaben über die Methode lesen:

// main.rs
mod wallet;
use wallet::Wallet;

fn main() {
    let w = Wallet::new(100.0);
    println!("Balance: {}", w.balance());  // Funktioniert!
}

Bei Feldern, die eigene Daten wie String enthalten, gibst du oft eine Referenz zurück, um unnötiges Kopieren zu vermeiden:

pub fn name(&self) -> &String {
    &self.name
}

Getter ermöglichen dir einen kontrollierten Lesezugriff, während das Feld selbst geschützt bleibt. Die Struktur behält die Kontrolle über ihre Daten: Externer Code kann sie ansehen, aber nicht verändern.

Aufgabe

Einfach

Lass uns ein Benutzerprofilsystem erstellen, das zeigt, wie Getter-Methoden einen kontrollierten Lesezugriff auf private Daten ermöglichen.

Du wirst zwei Dateien erstellen, um deinen Code zu organisieren:

profile.rs: Definiere eine UserProfile-Struktur mit zwei privaten Feldern: username (String) und age (u32). Die Struktur selbst sollte öffentlich sein, aber die Felder sollten privat bleiben. Implementiere einen öffentlichen new-Konstruktor, der einen Benutzernamen und ein Alter entgegennimmt. Füge dann zwei Getter-Methoden hinzu:
- username: gibt eine Referenz auf den Benutzernamen zurück (&String)
- age: gibt den Alterswert zurück (u32)
main.rs: Binde dein Profilmodul ein, erstelle ein UserProfile und verwende die Getter-Methoden, um die Informationen des Benutzers auszugeben.

Denke daran, dass Getter in Rust typischerweise nach dem Feld selbst benannt werden: Kein get_-Präfix nötig. Gib bei String-Feldern eine Referenz zurück, um unnötiges Kopieren zu vermeiden.

Deine Ausgabe sollte genau diesem Format entsprechen:

Username: {username}
Age: {age}

Wenn du beispielsweise ein Profil mit dem Benutzernamen "alice" und dem Alter 25 erstellst, würde die Ausgabe so aussehen:

Username: alice
Age: 25

Du erhältst zwei Eingaben: den Benutzernamen und das Alter.

Probier es selbst

mod profile;

use profile::UserProfile;

fn main() {
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let username = input1.trim().to_string();

    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let age: u32 = input2.trim().parse().expect("Failed to parse age");

    // TODO: Erstelle ein UserProfile mit dem Konstruktor

    // TODO: Verwende die Getter-Methoden, um den Benutzernamen und das Alter auszugeben
    // Format:
    // Username: {username}
    // Alter: {age}
}