Ruggine - Struttura

Le matrici vengono utilizzate per rappresentare una raccolta omogenea di valori. Allo stesso modo, una struttura è un altro tipo di dati definito dall'utente disponibile in Rust che ci permette di combinare elementi di dati di diversi tipi, inclusa un'altra struttura. Una struttura definisce i dati come una coppia chiave-valore.

Sintassi: dichiarazione di una struttura

La parola chiave struct viene utilizzata per dichiarare una struttura. Poiché le strutture sono tipizzate staticamente, ogni campo nella struttura deve essere associato a un tipo di dati. Le regole e le convenzioni di denominazione per una struttura sono come quelle di una variabile. Il blocco struttura deve terminare con un punto e virgola.

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

Sintassi: inizializzazione di una struttura

Dopo aver dichiarato una struttura, a ogni campo dovrebbe essere assegnato un valore. Questo è noto come inizializzazione.

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

L'esempio precedente dichiara una struttura Employee con tre campi: nome, azienda ed età dei tipi. Il main () inizializza la struttura. Usa il println! macro per stampare i valori dei campi definiti nella struttura.

Produzione

Name is :Mohtashim company is TutorialsPoint age is 50

Modifica di un'istanza di struct

Per modificare un'istanza, la variabile di istanza deve essere contrassegnata come mutabile. L'esempio seguente dichiara e inizializza una struttura denominata Employee e successivamente modifica il valore del campo age a 40 da 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);

Produzione

Name is :Mohtashim company is TutorialsPoint age is 40

Passaggio di una struttura a una funzione

L'esempio seguente mostra come passare l'istanza di struct come parametro. Il metodo di visualizzazione accetta un'istanza Employee come parametro e stampa i dettagli.

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

Ecco il programma completo -

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

Produzione

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

Restituzione di struct da una funzione

Consideriamo una funzione who_is_elder () , che confronta l'età di due dipendenti e restituisce quella maggiore.

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

Ecco il programma completo -

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
}

Produzione

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

Metodo nella struttura

I metodi sono come le funzioni. Sono un gruppo logico di istruzioni di programmazione. I metodi vengono dichiarati confnparola chiave. L'ambito di un metodo è all'interno del blocco della struttura.

I metodi vengono dichiarati all'esterno del blocco della struttura. Ilimplparola chiave viene utilizzata per definire un metodo nel contesto di una struttura. Il primo parametro di un metodo sarà sempreself, che rappresenta l'istanza chiamante della struttura. I metodi operano sui membri dati di una struttura.

Per invocare un metodo, dobbiamo prima istanziare la struttura. Il metodo può essere chiamato utilizzando l'istanza della struttura.

Sintassi

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

Illustrazione

L'esempio seguente definisce una struttura Rettangolo con campi: larghezza e altezza . Procedimento zona è definito all'interno del contesto della struttura. Il metodo area accede ai campi della struttura tramite la parola chiave self e calcola l'area di un rettangolo.

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

Produzione

width is 10 height is 20 area of Rectangle is 200

Metodo statico nella struttura

I metodi statici possono essere utilizzati come metodi di utilità. Questi metodi esistono anche prima che venga creata un'istanza della struttura. I metodi statici vengono richiamati utilizzando il nome della struttura ed è possibile accedervi senza un'istanza. A differenza dei metodi normali, un metodo statico non accetta il parametro & self .

Sintassi: dichiarazione di un metodo statico

Un metodo statico come funzioni e altri metodi possono facoltativamente contenere parametri.

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

Sintassi: invocare un metodo statico

Il nome_struttura :: sintassi viene utilizzato per accedere a un metodo statico.

structure_name::method_name(v1,v2)

Illustrazione

L'esempio seguente utilizza il metodo getInstance come classe factory che crea e restituisce istanze della struttura 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();
}

Produzione

x =10 y=20