Home-theater-designers
Una característica clave que hace que Rust sea más poderoso y atractivo es su soporte para estructuras. Las estructuras son tipos de datos compuestos para agrupar datos relacionados. Le permiten definir tipos de datos personalizados con campos con nombre que mejoran la organización del código y facilitan la manipulación de datos.
Puede usar estructuras para representar varios objetos, incluidos tipos de datos y configuraciones definidos por el usuario. Las estructuras son más flexibles que muchas otras estructuras de datos. Su capacidad para encapsular datos relacionados los hace útiles, ya que crean un modelo más lógico de objetos del mundo real.
Definición de estructuras y campos de estructura
Definirás una estructura usando el estructura palabra clave seguida de un nombre para la estructura. Siga esto especificando los nombres de campo de la estructura y su Tipos de datos de óxido dentro de un par de llaves.
proceso crítico de windows 10 bsod murió
struct Person {
name: String,
age: u8,
is_student: bool,
}
Este Persona struct tiene tres campos. El nombre campo es una cadena, el edad campo es un entero de 8 bits sin signo, y el es_estudiante campo es un booleano.
Puede usar literales de estructura para crear instancias de estructura después de la definición de estructura. Los literales de estructura especifican los valores de los campos de una estructura.
let person = Person {
name: String::from("John"),
age: 27,
is_student: true,
};
El persona variable es una instancia de la Persona struct, creado con un struct literal. Este literal instancia todos los campos de la estructura con valores de su tipo de datos correspondiente.
Uso de constructores para crear estructuras
También puede usar una función constructora para crear una instancia de una estructura.
impl Person {
// Define a constructor function `new` that takes `name`, `age` and
// `is_student` parameters
fn new(name: String, age: u8, is_student: bool) -> Self {
// Create a new instance of `Person` struct and initialize its fields
// with the provided values
Self {
name,
age,
is_student,
}
}
}
// Call the `new` constructor function of the `Person` struct and assign the
// resulting instance to `person`
let person = Person::new(String::from("John"), 27, true);
El programa anterior define un constructor para el Persona estructura con el impl. palabra clave. El nuevo constructor toma los campos de la estructura como argumentos y devuelve una nueva instancia de la estructura con los valores inicializados.
Puedes crear un Persona instancia con el nuevo constructor, pasándole los argumentos apropiados.
Acceso y modificación de campos de estructura
Puede acceder a los campos de estructura y modificarlos mediante una notación de puntos. Simplemente usa el punto ( . ) seguido del nombre del campo para acceder o cambiar su valor.
// declare a Person struct
struct Person {
name: String,
age: u8,
is_student: bool,
}
fn main() {
// instantiate a struct
let mut person = Person {
name: String::from("John"),
age: 27,
is_student: true,
};
// print the name and age fields of the struct
println!("Name: {}", person.name);
println!("Age: {}", person.age);
// modifiy the is_student field
person.is_student = false;
println!("Is student: {}", person.is_student);
}
El programa crea una estructura, instancia la estructura, imprime el nombre, y edad campos, y modifica el es_estudiante campo antes de imprimir el campo.
cómo eliminar todas las búsquedas de google
Declaración de métodos para estructuras
A diferencia de estructuras en C , puede definir métodos en estructuras de Rust que operan en una instancia. Los métodos son funciones que toman una referencia a una estructura para acceso y modificación. También puede usar la notación de puntos para llamar a los métodos de una estructura y acceder a su funcionalidad.
Así es como puede declarar métodos para estructuras y usar esos métodos para realizar operaciones:
struct Person {
name: String,
age: u8,
is_student: bool,
}
impl Person {
fn say_hello(&self) {
println!("Hello, my name is {} and I'm {} years old.", self.name,
self.age);
}
fn have_birthday(&mut self) {
self.age += 1;
}
}
fn main() {
let mut person = Person {
name: String::from("John"),
age: 27,
is_student: true,
};
person.say_hello();
person.have_birthday();
println!("New age: {}", person.age);
}
El programa define dos métodos para la Persona estructura El di hola El método toma una referencia a ser e imprime un saludo que incluye el nombre y la edad de la persona. El tener_cumpleaños El método toma una referencia mutable a ser y aumenta la edad de la persona.
El modelo de propiedad de Rust optimiza la gestión de la memoria
Las estructuras son estructuras de datos versátiles, que actúan como una especie de equivalente de clase mínima.
Al igual que con otras estructuras de datos de Rust, debe seguir las reglas de propiedad de Rust cuando trabaje con variables de estructura. El modelo de propiedad garantiza que administre la memoria de manera eficiente en sus programas, evitando problemas comunes como punteros nulos y colgantes.