La décomposition avec déplacement partiel en Rust

RustRustBeginner
Pratiquer maintenant

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

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire, nous apprenons les déplacements partiels dans la décomposition d'une seule variable, où les liaisons de modèle by-move et by-reference peuvent être utilisées simultanément. Cela entraîne un déplacement partiel de la variable, permettant à certaines parties d'être déplacées tandis que d'autres peuvent toujours être référencées. Si une variable parent est partiellement déplacée, elle ne peut plus être utilisée dans son ensemble ensuite, mais les parties qui ne sont que référencées et non déplacées peuvent toujours être utilisées.

Note : Si le laboratoire ne spécifie pas de nom de fichier, vous pouvez utiliser n'importe quel nom de fichier que vous voulez. Par exemple, vous pouvez utiliser main.rs, le compiler et l'exécuter avec rustc main.rs &&./main.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL rust(("Rust")) -.-> rust/MemorySafetyandManagementGroup(["Memory Safety and Management"]) rust(("Rust")) -.-> rust/DataStructuresandEnumsGroup(["Data Structures and Enums"]) rust(("Rust")) -.-> rust/DataTypesGroup(["Data Types"]) rust(("Rust")) -.-> rust/FunctionsandClosuresGroup(["Functions and Closures"]) rust(("Rust")) -.-> rust/AdvancedTopicsGroup(["Advanced Topics"]) rust(("Rust")) -.-> rust/BasicConceptsGroup(["Basic Concepts"]) rust/BasicConceptsGroup -.-> rust/variable_declarations("Variable Declarations") rust/DataTypesGroup -.-> rust/integer_types("Integer Types") rust/DataTypesGroup -.-> rust/string_type("String 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") rust/DataStructuresandEnumsGroup -.-> rust/method_syntax("Method Syntax") rust/AdvancedTopicsGroup -.-> rust/operator_overloading("Traits for Operator Overloading") subgraph Lab Skills rust/variable_declarations -.-> lab-99197{{"La décomposition avec déplacement partiel en Rust"}} rust/integer_types -.-> lab-99197{{"La décomposition avec déplacement partiel en Rust"}} rust/string_type -.-> lab-99197{{"La décomposition avec déplacement partiel en Rust"}} rust/type_casting -.-> lab-99197{{"La décomposition avec déplacement partiel en Rust"}} rust/function_syntax -.-> lab-99197{{"La décomposition avec déplacement partiel en Rust"}} rust/expressions_statements -.-> lab-99197{{"La décomposition avec déplacement partiel en Rust"}} rust/lifetime_specifiers -.-> lab-99197{{"La décomposition avec déplacement partiel en Rust"}} rust/method_syntax -.-> lab-99197{{"La décomposition avec déplacement partiel en Rust"}} rust/operator_overloading -.-> lab-99197{{"La décomposition avec déplacement partiel en Rust"}} end

Déplacements partiels

Dans la [décomposition] d'une seule variable, les liaisons de modèle by-move et by-reference peuvent être utilisées en même temps. Cela entraînera un déplacement partiel de la variable, ce qui signifie que certaines parties de la variable seront déplacées tandis que d'autres resteront. Dans un tel cas, la variable parent ne peut plus être utilisée ensuite dans son ensemble, cependant les parties qui ne sont que référencées (et non déplacées) peuvent toujours être utilisées.

fn main() {
    #[derive(Debug)]
    struct Person {
        name: String,
        age: Box<u8>,
    }

    let person = Person {
        name: String::from("Alice"),
        age: Box::new(20),
    };

    // `name` est déplacé de `person`, mais `age` est référencé
    let Person { name, ref age } = person;

    println!("L'âge de la personne est {}", age);

    println!("Le nom de la personne est {}", name);

    // Erreur! emprunt d'une valeur partiellement déplacée : `person` le déplacement partiel se produit
    //println!("La structure personne est {:?}", person);

    // `person` ne peut pas être utilisée mais `person.age` peut l'être car il n'est pas déplacé
    println!("L'âge de la personne à partir de la structure personne est {}", person.age);
}

(Dans cet exemple, nous stockons la variable age sur le tas pour illustrer le déplacement partiel : supprimer ref dans le code ci-dessus entraînerait une erreur car la propriété de person.age serait déplacée vers la variable age. Si Person.age était stocké sur la pile, ref ne serait pas nécessaire car la définition de age copierait les données de person.age sans les déplacer.)

Sommaire

Félicitations ! Vous avez terminé le laboratoire sur les Déplacements partiels. Vous pouvez pratiquer d'autres laboratoires dans LabEx pour améliorer vos compétences.