Das Entdecken von Rust-Tupeln und der Transposition von Matrizen

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 Labo untersuchen wir Tupel in Rust. Tupel sind Sammlungen von Werten unterschiedlicher Typen und werden mit runden Klammern konstruiert. Sie können als Funktionsargumente und Rückgabewerte verwendet werden, was es Funktionen ermöglicht, mehrere Werte zurückzugeben. Tupel können auch als Elemente anderer Tupel verwendet werden. Rust bietet Tupel-Indexierung an, um auf Werte in einem Tupel zuzugreifen. Tupel sind druckbar und können dekonstruiert werden, um Bindungen zu erstellen. Darüber hinaus lernen wir, wie wir das fmt::Display-Attribut zu einer Struktur hinzufügen, um das Druckformat zu personalisieren. Schließlich erhalten wir eine Aufgabe, um eine transpose-Funktion zu implementieren, die zwei Elemente in einer Matrix tauscht.

Hinweis: Wenn im Labo kein Dateiname angegeben ist, 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/MemorySafetyandManagementGroup(["Memory Safety and Management"]) rust/BasicConceptsGroup -.-> rust/variable_declarations("Variable Declarations") rust/DataTypesGroup -.-> rust/integer_types("Integer Types") rust/DataTypesGroup -.-> rust/floating_types("Floating-point Types") rust/DataTypesGroup -.-> rust/boolean_type("Boolean Type") 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/MemorySafetyandManagementGroup -.-> rust/lifetime_specifiers("Lifetime Specifiers") subgraph Lab Skills rust/variable_declarations -.-> lab-99193{{"Das Entdecken von Rust-Tupeln und der Transposition von Matrizen"}} rust/integer_types -.-> lab-99193{{"Das Entdecken von Rust-Tupeln und der Transposition von Matrizen"}} rust/floating_types -.-> lab-99193{{"Das Entdecken von Rust-Tupeln und der Transposition von Matrizen"}} rust/boolean_type -.-> lab-99193{{"Das Entdecken von Rust-Tupeln und der Transposition von Matrizen"}} rust/type_casting -.-> lab-99193{{"Das Entdecken von Rust-Tupeln und der Transposition von Matrizen"}} rust/function_syntax -.-> lab-99193{{"Das Entdecken von Rust-Tupeln und der Transposition von Matrizen"}} rust/expressions_statements -.-> lab-99193{{"Das Entdecken von Rust-Tupeln und der Transposition von Matrizen"}} rust/lifetime_specifiers -.-> lab-99193{{"Das Entdecken von Rust-Tupeln und der Transposition von Matrizen"}} end

Tupel

Ein Tupel ist eine Sammlung von Werten unterschiedlicher Typen. Tupel werden mit runden Klammern () konstruiert, und jedes Tupel selbst ist ein Wert mit dem Typsignatur (T1, T2,...), wobei T1, T2 die Typen seiner Elemente sind. Funktionen können Tupel verwenden, um mehrere Werte zurückzugeben, da Tupel beliebig viele Werte aufnehmen können.

// Tupel können als Funktionsargumente und als Rückgabewerte verwendet werden.
fn reverse(pair: (i32, bool)) -> (bool, i32) {
    // `let` kann verwendet werden, um die Elemente eines Tupels an Variablen zu binden.
    let (int_param, bool_param) = pair;

    (bool_param, int_param)
}

// Die folgende Struktur ist für die Aufgabe.
#[derive(Debug)]
struct Matrix(f32, f32, f32, f32);

fn main() {
    // Ein Tupel mit einer Reihe unterschiedlicher Typen.
    let long_tuple = (1u8, 2u16, 3u32, 4u64,
                      -1i8, -2i16, -3i32, -4i64,
                      0.1f32, 0.2f64,
                      'a', true);

    // Werte können aus dem Tupel mit der Tupel-Indexierung extrahiert werden.
    println!("Erstes Wert des langen Tupels: {}", long_tuple.0);
    println!("Zweites Wert des langen Tupels: {}", long_tuple.1);

    // Tupel können Elemente von anderen Tupeln sein.
    let tuple_of_tuples = ((1u8, 2u16, 2u32), (4u64, -1i8), -2i16);

    // Tupel sind druckbar.
    println!("Tupel von Tupeln: {:?}", tuple_of_tuples);

    // Aber lange Tupel (mehr als 12 Elemente) können nicht gedruckt werden.
    //let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
    //println!("Zu langes Tupel: {:?}", too_long_tuple);
    // TODO ^ Entkommentieren Sie die obigen 2 Zeilen, um den Compilerfehler zu sehen

    let pair = (1, true);
    println!("Das Paar ist {:?}", pair);

    println!("Das umgekehrte Paar ist {:?}", reverse(pair));

    // Um ein Tupel mit einem Element zu erstellen, ist das Komma erforderlich, um es
    // von einem Literal, das von Klammern umgeben ist, zu unterscheiden.
    println!("Tupel mit einem Element: {:?}", (5u32,));
    println!("Nur eine Ganzzahl: {:?}", (5u32));

    // Tupel können dekonstruiert werden, um Bindungen zu erstellen.
    let tuple = (1, "hello", 4.5, true);

    let (a, b, c, d) = tuple;
    println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d);

    let matrix = Matrix(1.1, 1.2, 2.1, 2.2);
    println!("{:?}", matrix);
}

Aufgabe

  1. Wiederholung: Fügen Sie das fmt::Display-Attribut zur Matrix-Struktur im obigen Beispiel hinzu, so dass wenn Sie von der Ausgabe im Debug-Format {:?} zur Ausgabe im Anzeigeformat {} wechseln, Sie die folgende Ausgabe erhalten:

    ( 1.1 1.2 )
    ( 2.1 2.2 )

    Sie können sich an das Beispiel zur Ausgabe im Anzeigeformat erinnern.

  2. Fügen Sie eine transpose-Funktion hinzu, die die reverse-Funktion als Vorlage verwendet, die einen Matrix als Argument akzeptiert und eine Matrix zurückgibt, in der zwei Elemente getauscht wurden. Beispielsweise:

    println!("Matrix:\n{}", matrix);
    println!("Transponiert:\n{}", transpose(matrix));

    Dies führt zu der Ausgabe:

    Matrix:
    ( 1.1 1.2 )
    ( 2.1 2.2 )
    Transponiert:
    ( 1.1 2.1 )
    ( 1.2 2.2 )

Zusammenfassung

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