Learn Rust Coding · Leçon

Définir et utiliser des structures

Créez des structures de données personnalisées avec des structures, notamment des structures-tuple et des structures semblables à des unités, afin de regrouper des données connexes.

Définir et utiliser des structures est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 3 leçons au total.

Découvrez les structures : types de données personnalisés

Dans Rust, les structures (abrégées en « structs ») permettent de créer des types de données personnalisés qui associent plusieurs valeurs liées au sein d'un groupe cohérent.

Imaginez une structure comme un plan pour un User, une Color ou un Point dans l'espace. Au lieu d'avoir des variables distinctes pour le nom, l'adresse e-mail et l'âge d'un User, vous pouvez toutes les regrouper dans une structure User.

Cela vous aide à organiser logiquement vos données et à rendre votre code plus facile à lire et à maintenir.

Définir une structure classique

Le type de structure le plus courant est la structure classique, dans laquelle vous nommez chaque élément de donnée, appelé un champ. Voici comment en définir une :

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    // This code only defines the struct blueprint.
    // No actual user has been created yet!
    println!("Struct 'User' blueprint defined.");
}

Créer des instances de structure

Une fois une structure définie, vous pouvez en créer des instances concrètes. Chaque instance contient des valeurs précises pour ses champs. Pour créer une instance, vous devez indiquer une valeur concrète pour chaque champ.

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };
    println!("User instance created!");
}

Accéder aux champs d'une structure

Pour extraire des données d'une instance de structure, vous utilisez la notation avec un point. Il suffit d'écrire le nom de l'instance, un point (.), puis le nom du champ.

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };
    println!("User's username: {}", user1.username);
    println!("User's email: {}", user1.email);
}

La mutabilité avec les structures

Comme les variables ordinaires, les instances de structure entières peuvent être rendues mutables à l'aide du mot-clé mut. Si une instance est mutable, tous ses champs peuvent être modifiés.

Vous ne pouvez pas rendre seulement certains champs mutables : la mutabilité s'applique à l'ensemble de l'instance de structure.

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let mut user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };
    
    println!("Old email: {}", user1.email);
    user1.email = String::from("new_alice@example.com");
    println!("New email: {}", user1.email);
}

Structures tuple : champs sans nom

Les structures tuple sont une autre forme de structure. Elles ressemblent aux tuples, mais possèdent un nom. Elles sont utiles lorsque vous voulez donner à un tuple un nom de type distinct, sans avoir besoin de nommer chacun de ses champs.

Par exemple, Color(i32, i32, i32) est un tuple nommé qui regroupe trois entiers.

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
    println!("Tuple structs 'Color' and 'Point' defined.");
}

Utiliser des structures tuple

Créer une instance d'une structure tuple ressemble à la création d'un tuple ordinaire. Pour accéder aux valeurs qu'elle contient, vous utilisez la notation avec un point et leur indice, en commençant par 0.

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);

    println!("Black color: R={}, G={}, B={}", black.0, black.1, black.2);
    println!("Origin point: X={}, Y={}, Z={}", origin.0, origin.1, origin.2);
}

Structures de type unité : marqueurs

Vous pouvez également définir des structures qui ne possèdent aucun champ. Elles sont appelées structures de type unité, car elles se comportent de manière similaire au type unité ().

Elles servent souvent de marqueurs pour implémenter un trait particulier sur un type, lorsque les données elles-mêmes n'ont pas d'importance.

struct AlwaysTrue;

fn main() {
    let subject = AlwaysTrue;
    // Unit-like structs don't store data directly,
    // but they can be instantiated and used as types.
    println!("Unit-like struct 'AlwaysTrue' created.");
}

Syntaxe de mise à jour des structures

Si vous devez créer une nouvelle instance de structure à partir d'une instance existante, tout en ne modifiant que certaines valeurs de champs, Rust propose une syntaxe pratique de mise à jour des structures (..).

Cette syntaxe déplace les champs restants depuis l'instance indiquée. L'instance d'origine ne peut donc plus être utilisée si elle contient des champs qui implémentent Copy.

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        email: String::from("bob@example.com"),
        username: String::from("bob456"),
        ..user1 // Copy remaining fields from user1
    };

    println!("User 2 email: {}", user2.email);
    println!("User 2 active: {}", user2.active);
    // user1.username is now moved, so user1 can't be used here.
}

Quiz sur les structures

Testez votre compréhension des structures Rust.

Récapitulatif : présentation des structures

Vous avez appris à définir et à utiliser des structures en Rust !

Les structures classiques regroupent des champs nommés pour créer des types de données personnalisés.
Les structures tuple sont des tuples nommés, utiles lorsque les noms des champs ne sont pas indispensables.
Les structures de type unité n'ont aucun champ et servent de marqueurs.
Les instances de structure peuvent être rendues mut afin d'autoriser la modification de leurs champs.
La syntaxe .. permet de créer de nouvelles instances à partir d'instances existantes.

Les structures sont fondamentales pour organiser les données liées dans les programmes Rust, ce qui rend votre code plus structuré et plus lisible.

Questions Fréquemment Posées

La leçon « Définir et utiliser des structures » est-elle gratuite ?

Oui — le texte complet de « Définir et utiliser des structures » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Définir et utiliser des structures » ?

Créez des structures de données personnalisées avec des structures, notamment des structures-tuple et des structures semblables à des unités, afin de regrouper des données connexes. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.

Combien de temps prend la leçon « Définir et utiliser des structures » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Définir et utiliser des structures
Énumérations pour les types personnalisés
Appariement de motifs puissant

← Retour à Learn Rust Coding