Home-theater-designers
En nyckelfunktion som gör Rust kraftfull och mer tilltalande är dess stöd för strukturer. Strukturer är sammansatta datatyper för att gruppera relaterade data. De låter dig definiera anpassade datatyper med namngivna fält som förbättrar kodorganisationen och gör datamanipulation enklare.
Du kan använda strukturer för att representera olika objekt, inklusive användardefinierade datatyper och konfigurationer. Strukturer är mer flexibla än många andra datastrukturer. Deras förmåga att kapsla in relaterade data gör dem användbara eftersom de skapar en mer logisk modell av verkliga objekt.
Definiera strukturer och strukturfält
Du kommer att definiera en struktur genom att använda struktur nyckelord följt av ett namn för strukturen. Följ detta genom att ange strukturens fältnamn och deras Rostdatatyper inuti ett par lockiga hängslen.
struct Person {
name: String,
age: u8,
is_student: bool,
}
Detta Person struct har tre fält. De namn fältet är en sträng, den ålder fältet är ett osignerat 8-bitars heltal, och är_student fältet är ett booleskt fält.
blå skärm kritisk process dog windows 10
Du kan använda struct-literals för att skapa struct-instanser efter struct-definitionen. Struct literals anger värdena för en strukturs fält.
let person = Person {
name: String::from("John"),
age: 27,
is_student: true,
};
De person variabel är en instans av Person struct, skapad med en struct literal. Denna bokstavliga instansierar alla fält i strukturen med värden av deras motsvarande datatyp.
Använda konstruktörer för att skapa strukturer
Du kan också använda en konstruktorfunktion för att skapa en instans 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 ovan definierar en konstruktor för Person strukturera med impl nyckelord. De ny konstruktorn tar in struct-fälten som argument och returnerar en ny instans av struct med de initialiserade värdena.
Du kan skapa en Person exempel med ny konstruktör och skickar lämpliga argument till den.
Åtkomst till och modifiering av strukturfält
Du kan komma åt och ändra strukturfält med hjälp av en punktnotation. Du använder bara pricken ( . ) operator följt av fältets namn för att komma åt eller ändra dess värde.
// 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 skapar en struktur, instansierar strukturen, skriver ut namn, och ålder fält och ändrar är_student innan du skriver ut fältet.
hur tar jag bort alla bilder på mac
Deklarera metoder för strukturer
Till skillnad från strukturer i C , kan du definiera metoder på Rust-strukturer som fungerar på en instans. Metoder är funktioner som tar en referens till en struktur för åtkomst och modifiering. Du kan också använda punktnotationen för att anropa metoderna för en struktur och få tillgång till deras funktionalitet.
Så här kan du deklarera metoder för strukturer och använda dessa metoder för att utföra operationer:
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 definierar två metoder för Person struktur. De Säg hej metod tar en hänvisning till själv och skriver ut en hälsning som innehåller personens namn och ålder. De har_födelsedag metod tar en föränderlig referens till själv och ökar personens ålder.
Rusts ägarmodell optimerar minneshantering
Strukturer är mångsidiga datastrukturer som fungerar som en sorts minimal klassekvivalent.
Som med andra Rust-datastrukturer bör du följa Rusts ägarskapsregler när du arbetar med strukturvariabler. Ägarskapsmodellen säkerställer att du hanterar minnet effektivt i dina program, vilket förhindrar vanliga problem som null och hängande pekare.