Een belangrijk kenmerk dat Rust krachtig en aantrekkelijker maakt, is de ondersteuning voor structs. Structuren zijn samengestelde gegevenstypen voor het groeperen van gerelateerde gegevens. Hiermee kunt u aangepaste gegevenstypen definiëren met benoemde velden die de codeorganisatie verbeteren en gegevensmanipulatie gemakkelijker maken.
U kunt structs gebruiken om verschillende objecten weer te geven, inclusief door de gebruiker gedefinieerde gegevenstypen en configuraties. Structuren zijn flexibeler dan veel andere datastructuren. Hun vermogen om gerelateerde gegevens in te kapselen, maakt ze nuttig omdat ze een logischer model van objecten uit de echte wereld creëren.
Structuren en structuurvelden definiëren
U definieert een structuur met behulp van de structuur trefwoord gevolgd door een naam voor de structuur. Volg dit door de veldnamen van de structuur en hun Roest gegevenstypen binnen een paar accolades.
structuurPersoon {
naam: Snaar,
leeftijd: u8,
is_student: boel,
}
Dit Persoon struct heeft drie velden. De naam veld is een string, de leeftijd veld is een niet-ondertekend 8-bits geheel getal, en de is_student veld is een Booleaanse waarde.
U kunt struct-literals gebruiken om struct-instanties te maken na de struct-definitie. Struct-literals specificeren de waarden van de velden van een struct.
laten persoon = Persoon {
naam: Snaar::van("John"),
leeftijd: 27,
is_student: WAAR,
};
De persoon variabele is een instantie van de Persoon struct, gemaakt met een letterlijke struct. Deze letterlijke instantiërt alle velden van de structuur met waarden van hun overeenkomstige gegevenstype.
Constructors gebruiken om structuren te maken
U kunt ook een constructorfunctie gebruiken om een instantie van een struct te maken.
impl Persoon {
// Definieer een constructorfunctie `new` waaraan `name`, `age` en
// `is_student`-parameters
fnnieuw(naam: Snaar, leeftijd: u8, is_student: boel) -> Zelf {
// Maak een nieuwe instantie van `Person` struct en initialiseer de velden
// met de opgegeven waarden
Zelf {
naam,
leeftijd,
is_student,
}
}
}
// Roep de `nieuwe` constructorfunctie van de `Person`-structuur aan en wijs de
// resulterende instantie naar `persoon`
laten persoon = Persoon:: nieuw(Snaar::van("John"), 27, WAAR);
Het bovenstaande programma definieert een constructor voor het Persoon struct met de impl trefwoord. De nieuw constructor neemt de struct-velden op als argumenten en retourneert een nieuwe instantie van de struct met de geïnitialiseerde waarden.
U kunt een Persoon bijvoorbeeld met de nieuw constructor, die de juiste argumenten doorgeeft.
Toegang tot en wijziging van structuurvelden
U kunt struct-velden openen en wijzigen met behulp van een puntnotatie. Je gebruikt gewoon de punt (.) operator gevolgd door de naam van het veld om toegang te krijgen tot de waarde of deze te wijzigen.
// declareer een persoonsstructuur
structuurPersoon {
naam: Snaar,
leeftijd: u8,
is_student: boel,
}fnvoornaamst() {
// instantiëren van een struct
latenmuts persoon = Persoon {
naam: Snaar::van("John"),
leeftijd: 27,
is_student: WAAR,
};// druk de naam- en leeftijdsvelden van de structuur af
println!("Naam: {}", persoon.naam);
println!("Leeftijd: {}", persoon.leeftijd);// wijzig het veld is_student
persoon.is_student = vals;
println!("Is leerling: {}", persoon.is_student);
}
Het programma maakt een struct aan, concretiseert de struct, drukt het naam, En leeftijd velden, en wijzigt de is_student veld voordat u het veld afdrukt.
Methoden voor structs declareren
in tegenstelling tot structureert in C, kunt u methoden op Rust-structuren definiëren die op een instantie werken. Methoden zijn functies die verwijzen naar een structuur voor toegang en wijziging. U kunt ook de puntnotatie gebruiken om de methoden van een struct aan te roepen en toegang te krijgen tot hun functionaliteit.
Hier ziet u hoe u methoden voor structs kunt declareren en die methoden kunt gebruiken om bewerkingen uit te voeren:
structuurPersoon {
naam: Snaar,
leeftijd: u8,
is_student: boel,
}impl Persoon {
fnzeg hallo(&zelf) {
println!("Hallo, mijn naam is {} en ik ben {} jaar oud.", zelf.naam,
zelf.leeftijd);
}fnheb_verjaardag(&mutszelf) {
zelf.leeftijd += 1;
}
}fnvoornaamst() {
latenmuts persoon = Persoon {
naam: Snaar::van("John"),
leeftijd: 27,
is_student: WAAR,
};persoon.zeg_hallo();
persoon.have_birthday();
println!("Nieuwe leeftijd: {}", persoon.leeftijd);
}
Het programma definieert twee methoden voor de Persoon structuur. De zeg hallo methode verwijst naar zelf en drukt een begroeting af met de naam en leeftijd van de persoon. De heb_verjaardag methode neemt een veranderlijke verwijzing naar zelf en verhoogt de leeftijd van de persoon.
Het eigendomsmodel van Rust optimaliseert geheugenbeheer
Structs zijn veelzijdige datastructuren, die fungeren als een soort minimaal klassenequivalent.
Net als bij andere Rust-datastructuren, moet u de eigendomsregels van Rust volgen bij het werken met struct-variabelen. Het eigendomsmodel zorgt ervoor dat u het geheugen efficiënt beheert in uw programma's, waardoor veelvoorkomende problemen zoals null- en bungelende aanwijzers worden voorkomen.