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.
estructuraPersona {
nombre: Cadena,
edad: u8,
es_estudiante: 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.
dejar persona = Persona {
nombre: Cadena::de("John"),
edad: 27,
es_estudiante: verdadero,
};
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 Persona {
// Definir una función constructora `nuevo` que tome `nombre`, `edad` y
// parámetros `es_estudiante`
fnnuevo(nombre: Cadena, edad: u8, es_estudiante: bool) -> Ser {
// Crea una nueva instancia de la estructura `Person` e inicializa sus campos
// con los valores proporcionados
Ser {
nombre,
edad,
es_estudiante,
}
}
}
// Llame a la función constructora `nueva` de la estructura `Persona` y asigne el
// instancia resultante para `persona`
dejar persona = Persona:: nuevo(Cadena::de("John"), 27, verdadero);
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.
// declara una estructura de Persona
estructuraPersona {
nombre: Cadena,
edad: u8,
es_estudiante: bool,
}fnprincipal() {
// instanciar una estructura
dejarmudo persona = Persona {
nombre: Cadena::de("John"),
edad: 27,
es_estudiante: verdadero,
};// imprime los campos de nombre y edad de la estructura
imprimir!("Nombre: {}", persona.nombre);
imprimir!("Edad: {}", persona.edad);// modifica el campo is_student
persona.es_estudiante = FALSO;
imprimir!("Es estudiante: {}", persona.es_estudiante);
}
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.
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:
estructuraPersona {
nombre: Cadena,
edad: u8,
es_estudiante: bool,
}impl Persona {
fndi hola(&ser) {
imprimir!("Hola, mi nombre es {} y tengo {} años"., ser.nombre,
ser.edad);
}fntener_cumpleaños(&mudoser) {
ser.edad += 1;
}
}fnprincipal() {
dejarmudo persona = Persona {
nombre: Cadena::de("John"),
edad: 27,
es_estudiante: verdadero,
};persona.di_hola();
persona.tener_cumpleaños();
imprimir!("Nueva era: {}", persona.edad);
}
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.
