Cecha Debug

Część sekcji Programowanie obiektowe ścieżki Rust w Coddy. Lekcja 35 z 61.

Biblioteka standardowa Rust zawiera wiele wstępnie zdefiniowanych cech, które zapewniają typowe funkcje. Jedną z najbardziej przydatnych podczas programowania jest cecha Debug, która umożliwia wyświetlenie zawartości struktury w celu jej sprawdzenia.

Jeśli spróbujesz bezpośrednio wypisać własną strukturę, Rust nie będzie wiedział, jak ją wyświetlić:

struct Player {
    name: String,
    score: u32,
}

let p = Player { name: String::from("Alice"), score: 100 };
println!("{:?}", p);  // Błąd! Debug nie jest zaimplementowany

Formatowanie {:?} wymaga cechy Debug. Zamiast implementować ją ręcznie, Rust udostępnia skrót: atrybut #[derive]. Umieść go bezpośrednio nad definicją struktury:

#[derive(Debug)]
struct Player {
    name: String,
    score: u32,
}

let p = Player { name: String::from("Alice"), score: 100 };
println!("{:?}", p);  // Player { name: "Alice", score: 100 }

Atrybut #[derive(Debug)] informuje kompilator, aby automatycznie wygenerował implementację Debug. Działa to, o ile wszystkie pola w strukturze również implementują Debug (co dotyczy większości standardowych typów).

Aby uzyskać bardziej czytelne wyjście dla zagnieżdżonych struktur, użyj {:#?} do ładnego formatowania:

println!("{:#?}", p);
// Player {
//     name: "Alice",
//     score: 100,
// }

Wyprowadzanie Debug jest niezbędne podczas tworzenia programu. Pozwala szybko sprawdzać dane bez pisania własnego kodu formatującego.

Wyzwanie

Łatwy

Sprawmy, by można było sprawdzać zawartość Twoich struktur, wyprowadzając cechę Debug! Utworzysz prosty system inwentarza, w którym elementy można wyświetlać na potrzeby debugowania.

Podzielisz swój kod na dwa pliki:

inventory.rs: Zdefiniuj publiczną strukturę Item z dwoma publicznymi polami: name (String) i quantity (u32). Użyj atrybutu #[derive(Debug)], aby automatycznie zaimplementować cechę Debug dla swojej struktury.
main.rs: Dołącz moduł inwentarza i utwórz instancję Item na podstawie podanych danych wejściowych. Wyświetl element za pomocą formatera debugowania {:?}, aby pokazać jego wewnętrzną strukturę.

Zaletą wyprowadzania Debug jest to, że Rust automatycznie generuje za Ciebie kod formatujący — nie trzeba niczego implementować ręcznie! Twoja struktura potrzebuje tylko tego atrybutu, aby można ją było wyświetlić za pomocą {:?}.

Wynik powinien wyświetlać element w formacie debugowania Rust:

Item { name: "{name}", quantity: {quantity} }

Na przykład dla danych wejściowych Keyboard i 15:

Item { name: "Keyboard", quantity: 15 }

Otrzymasz dwa dane wejściowe: nazwę elementu i jego ilość (przekonwertuj ją na u32).

Spróbuj swoich sił

mod inventory;

use inventory::Item;

fn main() {
    // Odczytaj dane wejściowe
    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 quantity_str = String::new();
    std::io::stdin().read_line(&mut quantity_str).expect("Failed to read line");
    let quantity: u32 = quantity_str.trim().parse().expect("Failed to parse quantity");
    
    // TODO: Utwórz instancję Item o podanej nazwie i ilości
    
    // TODO: Wypisz element, używając formatera debugowania {:?}
}