Óxido - Estructura

Las matrices se utilizan para representar una colección homogénea de valores. De manera similar, una estructura es otro tipo de datos definido por el usuario disponible en Rust que nos permite combinar elementos de datos de diferentes tipos, incluida otra estructura. Una estructura define los datos como un par clave-valor.

Sintaxis: declaración de una estructura

La palabra clave struct se usa para declarar una estructura. Dado que las estructuras se escriben de forma estática, cada campo de la estructura debe estar asociado con un tipo de datos. Las reglas y convenciones de nomenclatura de una estructura son como las de una variable. El bloque de estructura debe terminar con punto y coma.

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

Sintaxis: inicialización de una estructura

Después de declarar una estructura, a cada campo se le debe asignar un valor. Esto se conoce como inicialización.

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

El ejemplo anterior declara una estructura Employee con tres campos: nombre, empresa y edad de tipos. El main () inicializa la estructura. Utiliza println! macro para imprimir valores de los campos definidos en la estructura.

Salida

Name is :Mohtashim company is TutorialsPoint age is 50

Modificar una instancia de estructura

Para modificar una instancia, la variable de instancia debe marcarse como mutable. El siguiente ejemplo declara e inicializa una estructura denominada Empleado y luego modifica el valor del campo de edad de 50 a 40.

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

Salida

Name is :Mohtashim company is TutorialsPoint age is 40

Pasando una estructura a una función

El siguiente ejemplo muestra cómo pasar una instancia de struct como parámetro. El método de visualización toma una instancia de Empleado como parámetro e imprime los detalles.

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

Aquí está el programa 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);
}

Salida

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

Devolviendo la estructura de una función

Consideremos una función who_is_elder () , que compara la edad de dos empleados y devuelve el mayor.

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

Aquí está el programa 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
}

Salida

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

Método en estructura

Los métodos son como funciones. Son un grupo lógico de instrucciones de programación. Los métodos se declaran con elfnpalabra clave. El alcance de un método está dentro del bloque de estructura.

Los métodos se declaran fuera del bloque de estructura. losimplLa palabra clave se utiliza para definir un método dentro del contexto de una estructura. El primer parámetro de un método siempre seráself, que representa la instancia de llamada de la estructura. Los métodos operan sobre los miembros de datos de una estructura.

Para invocar un método, primero debemos crear una instancia de la estructura. El método se puede llamar utilizando la instancia de la estructura.

Sintaxis

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

Ilustración

El siguiente ejemplo define una estructura Rectángulo con campos: ancho y alto . Un área de método se define dentro del contexto de la estructura. El método de área accede a los campos de la estructura a través de la palabra clave self y calcula el área de un rectángulo.

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

Salida

width is 10 height is 20 area of Rectangle is 200

Método estático en estructura

Los métodos estáticos se pueden utilizar como métodos de utilidad. Estos métodos existen incluso antes de que se instancia la estructura. Los métodos estáticos se invocan utilizando el nombre de la estructura y se puede acceder a ellos sin una instancia. A diferencia de los métodos normales, un método estático no tomará el parámetro & self .

Sintaxis: declaración de un método estático

Un método estático como funciones y otros métodos pueden contener parámetros opcionalmente.

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

Sintaxis: invocación de un método estático

La sintaxis de structure_name :: se usa para acceder a un método estático.

structure_name::method_name(v1,v2)

Ilustración

El siguiente ejemplo usa el método getInstance como una clase de fábrica que crea y devuelve instancias de la estructura 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();
}

Salida

x =10 y=20