Ein Schlüsselmerkmal, das Rust leistungsfähiger und ansprechender macht, ist die Unterstützung von Strukturen. Strukturen sind zusammengesetzte Datentypen zum Gruppieren zusammengehöriger Daten. Sie ermöglichen es Ihnen, benutzerdefinierte Datentypen mit benannten Feldern zu definieren, die die Codeorganisation verbessern und die Datenmanipulation vereinfachen.
Sie können Strukturen verwenden, um verschiedene Objekte darzustellen, einschließlich benutzerdefinierter Datentypen und Konfigurationen. Strukturen sind flexibler als viele andere Datenstrukturen. Ihre Fähigkeit, verwandte Daten zu kapseln, macht sie nützlich, da sie ein logischeres Modell realer Objekte erstellen.
Strukturen und Strukturfelder definieren
Sie definieren eine Struktur, indem Sie die verwenden Struktur Schlüsselwort gefolgt von einem Namen für die Struktur. Anschließend geben Sie die Feldnamen der Struktur und deren
Rust-Datentypen in einem Paar geschweifter Klammern.StrukturPerson {
Name: Schnur,
Alter: u8,
ist_Student: bool,
}
Das Person struct hat drei Felder. Der Name Feld ist eine Zeichenfolge, die Alter -Feld ist eine vorzeichenlose 8-Bit-Ganzzahl, und die ist_Student Feld ist ein boolescher Wert.
Sie können Strukturliterale verwenden, um Strukturinstanzen nach der Strukturdefinition zu erstellen. Strukturliterale geben die Werte der Felder einer Struktur an.
lassen Person = Person {
Name: Schnur::aus("John"),
Alter: 27,
ist_Student: WAHR,
};
Der Person Variable ist eine Instanz von Person struct, erstellt mit einem Struct-Literal. Dieses Literal instanziiert alle Felder der Struktur mit Werten ihres entsprechenden Datentyps.
Verwenden von Konstruktoren zum Erstellen von Strukturen
Sie können auch eine Konstruktorfunktion verwenden, um eine Instanz einer Struktur zu erstellen.
impl Person {
// Definiere eine Konstruktorfunktion `new`, die `name`, `age` und akzeptiert
// `is_student`-Parameter
fnneu(Name: Schnur, Alter: u8, ist_student: bool) -> Selbst {
// Erstellen Sie eine neue Instanz der `Person`-Struktur und initialisieren Sie ihre Felder
// mit den bereitgestellten Werten
Selbst {
Name,
Alter,
ist_Student,
}
}
}
// Rufe die `new`-Konstruktorfunktion der `Person`-Struktur auf und weise die zu
// resultierende Instanz zu `person`
lassen Person = Person:: neu(Schnur::aus("John"), 27, WAHR);
Das obige Programm definiert einen Konstruktor für die Person Struktur mit der impl Stichwort. Der neu Der Konstruktor übernimmt die Strukturfelder als Argumente und gibt eine neue Instanz der Struktur mit den initialisierten Werten zurück.
Sie können eine erstellen Person Beispiel mit der neu Konstruktor und übergibt ihm die entsprechenden Argumente.
Zugreifen auf und Ändern von Strukturfeldern
Sie können mithilfe einer Punktnotation auf Strukturfelder zugreifen und diese ändern. Sie verwenden einfach den Punkt (.)-Operator, gefolgt vom Namen des Felds, um auf seinen Wert zuzugreifen oder ihn zu ändern.
// Deklarieren Sie eine Person-Struktur
StrukturPerson {
Name: Schnur,
Alter: u8,
ist_Student: bool,
}fnhauptsächlich() {
// eine Struktur instanziieren
lassenmut Person = Person {
Name: Schnur::aus("John"),
Alter: 27,
ist_Student: WAHR,
};// Namens- und Altersfelder der Struktur ausgeben
drucken!("Name: {}", Name der Person);
drucken!("Alter: {}", person.alter);// das is_student-Feld ändern
person.ist_student = FALSCH;
drucken!("Ist Student: {}", person.ist_student);
}
Das Programm erstellt eine Struktur, instanziiert die Struktur, druckt die Name, Und Alter Felder und modifiziert die ist_Student Feld, bevor Sie das Feld drucken.
Methoden für Strukturen deklarieren
nicht wie Strukturen in C, können Sie Methoden für Rust-Strukturen definieren, die auf einer Instanz ausgeführt werden. Methoden sind Funktionen, die einen Verweis auf eine Struktur für den Zugriff und die Änderung verwenden. Sie können auch die Punktnotation verwenden, um die Methoden einer Struktur aufzurufen und auf ihre Funktionalität zuzugreifen.
So können Sie Methoden für Strukturen deklarieren und diese Methoden verwenden, um Operationen auszuführen:
StrukturPerson {
Name: Schnur,
Alter: u8,
ist_Student: bool,
}impl Person {
fnsag Hallo(&selbst) {
drucken!("Hallo, mein Name ist {} und ich bin {} Jahre alt.", selbst.Name,
selbst.Alter);
}fnhabe_geburtstag(&mutselbst) {
selbst.Alter += 1;
}
}fnhauptsächlich() {
lassenmut Person = Person {
Name: Schnur::aus("John"),
Alter: 27,
ist_Student: WAHR,
};Person.Sag_Hallo();
person.have_birthday();
drucken!("Neues Zeitalter: {}", person.alter);
}
Das Programm definiert zwei Methoden für die Person Struktur. Der sag Hallo Methode nimmt einen Verweis auf selbst und druckt eine Begrüßung, die den Namen und das Alter der Person enthält. Der habe_geburtstag Methode nimmt einen veränderlichen Verweis auf selbst und erhöht das Alter der Person.
Das Eigentumsmodell von Rust optimiert die Speicherverwaltung
Strukturen sind vielseitige Datenstrukturen, die als eine Art minimales Klassenäquivalent fungieren.
Wie bei anderen Rust-Datenstrukturen sollten Sie beim Arbeiten mit Strukturvariablen die Eigentumsregeln von Rust befolgen. Das Eigentumsmodell stellt sicher, dass Sie den Arbeitsspeicher in Ihren Programmen effizient verwalten und allgemeine Probleme wie Null- und baumelnde Zeiger vermeiden.
