Veränderliche Methoden

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

Manchmal müssen Methoden mehr tun, als nur Daten zu lesen. Sie müssen sie ändern. Um Methoden zu erstellen, die die Felder einer Struktur ändern können, verwenden wir &mut self statt &self.

Das Schlüsselwort mut bezeichnet eine veränderbare Ausleihe und erteilt der Methode die Berechtigung, den internen Zustand der Instanz zu ändern:

struct Counter {
    value: i32,
}

impl Counter {
    fn increment(&mut self) {
        self.value += 1;
    }
    
    fn decrement(&mut self) {
        self.value -= 1;
    }
    
    fn get(&self) -> i32 {
        self.value
    }
}

Beachte, dass increment und decrement &mut self verwenden, weil sie value ändern, während get &self verwendet, da es die Daten nur liest.

Beim Aufrufen veränderlicher Methoden muss die Instanz selbst als veränderlich deklariert werden:

fn main() {
    let mut counter = Counter { value: 0 };
    
    counter.increment();
    counter.increment();
    println!("{}", counter.get()); // 2
    
    counter.decrement();
    println!("{}", counter.get()); // 1
}

Wenn du beim Erstellen der Instanz das Schlüsselwort mut vergisst, verhindert Rust, dass du irgendwelche &mut self-Methoden darauf aufrufst. Dadurch weißt du immer, wann sich deine Daten ändern könnten.

Aufgabe

Einfach

Erstelle eine BankAccount-Struktur mit einem einzigen Feld: balance (i32).

Füge einen Implementierungsblock für BankAccount mit drei Methoden hinzu:

deposit: übernimmt &mut self und einen amount: i32 und addiert den Betrag zum Kontostand
withdraw: übernimmt &mut self und einen amount: i32 und subtrahiert den Betrag vom Kontostand
get_balance: übernimmt &self und gibt den aktuellen Kontostand als i32 zurück

Du erhältst drei Eingaben:

Erste Zeile: der anfängliche Kontostand (i32)
Zweite Zeile: der Einzahlungsbetrag (i32)
Dritte Zeile: der Auszahlungsbetrag (i32)

Erstelle eine veränderbare BankAccount-Instanz mit dem anfänglichen Kontostand, zahle anschließend den angegebenen Betrag ein, zahle den angegebenen Betrag aus und gib den endgültigen Kontostand aus.

Erwartetes Ausgabeformat:

{final_balance}

Probier es selbst

use std::io;

// TODO: Definiere die BankAccount-Struktur hier


// TODO: Füge den Implementierungsblock für BankAccount mit den Methoden deposit, withdraw und get_balance hinzu


fn main() {
    let mut input = String::new();
    
    // Anfangssaldo einlesen
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let initial_balance: i32 = input.trim().parse().expect("Invalid number");
    
    input.clear();
    
    // Einzahlungsbetrag einlesen
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let deposit_amount: i32 = input.trim().parse().expect("Invalid number");
    
    input.clear();
    
    // Abhebungsbetrag einlesen
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let withdraw_amount: i32 = input.trim().parse().expect("Invalid number");
    
    // TODO: Erstelle eine veränderbare BankAccount-Instanz mit initial_balance
    // TODO: Rufe deposit mit deposit_amount auf
    // TODO: Rufe withdraw mit withdraw_amount auf
    // TODO: Gib den endgültigen Kontostand mit get_balance aus
}