Home-theater-designers
En nøkkelfunksjon som gjør Rust kraftig og mer tiltalende er støtten for strukturer. Strukturer er sammensatte datatyper for gruppering av relaterte data. De lar deg definere egendefinerte datatyper med navngitte felt som forbedrer kodeorganisering og gjør datamanipulering enklere.
Du kan bruke strukturer til å representere ulike objekter, inkludert brukerdefinerte datatyper og konfigurasjoner. Strukturer er mer fleksible enn mange andre datastrukturer. Deres evne til å kapsle inn relaterte data gjør dem nyttige siden de lager en mer logisk modell av virkelige objekter.
Definere strukturer og strukturfelt
Du definerer en struktur ved å bruke struktur nøkkelord etterfulgt av et navn for strukturen. Følg dette ved å spesifisere strukturens feltnavn og deres Rustdatatyper inne i et par krøllete seler.
struct Person {
name: String,
age: u8,
is_student: bool,
}
Dette Person struct har tre felt. De Navn feltet er en streng, den alder feltet er et usignert 8-bits heltall, og er_student felt er en boolsk.
Du kan bruke struct-literaler til å lage struct-forekomster etter struct-definisjonen. Structure literals spesifiserer verdiene til en strukturs felt.
let person = Person {
name: String::from("John"),
age: 27,
is_student: true,
};
De person variabel er en forekomst av Person struct, opprettet med en struct bokstavelig. Denne bokstavelige instansierer alle feltene i strukturen med verdier for deres tilsvarende datatype.
Bruke konstruktører til å lage strukturer
Du kan også bruke en konstruktørfunksjon for å lage en forekomst av en struktur.
impl Person {
// Define a constructor function `new` that takes `name`, `age` and
// `is_student` parameters
fn new(name: String, age: u8, is_student: bool) -> Self {
// Create a new instance of `Person` struct and initialize its fields
// with the provided values
Self {
name,
age,
is_student,
}
}
}
// Call the `new` constructor function of the `Person` struct and assign the
// resulting instance to `person`
let person = Person::new(String::from("John"), 27, true);
Programmet ovenfor definerer en konstruktør for Person struktur med impl nøkkelord. De ny konstruktør tar inn struct-feltene som argumenter og returnerer en ny forekomst av strukturen med de initialiserte verdiene.
hvilket kodingsspråk bruker enhet
Du kan lage en Person eksempel med ny konstruktør, sender den passende argumenter.
Få tilgang til og endre strukturfelt
Du kan få tilgang til og endre strukturfelt ved å bruke en punktnotasjon. Du bruker bare prikken ( . ) operatør etterfulgt av feltets navn for å få tilgang til eller endre verdien.
// declare a Person struct
struct Person {
name: String,
age: u8,
is_student: bool,
}
fn main() {
// instantiate a struct
let mut person = Person {
name: String::from("John"),
age: 27,
is_student: true,
};
// print the name and age fields of the struct
println!("Name: {}", person.name);
println!("Age: {}", person.age);
// modifiy the is_student field
person.is_student = false;
println!("Is student: {}", person.is_student);
}
Programmet lager en struktur, instansierer strukturen, skriver ut Navn, og alder felt, og endrer er_student feltet før du skriver ut feltet.
Erklæringsmetoder for konstruksjoner
I motsetning til strukturer i C , kan du definere metoder på Rust-strukturer som opererer på en forekomst. Metoder er funksjoner som tar en referanse til en struktur for tilgang og modifikasjon. Du kan også bruke punktnotasjonen til å kalle metodene til en struktur og få tilgang til funksjonaliteten deres.
Slik kan du deklarere metoder for strukturer og bruke disse metodene til å utføre operasjoner:
struct Person {
name: String,
age: u8,
is_student: bool,
}
impl Person {
fn say_hello(&self) {
println!("Hello, my name is {} and I'm {} years old.", self.name,
self.age);
}
fn have_birthday(&mut self) {
self.age += 1;
}
}
fn main() {
let mut person = Person {
name: String::from("John"),
age: 27,
is_student: true,
};
person.say_hello();
person.have_birthday();
println!("New age: {}", person.age);
}
Programmet definerer to metoder for Person struktur. De si hei metode tar en referanse til selv- og skriver ut en hilsen som inkluderer personens navn og alder. De har_bursdag metoden tar en foranderlig referanse til selv- og øker personens alder.
Rusts eierskapsmodell optimaliserer minnehåndtering
Strukturer er allsidige datastrukturer, som fungerer som en slags minimal klasseekvivalent.
Som med andre Rust-datastrukturer, bør du følge Rusts eierskapsregler når du arbeider med strukturvariabler. Eierskapsmodellen sikrer at du administrerer minnet effektivt i programmene dine, og forhindrer vanlige problemer som null og hengende pekere.