Que son los structs y los enums
Los structs y los enums son dos formas de definir tipos de datos personalizados en Rust.
Un **struct** es una forma de agrupar varios campos de diferentes tipos en un solo tipo compuesto. Los structs se pueden usar para representar conceptos o entidades que tienen propiedades o atributos asociados. Por ejemplo, se puede definir un struct para representar un punto en el espacio bidimensional:
struct Punto {
x: f64, // campo x de tipo f64
y: f64, // campo y de tipo f64
}
Para crear una instancia de un struct, se usa la sintaxis Nombre { campo: valor, ... }. Por ejemplo:
let p = Punto { x: 3.0, y: 4.0 }; // crea un punto con las coordenadas (3.0, 4.0)
Para acceder o modificar los campos de un struct, se usa la notación de punto .. Por ejemplo:
println!("El punto está en ({}, {})", p.x, p.y); // imprime los valores de los campos x e y del punto p
p.x = 5.0; // cambia el valor del campo x del punto p a 5.0
Los structs también pueden tener métodos asociados, que son funciones que operan sobre una instancia de un struct. Para definir un método, se usa la palabra clave impl seguida del nombre del struct y un bloque que contiene las definiciones de los métodos. Por ejemplo:
impl Punto {
// define un método llamado distancia que recibe una referencia inmutable a otro punto y devuelve un f64
fn distancia(&self, otro: &Punto) -> f64 {
// calcula la distancia euclidiana entre dos puntos usando el teorema de Pitágoras
((self.x - otro.x).powi(2) + (self.y - otro.y).powi(2)).sqrt()
}
}
Para llamar a un método, se usa la notación de punto . seguida del nombre del método y los argumentos entre paréntesis. Por ejemplo:
let q = Punto { x: 0.0, y: 0.0 }; // crea otro punto con las coordenadas (0.0, 0.0)
let d = p.distancia(&q); // llama al método distancia con el argumento q y guarda el resultado en una variable d
println!("La distancia entre los puntos es {}", d); // imprime el valor de d
Un **enum** es una forma de definir un tipo de dato que puede ser uno de varios valores posibles. Cada valor posible se llama una variante del enum. Los enums se pueden usar para representar opciones o alternativas que son mutuamente excluyentes. Por ejemplo, se puede definir un enum para representar el estado de ánimo de una persona:
enum EstadoDeAnimo {
Alegre, // variante Alegre sin datos asociados
Triste, // variante Triste sin datos asociados
Enojado { nivel: u8 }, // variante Enojado con un campo nivel de tipo u8
Confundido(String), // variante Confundido con un dato asociado de tipo String
}
Para crear una instancia de un enum, se usa la sintaxis Nombre::Variante o Nombre::Variante(dato) si la variante tiene datos asociados. Por ejemplo:
let e1 = EstadoDeAnimo::Alegre; // crea una instancia del enum con la variante Alegre
let e2 = EstadoDeAnimo::Enojado { nivel: 5 }; // crea una instancia del enum con la variante Enojado y el nivel 5
let e3 = EstadoDeAnimo::Confundido("¿Qué pasa?".to_string()); // crea una instancia del enum con la variante Confundido y el dato "¿Qué pasa?"
Para acceder o modificar los datos asociados a una variante de un enum, se usa la coincidencia de patrones con la expresión match o la expresión if let. Por ejemplo:
match e2 {
EstadoDeAnimo::Alegre => println!("Estoy feliz"), // si e2 es Alegre, imprime un mensaje
EstadoDeAnimo::Triste => println!("Estoy triste"), // si e2 es Triste, imprime otro mensaje
EstadoDeAnimo::Enojado { nivel } => println!("Estoy enojado al nivel {}", nivel), // si e2 es Enojado, imprime el nivel
EstadoDeAnimo::Confundido(mensaje) => println!("Estoy confundido: {}", mensaje), // si e2 es Confundido, imprime el mensaje
}
if let EstadoDeAnimo::Confundido(mensaje) = e3 {
println!("Estoy confundido: {}", mensaje); // si e3 es Confundido, imprime el mensaje
} else {
println!("No estoy confundido"); // si e3 no es Confundido, imprime otro mensaje
}
Los enums también pueden tener métodos asociados, de la misma forma que los structs. Por ejemplo:
impl EstadoDeAnimo {
// define un método llamado describir que recibe una referencia inmutable a una instancia del enum y devuelve un String
fn describir(&self) -> String {
match self {
EstadoDeAnimo::Alegre => "Estoy feliz".to_string(), // si self es Alegre, devuelve un String con el mensaje
EstadoDeAnimo::Triste => "Estoy triste".to_string(), // si self es Triste, devuelve otro String con otro mensaje
EstadoDeAnimo::Enojado { nivel } => format!("Estoy enojado al nivel {}", nivel), // si self es Enojado, devuelve un String con el nivel
EstadoDeAnimo::Confundido(mensaje) => format!("Estoy confundido: {}", mensaje), // si self es Confundido, devuelve un String con el mensaje
}
}
}
Para llamar a un método de un enum, se usa la misma notación de punto . que para los structs. Por ejemplo:
let descripcion = e1.describir(); // llama al método describir y guarda el resultado en una variable descripcion
println!("{}", descripcion); // imprime el valor de descripcion
Espero que esta explicación te haya sido útil. Si quieres aprender más sobre los structs y los enums en Rust, te recomiendo que visites los siguientes enlaces:
[Struct y enum en Rust: ¿Qué son y en qué se diferencian?](https://unpinguino.net/posts/struct-y-enum-en-rust-que-son-y-en-que-se-diferencian/)
[Rust - Definición de un Enum](https://runebook.dev/es/docs/rust/book/ch06-01-defining-an-enum)
[Rust - Enumeración y coincidencia de patrones](https://runebook.dev/es/docs/rust/book/ch06-00-enums)
Comentarios
Publicar un comentario