Ausdruckbare Typen in der Standardbibliothek von Rust

Einführung

In diesem Lab wird erklärt, dass um die Formatierungseigenschaften von std::fmt zu verwenden, Typen eine Implementierung für die Ausdruckbarkeit haben müssen, was automatisch für Typen in der std-Bibliothek bereitgestellt werden kann. Für andere Typen kann das fmt::Debug-Attribut abgeleitet werden, um die Ausgabe zu ermöglichen. Das fmt::Debug-Attribut vereinfacht die Implementierung von ausdruckbaren Typen, während fmt::Display manuell implementiert werden muss. Das fmt::Debug-Attribut ermöglicht es allen Typen, die Implementierung für die Ausgabe abzuleiten, und das gleiche gilt für {:?} für Typen der std-Bibliothek. Im Lab wird auch die Verwendung von {:?} für die Ausgabe erwähnt und ein Beispiel dafür gegeben, wie es verwendet werden kann, um verschiedene Typen auszugeben. Darüber hinaus wird das Konzept des "schönen Ausgebens" mit {:#?} eingeführt, das eine elegantere Darstellung von Datenstrukturen bietet. Schließlich wird erwähnt, dass fmt::Display manuell implementiert werden kann, um die Darstellung von Typen zu steuern.

Hinweis: Wenn das Lab keinen Dateinamen angibt, können Sie einen beliebigen Dateinamen verwenden. Beispielsweise können Sie main.rs verwenden und es mit rustc main.rs &&./main kompilieren und ausführen.

Debug

Alle Typen, die die Formatierungseigenschaften von std::fmt verwenden möchten, erfordern eine Implementierung, um ausdruckbar zu sein. Automatische Implementierungen werden nur für Typen wie in der std-Bibliothek bereitgestellt. Alle anderen müssen auf irgendeine Weise manuell implementiert werden.

Das fmt::Debug-Attribut macht dies sehr einfach. Alle Typen können die fmt::Debug-Implementierung ableiten (automatisch erstellen). Dies gilt nicht für fmt::Display, das manuell implementiert werden muss.

// Diese Struktur kann weder mit `fmt::Display` noch
// mit `fmt::Debug` ausgegeben werden.
struct UnPrintable(i32);

// Das `derive`-Attribut erstellt automatisch die Implementierung,
// die erforderlich ist, um diese `struct` mit `fmt::Debug` ausdruckbar zu machen.
#[derive(Debug)]
struct DebugPrintable(i32);

Alle std-Bibliothekstypen sind auch automatisch mit {:?} ausdruckbar:

// Leite die `fmt::Debug`-Implementierung für `Structure` ab. `Structure`
// ist eine Struktur, die ein einzelnes `i32` enthält.
#[derive(Debug)]
struct Structure(i32);

// Setze eine `Structure` in die Struktur `Deep`. Mach es auch ausdruckbar.
#[derive(Debug)]
struct Deep(Structure);

fn main() {
    // Das Ausgeben mit `{:?}` ist ähnlich zu `{}`.
    println!("{:?} Monate im Jahr.", 12);
    println!("{1:?} {0:?} ist der {actor:?} Name.",
             "Slater",
             "Christian",
             actor="actor's");

    // `Structure` ist ausdruckbar!
    println!("Jetzt wird {:?} ausgegeben!", Structure(3));

    // Das Problem mit `derive` ist, dass man keine Kontrolle darüber hat,
    // wie die Ergebnisse aussehen. Was, wenn ich möchte, dass nur eine `7` angezeigt wird?
    println!("Jetzt wird {:?} ausgegeben!", Deep(Structure(7)));
}

fmt::Debug macht also definitiv diese ausdruckbar, opfert aber etwas an Eleganz. Rust bietet auch "schönes Ausgeben" mit {:#?}.

#[derive(Debug)]
struct Person<'a> {
    name: &'a str,
    age: u8
}

fn main() {
    let name = "Peter";
    let age = 27;
    let peter = Person { name, age };

    // Schönes Ausgeben
    println!("{:#?}", peter);
}

Man kann fmt::Display manuell implementieren, um die Darstellung zu steuern.

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Debug-Lab abgeschlossen. Sie können in LabEx weitere Labs ausprobieren, um Ihre Fähigkeiten zu verbessern.