Rost - Struktur

Arrays werden verwendet, um eine homogene Sammlung von Werten darzustellen. In ähnlicher Weise ist eine Struktur ein anderer benutzerdefinierter Datentyp, der in Rust verfügbar ist und es uns ermöglicht, Datenelemente verschiedener Typen, einschließlich einer anderen Struktur, zu kombinieren. Eine Struktur definiert Daten als Schlüssel-Wert-Paar.

Syntax - Deklarieren einer Struktur

Das Schlüsselwort struct wird verwendet, um eine Struktur zu deklarieren. Da Strukturen statisch typisiert sind, muss jedes Feld in der Struktur einem Datentyp zugeordnet werden. Die Namensregeln und Konventionen für eine Struktur ähneln denen einer Variablen. Der Strukturblock muss mit einem Semikolon enden.

struct Name_of_structure {
   field1:data_type,
   field2:data_type,
   field3:data_type
}

Syntax - Initialisieren einer Struktur

Nach dem Deklarieren einer Struktur sollte jedem Feld ein Wert zugewiesen werden. Dies wird als Initialisierung bezeichnet.

let instance_name = Name_of_structure {
   field1:value1,
   field2:value2,
   field3:value3
}; 
//NOTE the semicolon
Syntax: Accessing values in a structure
Use the dot notation to access value of a specific field.
instance_name.field1
Illustration
struct Employee {
   name:String,
   company:String,
   age:u32
}
fn main() {
   let emp1 = Employee {
      company:String::from("TutorialsPoint"),
      name:String::from("Mohtashim"),
      age:50
   };
   println!("Name is :{} company is {} age is {}",emp1.name,emp1.company,emp1.age);
}

Das obige Beispiel deklariert einen strukturierten Mitarbeiter mit drei Feldern - Name, Firma und Alter der Typen. Das main () initialisiert die Struktur. Es verwendet den Druck! Makro zum Drucken der Werte der in der Struktur definierten Felder.

Ausgabe

Name is :Mohtashim company is TutorialsPoint age is 50

Ändern einer Strukturinstanz

Um eine Instanz zu ändern, sollte die Instanzvariable als veränderbar markiert werden. Das folgende Beispiel deklariert und initialisiert eine Struktur namens Mitarbeiter und später modifiziert Wert des Altersfeldes auf 40 von 50.

let mut emp1 = Employee {
   company:String::from("TutorialsPoint"),
   name:String::from("Mohtashim"),
   age:50
};
emp1.age = 40;
println!("Name is :{} company is {} age is 
{}",emp1.name,emp1.company,emp1.age);

Ausgabe

Name is :Mohtashim company is TutorialsPoint age is 40

Übergeben einer Struktur an eine Funktion

Das folgende Beispiel zeigt, wie eine Instanz von struct als Parameter übergeben wird. Die Anzeigemethode verwendet eine Employee-Instanz als Parameter und druckt die Details.

fn display( emp:Employee) {
   println!("Name is :{} company is {} age is 
   {}",emp.name,emp.company,emp.age);
}

Hier ist das komplette Programm -

//declare a structure
struct Employee {
   name:String,
   company:String,
   age:u32
}
fn main() {
   //initialize a structure
   let emp1 = Employee {
      company:String::from("TutorialsPoint"),
      name:String::from("Mohtashim"),
      age:50
   };
   let emp2 = Employee{
      company:String::from("TutorialsPoint"),
      name:String::from("Kannan"),
      age:32
   };
   //pass emp1 and emp2 to display()
   display(emp1);
   display(emp2);
}
// fetch values of specific structure fields using the 
// operator and print it to the console
fn display( emp:Employee){
   println!("Name is :{} company is {} age is 
   {}",emp.name,emp.company,emp.age);
}

Ausgabe

Name is :Mohtashim company is TutorialsPoint age is 50
Name is :Kannan company is TutorialsPoint age is 32

Struktur von einer Funktion zurückgeben

Betrachten wir eine Funktion who_is_elder () , die das Alter von zwei Mitarbeitern vergleicht und die ältere zurückgibt.

fn who_is_elder (emp1:Employee,emp2:Employee)->Employee {
   if emp1.age>emp2.age {
      return emp1;
   } else {
      return emp2;
   }
}

Hier ist das komplette Programm -

fn main() {
   //initialize structure
   let emp1 = Employee{
      company:String::from("TutorialsPoint"),
      name:String::from("Mohtashim"),
      age:50
   };
   let emp2 = Employee {
      company:String::from("TutorialsPoint"),
      name:String::from("Kannan"),
      age:32
   };
   let elder = who_is_elder(emp1,emp2);
   println!("elder is:");

   //prints details of the elder employee
   display(elder);
}
//accepts instances of employee structure and compares their age
fn who_is_elder (emp1:Employee,emp2:Employee)->Employee {
   if emp1.age>emp2.age {
      return emp1;
   } else {
      return emp2;
   }
}
//display name, comapny and age of the employee
fn display( emp:Employee) {
   println!("Name is :{} company is {} age is {}",emp.name,emp.company,emp.age);
}
//declare a structure
struct Employee {
   name:String,
   company:String,
   age:u32
}

Ausgabe

elder is:
Name is :Mohtashim company is TutorialsPoint age is 50

Methode in der Struktur

Methoden sind wie Funktionen. Sie sind eine logische Gruppe von Programmieranweisungen. Methoden werden mit dem deklariertfnStichwort. Der Umfang einer Methode liegt innerhalb des Strukturblocks.

Methoden werden außerhalb des Strukturblocks deklariert. DasimplMit dem Schlüsselwort wird eine Methode im Kontext einer Struktur definiert. Der erste Parameter einer Methode ist immerself, die die aufrufende Instanz der Struktur darstellt. Methoden arbeiten mit den Datenelementen einer Struktur.

Um eine Methode aufzurufen, müssen wir zuerst die Struktur instanziieren. Die Methode kann über die Instanz der Struktur aufgerufen werden.

Syntax

struct My_struct {}
impl My_struct { 
   //set the method's context
   fn method_name() { 
      //define a method
   }
}

Illustration

Das folgende Beispiel definiert eine Struktur Rechteck mit Feldern - Breite und Höhe . Verfahren Bereich ist innerhalb der Struktur des Kontextes definiert. Die area-Methode greift über das Schlüsselwort self auf die Felder der Struktur zu und berechnet die Fläche eines Rechtecks.

//define dimensions of a rectangle
struct Rectangle {
   width:u32, height:u32
}

//logic to calculate area of a rectangle
impl Rectangle {
   fn area(&self)->u32 {
      //use the . operator to fetch the value of a field via the self keyword
      self.width * self.height
   }
}

fn main() {
   // instanatiate the structure
   let small = Rectangle {
      width:10,
      height:20
   };
   //print the rectangle's area
   println!("width is {} height is {} area of Rectangle 
   is {}",small.width,small.height,small.area());
}

Ausgabe

width is 10 height is 20 area of Rectangle is 200

Statische Methode in der Struktur

Statische Methoden können als Dienstprogrammmethoden verwendet werden. Diese Methoden existieren bereits, bevor die Struktur instanziiert wird. Statische Methoden werden unter Verwendung des Strukturnamens aufgerufen und können ohne Instanz aufgerufen werden. Im Gegensatz zu normalen Methoden akzeptiert eine statische Methode nicht den Parameter & self .

Syntax - Deklarieren einer statischen Methode

Eine statische Methode wie Funktionen und andere Methoden kann optional Parameter enthalten.

impl Structure_Name {
   //static method that creates objects of the Point structure
   fn method_name(param1: datatype, param2: datatype) -> return_type {
      // logic goes here
   }
}

Syntax - Aufrufen einer statischen Methode

Die Syntax struct_name :: wird verwendet, um auf eine statische Methode zuzugreifen.

structure_name::method_name(v1,v2)

Illustration

Im folgenden Beispiel wird die Methode getInstance als Factory-Klasse verwendet, die Instanzen der Struktur Point erstellt und zurückgibt .

//declare a structure
struct Point {
   x: i32,
   y: i32,
}
impl Point {
   //static method that creates objects of the Point structure
   fn getInstance(x: i32, y: i32) -> Point {
      Point { x: x, y: y }
   }
   //display values of the structure's field
   fn display(&self){
      println!("x ={} y={}",self.x,self.y );
   }
}
fn main(){
   // Invoke the static method
   let p1 = Point::getInstance(10,20);
   p1.display();
}

Ausgabe

x =10 y=20