Das Public-Schlüsselwort

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

In der vorherigen Lektion hast du gelernt, wie man Code in separate Moduldateien organisiert. Wenn du jedoch versucht hättest, die Player-Struktur aus main.rs zu verwenden, würdest du auf einen Compilerfehler stoßen. Das liegt daran, dass alles in einem Rust-Modul standardmäßig privat ist.

Damit Elemente außerhalb ihres Moduls zugänglich sind, musst du sie ausdrücklich mit dem Schlüsselwort pub kennzeichnen:

// player.rs
pub struct Player {
    pub name: String,
    pub score: u32,
}

impl Player {
    pub fn new(name: String) -> Player {
        Player { name, score: 0 }
    }
}

Beachte, wie pub an mehreren Stellen erscheint: bei der Struktur selbst, bei jedem Feld und bei der Methode. Jedes Element benötigt seine eigene Sichtbarkeitserklärung.

Ohne pub bei der Struktur können andere Dateien den Typ nicht einmal benennen. Ohne pub bei den Feldern können sie nicht direkt auf die Daten zugreifen. Ohne pub bei den Methoden können sie sie nicht aufrufen.

Jetzt kannst du in main.rs die öffentlichen Elemente des Moduls verwenden:

// main.rs
mod player;

use player::Player;

fn main() {
    let p = Player::new(String::from("Alice"));
    println!("{}", p.name);
}

Die use-Anweisung bringt Player in den Gültigkeitsbereich, sodass du nicht jedes Mal player::Player schreiben musst. Dieser Ansatz, bei dem standardmäßig der Datenschutz gilt, ist beabsichtigt. Er ermutigt dich, sorgfältig darüber nachzudenken, welche Teile deines Codes der Außenwelt zugänglich gemacht werden sollten.

Aufgabe

Einfach

Erstellen wir einen einfachen Produktkatalog, indem wir deinen Code auf zwei Dateien aufteilen und die richtigen Elemente öffentlich machen, sodass sie von deinem Hauptprogramm aus verwendet werden können.

Du erstellst zwei Dateien:

product.rs: Definiere eine Product-Struktur mit zwei Feldern: name (String) und price (f64). Füge eine zugehörige Funktion namens new hinzu, die einen Namen und einen Preis entgegennimmt und ein neues Product zurückgibt. Denke daran, die Struktur, ihre Felder und die Methode als öffentlich zu kennzeichnen, damit sie von außerhalb des Moduls aufgerufen werden können.
main.rs: Deklariere das Produktmodul, bringe Product mit einer use-Anweisung in den Gültigkeitsbereich, erstelle anschließend ein Produkt und gib seine Details aus.

Überlege sorgfältig, wo du das Schlüsselwort pub benötigst: Die Struktur selbst muss sichtbar sein, auf die Felder muss lesend zugegriffen werden können, und die Konstruktormethode muss von main.rs aus aufrufbar sein.

Deine Ausgabe sollte genau diesem Format folgen:

Product: {name}, Price: ${price}

Wenn du beispielsweise ein Produkt mit dem Namen "Laptop" und dem Preis 999.99 erstellst, würde die Ausgabe folgendermaßen aussehen:

Product: Laptop, Price: $999.99

Du erhältst zwei Eingaben: den Produktnamen und den Preis.

Probier es selbst

// Deklariere das product-Modul
mod product;

// TODO: Bringe Product mit einer use-Anweisung in den Gültigkeitsbereich

fn main() {
    // Eingabe lesen
    let mut name = String::new();
    std::io::stdin().read_line(&mut name).expect("Failed to read line");
    let name = name.trim().to_string();
    
    let mut price_input = String::new();
    std::io::stdin().read_line(&mut price_input).expect("Failed to read line");
    let price: f64 = price_input.trim().parse().expect("Failed to parse price");
    
    // TODO: Erstelle ein neues Product mit der Funktion Product::new
    
    // TODO: Gib die Produktdetails im folgenden Format aus:
    // Product: {name}, Price: ${price}
}