Leer programmeren met Rust · Les

Structs definiëren en gebruiken

Maak aangepaste gegevensstructuren met structs, waaronder tuple structs en unit-like structs, om verwante gegevens te groeperen.

Les 1 van 311 stappen

Structs definiëren en gebruiken is een gratis Leer programmeren met Rust-les op CoddyKit. Dit is les 1 van 3. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Leer programmeren met Rust. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Leer programmeren met Rust bevat in totaal 3 lessen.

Maak kennis met structs: aangepaste gegevenstypen

In Rust zijn structs (een afkorting van structures) een manier om aangepaste gegevenstypen te maken waarmee je meerdere gerelateerde waarden een naam kunt geven en kunt samenbrengen in een betekenisvolle groep.

Zie een struct als een blauwdruk voor een gebruiker, een kleur of een punt in de ruimte. In plaats van afzonderlijke variabelen te hebben voor de naam, het e-mailadres en de leeftijd van een gebruiker, kun je ze allemaal in een User-struct plaatsen.

Zo organiseer je je gegevens logisch en maak je je code gemakkelijker te lezen en te onderhouden.

Een klassieke struct definiëren

Het meest voorkomende type struct is een klassieke struct, waarin je elk stukje gegevens een naam geeft. Zo'n stukje heet een veld. Zo definieer je er een:

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.");
}

Structinstanties maken

Nadat je een struct hebt gedefinieerd, kun je concrete instanties ervan maken. Elke instantie bevat specifieke waarden voor zijn velden. Je maakt een instantie door voor elk veld een concrete waarde op te geven.

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!");
}

Structvelden benaderen

Om gegevens uit een structinstantie te halen, gebruik je puntnotatie. Typ simpelweg de naam van de instantie, een punt (.) en vervolgens de naam van het veld.

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);
}

Mutabiliteit met structs

Net als gewone variabelen kunnen volledige structinstanties mutabel worden gemaakt met het sleutelwoord mut. Als een instantie mutabel is, kunnen al zijn velden worden gewijzigd.

Je kunt niet alleen bepaalde velden mutabel maken; de mutabiliteit geldt voor de structinstantie als geheel.

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);
}

Tuplestructs: velden zonder naam

Tuplestructs zijn een andere vorm van struct die eruitziet als een tuple, maar een naam heeft. Ze zijn handig wanneer je een tuple een eigen typenaam wilt geven, maar de afzonderlijke velden geen naam hoeven te hebben.

Color(i32, i32, i32) is bijvoorbeeld een benoemde tuple die drie gehele getallen groepeert.

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.");
}

Tuplestructs gebruiken

Een instantie van een tuplestruct maken lijkt op het maken van een gewone tuple. Om toegang te krijgen tot de waarden erin, gebruik je puntnotatie met hun index, vanaf 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);
}

Structs zonder velden: markeringen

Je kunt ook structs definiëren die helemaal geen velden hebben. Deze worden unitachtige structs genoemd omdat ze zich vergelijkbaar gedragen als het unittype ().

Ze worden vaak gebruikt als markeringen om een bepaalde trait voor een type te implementeren, wanneer de gegevens zelf niet belangrijk zijn.

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.");
}

Syntaxis voor structupdates

Als je een nieuwe structinstantie wilt maken op basis van een bestaande instantie, maar slechts enkele veldwaarden wilt wijzigen, biedt Rust een handige syntaxis voor structupdates (..).

Met deze syntaxis worden de overige velden verplaatst vanuit de opgegeven instantie. Daardoor kan de oorspronkelijke instantie niet meer worden gebruikt als deze velden bevat die Copy implementeren.

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.
}

Structquiz

Test je begrip van Rust-structs.

Beantwoord dit in de interactieve les

Samenvatting: overzicht van structs

Je hebt geleerd hoe je structs in Rust definieert en gebruikt!

Klassieke structs groeperen benoemde velden om aangepaste gegevenstypen te maken.
Tuplestructs zijn benoemde tuples, handig wanneer veldnamen niet strikt noodzakelijk zijn.
Unitachtige structs hebben geen velden en dienen als markeringen.
Structinstanties kunnen mut worden gemaakt om wijzigingen in hun velden toe te staan.
Met de syntaxis .. kun je nieuwe instanties maken op basis van bestaande instanties.

Structs zijn essentieel voor het organiseren van gerelateerde gegevens in Rust-programma's, waardoor je code gestructureerder en beter leesbaar wordt.

Gratis beginnen

Leer Rust met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 39
Lessen: 144

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Structs definiëren en gebruiken” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Leer programmeren met Rust, waaronder “Structs definiëren en gebruiken”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Leer programmeren met Rust bevat in totaal 3 lessen.

Wat leer ik in “Structs definiëren en gebruiken”?

Maak aangepaste gegevensstructuren met structs, waaronder tuple structs en unit-like structs, om verwante gegevens te groeperen. Je oefent met Leer programmeren met Rust door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Leer programmeren met Rust te beginnen?

Ervaring vooraf is niet nodig. Leer programmeren met Rust op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 3.

Hoe lang duurt de les “Structs definiëren en gebruiken”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Leer programmeren met Rust?

Ja. Elke les over Leer programmeren met Rust bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Leer programmeren met Rust