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.
strukturPerson {
namn: Sträng,
ålder: 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.
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.
låta person = Person {
namn: Sträng::från("John"),
ålder: 27,
is_student: Sann,
};
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 {
// Definiera en konstruktorfunktion `new` som tar `name`, `age` och
// `is_student` parametrar
fnny(namn: Sträng, ålder: u8, is_student: bool) -> Själv {
// Skapa en ny instans av `Person`-strukturen och initiera dess fält
// med de angivna värdena
Själv {
namn,
ålder,
är_student,
}
}
}
// Anropa den `nya` konstruktorfunktionen för `Person`-strukturen och tilldela
// resulterar instans till "person".
låta person = Person:: ny(Sträng::från("John"), 27, Sann);
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.
// deklarera en personstruktur
strukturPerson {
namn: Sträng,
ålder: u8,
is_student: bool,
}fnhuvud() {
// instansiera en struktur
låtamut person = Person {
namn: Sträng::från("John"),
ålder: 27,
is_student: Sann,
};// skriv ut namn- och åldersfälten för strukturen
println!("Namn: {}", person.namn);
println!("Ålder: {}", person.ålder);// ändra fältet is_student
person.is_student = falsk;
println!("Är 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.
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:
strukturPerson {
namn: Sträng,
ålder: u8,
is_student: bool,
}impl Person {
fnSäg hej(&själv) {
println!("Hej, jag heter {} och jag är {} år gammal.", själv.namn,
själv.ålder);
}fnhar_födelsedag(&mutsjälv) {
själv.age += 1;
}
}fnhuvud() {
låtamut person = Person {
namn: Sträng::från("John"),
ålder: 27,
is_student: Sann,
};person.say_hello();
person.have_birthday();
println!("Ny tid: {}", person.ålder);
}
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.
