Rdza - Struktura

Tablice służą do reprezentowania jednorodnego zbioru wartości. Podobnie, struktura jest innym typem danych zdefiniowanym przez użytkownika dostępnym w Rust, który pozwala nam łączyć elementy danych różnych typów, w tym inną strukturę. Struktura definiuje dane jako parę klucz-wartość.

Składnia - deklarowanie struktury

Struct słów kluczowych służy do deklarowania strukturę. Ponieważ struktury są wpisywane statycznie, każde pole w strukturze musi być skojarzone z typem danych. Reguły nazewnictwa i konwencje dotyczące struktury są takie same, jak w przypadku zmiennej. Blok struktury musi kończyć się średnikiem.

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

Składnia - inicjowanie struktury

Po zadeklarowaniu struktury każdemu polu należy przypisać wartość. Nazywa się to inicjalizacją.

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);
}

Powyższy przykład deklaruje strukturę Pracownik z trzema polami - imię i nazwisko, firma i wiek typów. Metoda main () inicjuje strukturę. Używa println! makro do wydrukowania wartości pól zdefiniowanych w strukturze.

Wynik

Name is :Mohtashim company is TutorialsPoint age is 50

Modyfikowanie instancji struktury

Aby zmodyfikować instancję, zmienną instancji należy oznaczyć jako mutable. Poniższy przykład deklaruje i inicjuje strukturę o nazwie Employee, a następnie modyfikuje wartość pola age na 40 z 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);

Wynik

Name is :Mohtashim company is TutorialsPoint age is 40

Przekazywanie struktury do funkcji

Poniższy przykład pokazuje, jak przekazać wystąpienie struct jako parametr. Metoda display przyjmuje instancję Employee jako parametr i wyświetla szczegóły.

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

Oto pełny program -

//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);
}

Wynik

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

Zwracanie struktury z funkcji

Rozważmy funkcję who_is_elder () , która porównuje wiek dwóch pracowników i zwraca starszego.

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

Oto pełny program -

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
}

Wynik

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

Metoda w strukturze

Metody są jak funkcje. Stanowią logiczną grupę instrukcji programistycznych. Metody są deklarowane z rozszerzeniemfnsłowo kluczowe. Zakres metody znajduje się w bloku struktury.

Metody są deklarowane poza blokiem struktury. Plikimplsłowo kluczowe służy do definiowania metody w kontekście struktury. Pierwszym parametrem metody będzie zawszeself, który reprezentuje wywołujące wystąpienie struktury. Metody działają na elementach danych struktury.

Aby wywołać metodę, musimy najpierw utworzyć instancję struktury. Metodę można wywołać za pomocą instancji struktury.

Składnia

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

Ilustracja

Poniższy przykład definiuje strukturę Rectangle z polami - szerokość i wysokość . Sposób powierzchnia jest określona w kontekście przez konstrukcję. Metoda area uzyskuje dostęp do pól struktury za pomocą słowa kluczowego self i oblicza pole powierzchni prostokąta.

//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());
}

Wynik

width is 10 height is 20 area of Rectangle is 200

Metoda statyczna w strukturze

Metody statyczne mogą być używane jako metody użytkowe. Te metody istnieją jeszcze przed utworzeniem instancji struktury. Metody statyczne są wywoływane przy użyciu nazwy struktury i można uzyskać do nich dostęp bez instancji. W przeciwieństwie do zwykłych metod, metoda statyczna nie przyjmuje parametru & self .

Składnia - deklarowanie metody statycznej

Metoda statyczna, taka jak funkcje i inne metody, może opcjonalnie zawierać parametry.

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

Składnia - wywołanie metody statycznej

Structure_name :: składnia umożliwia dostęp do metody statycznej.

structure_name::method_name(v1,v2)

Ilustracja

W poniższym przykładzie zastosowano metodę getInstance jako klasę fabryczną, która tworzy i zwraca wystąpienia struktury Point .

//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();
}

Wynik

x =10 y=20