Einführung in die Bezeichner von Rust-Makros

RustRustBeginner
Jetzt üben

This tutorial is from open-source community. Access the source code

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab werden wir auf das Konzept der Bezeichner in Rust-Makros eingewiesen. Bezeichner werden verwendet, um die Argumente eines Makros voranzustellen und sind typannotiert. Einige Beispiele für Bezeichner sind ident für Variablennamen/Funktionsnamen, expr für Ausdrücke, block für Codeblöcke und pat für Muster. Diese Bezeichner werden innerhalb von Makrosregeln verwendet, um Code basierend auf den bereitgestellten Argumenten zu generieren.

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.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL rust(("Rust")) -.-> rust/BasicConceptsGroup(["Basic Concepts"]) rust(("Rust")) -.-> rust/DataTypesGroup(["Data Types"]) rust(("Rust")) -.-> rust/FunctionsandClosuresGroup(["Functions and Closures"]) rust(("Rust")) -.-> rust/AdvancedTopicsGroup(["Advanced Topics"]) rust/BasicConceptsGroup -.-> rust/variable_declarations("Variable Declarations") rust/DataTypesGroup -.-> rust/type_casting("Type Conversion and Casting") rust/FunctionsandClosuresGroup -.-> rust/function_syntax("Function Syntax") rust/FunctionsandClosuresGroup -.-> rust/expressions_statements("Expressions and Statements") rust/AdvancedTopicsGroup -.-> rust/operator_overloading("Traits for Operator Overloading") subgraph Lab Skills rust/variable_declarations -.-> lab-99225{{"Einführung in die Bezeichner von Rust-Makros"}} rust/type_casting -.-> lab-99225{{"Einführung in die Bezeichner von Rust-Makros"}} rust/function_syntax -.-> lab-99225{{"Einführung in die Bezeichner von Rust-Makros"}} rust/expressions_statements -.-> lab-99225{{"Einführung in die Bezeichner von Rust-Makros"}} rust/operator_overloading -.-> lab-99225{{"Einführung in die Bezeichner von Rust-Makros"}} end

Bezeichner

Die Argumente eines Makros werden mit einem Dollarzeichen $ vorangestellt und mit einem Bezeichner typannotiert:

macro_rules! create_function {
    // Dieses Macro nimmt ein Argument vom Bezeichner `ident` entgegen und
    // erstellt eine Funktion mit dem Namen `$func_name`.
    // Der Bezeichner `ident` wird für Variablennamen/Funktionsnamen verwendet.
    ($func_name:ident) => {
        fn $func_name() {
            // Das Macro `stringify!` wandelt ein `ident` in einen String um.
            println!("You called {:?}()",
                     stringify!($func_name));
        }
    };
}

// Erstellen Sie Funktionen mit den Namen `foo` und `bar` mit dem obigen Macro.
create_function!(foo);
create_function!(bar);

macro_rules! print_result {
    // Dieses Macro nimmt einen Ausdruck vom Typ `expr` entgegen und druckt
    // ihn als String zusammen mit seinem Ergebnis.
    // Der Bezeichner `expr` wird für Ausdrücke verwendet.
    ($expression:expr) => {
        // `stringify!` wird den Ausdruck *so wie er ist* in einen String umwandeln.
        println!("{:?} = {:?}",
                 stringify!($expression),
                 $expression);
    };
}

fn main() {
    foo();
    bar();

    print_result!(1u32 + 1);

    // Denken Sie daran, dass Blöcke ebenfalls Ausdrücke sind!
    print_result!({
        let x = 1u32;

        x * x + 2 * x - 1
    });
}

Dies sind einige der verfügbaren Bezeichner:

  • block
  • expr wird für Ausdrücke verwendet
  • ident wird für Variablennamen/Funktionsnamen verwendet
  • item
  • literal wird für literale Konstanten verwendet
  • pat (Muster)
  • path
  • stmt (Anweisung)
  • tt (Tokenbaum)
  • ty (Typ)
  • vis (Sichtbarkeitsqualifizierer)

Für eine vollständige Liste siehe die [Rust Reference].

Zusammenfassung

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