Einführung in Implementierungsblöcke

Teil des Abschnitts Object Oriented Programming der Rust-Journey von Coddy — Lektion 1 von 61.

In Rust definieren Structs, welche Daten ein Typ enthält, aber sie definieren nicht, was dieser Typ tun kann. Um einem Struct Verhalten zu verleihen, verwenden wir Implementierungsblöcke mit dem Schlüsselwort impl.

Ein Implementierungsblock verbindet Funktionen (Methoden genannt) mit einem spezifischen Struct. Hier ist die grundlegende Struktur:

struct Dog {
    name: String,
    age: u8,
}

impl Dog {
    fn bark(&self) {
        println!("{} says woof!", self.name);
    }
}

Der impl Dog-Block teilt Rust mit, dass alles darin zum Dog-Struct gehört. Diese Trennung hält Ihre Datendefinition sauber, während sie es Ihnen ermöglicht, so viele Methoden wie nötig im Implementierungsblock hinzuzufügen.

Um eine Methode aufzurufen, verwende die Punktnotation bei einer Instanz:

fn main() {
    let my_dog = Dog {
        name: String::from("Rex"),
        age: 3,
    };
    
    my_dog.bark(); // Ausgabe: Rex sagt woof!
}

Dieses Muster der Trennung von Daten (dem struct) und Verhalten (dem impl-Block) ist grundlegend für die Organisation von Rust-Code. In den kommenden Lektionen werden wir untersuchen, wie Methoden über den &self-Parameter, den Sie im obigen Beispiel sehen, auf struct-Daten zugreifen.

Aufgabe

Einfach

Erstelle eine Cat Struct mit zwei Feldern: name (String) und lives (u8).

Füge einen Implementierungsblock für Cat mit einer Methode namens meow hinzu, die &self nimmt und den Namen der Katze gefolgt von " says meow!" ausgibt.

Du erhältst zwei Eingaben:

Erste Zeile: der Name der Katze (String)
Zweite Zeile: die Anzahl der Leben (u8)

Erstelle eine Cat Instanz mit den bereitgestellten Werten und rufe die meow Methode darauf auf.

Erwartetes Ausgabeformat:

{name} says meow!

Spickzettel

Implementierungsblöcke verbinden Methoden mit Structs unter Verwendung des impl-Schlüsselworts:

struct Dog {
    name: String,
    age: u8,
}

impl Dog {
    fn bark(&self) {
        println!("{} says woof!", self.name);
    }
}

Der impl-Block trennt die Datendefinition (Struct) vom Verhalten (Methoden). Methoden werden mit der Punktnotation aufgerufen:

let my_dog = Dog {
    name: String::from("Rex"),
    age: 3,
};

my_dog.bark(); // Ausgabe: Rex says woof!

Methoden verwenden den &self-Parameter, um auf Struct-Daten zuzugreifen.

Probier es selbst

use std::io;

// TODO: Definiere das Cat-Struct mit den Feldern 'name' (String) und 'lives' (u8)


// TODO: Füge einen Implementierungsblock für Cat mit einer 'meow'-Methode hinzu


fn main() {
    let mut name = String::new();
    io::stdin().read_line(&mut name).expect("Failed to read line");
    let name = name.trim().to_string();
    
    let mut lives_input = String::new();
    io::stdin().read_line(&mut lives_input).expect("Failed to read line");
    let lives: u8 = lives_input.trim().parse().expect("Failed to parse lives");
    
    // TODO: Erstelle eine Cat-Instanz und rufe die meow-Methode auf
    
}