Nivel 1 · Fundamentos· Lección 6 de 10 · 20 min
Structs y métodos
Definir tus propios tipos de datos, añadirles comportamiento con bloques impl y derivar los traits más comunes.
Definir un struct
Un struct agrupa campos con nombre en un solo tipo.
#[derive(Debug)]
struct User {
name: String,
age: u32,
active: bool,
}
fn main() {
let mut user = User {
name: String::from("Ada"),
age: 36,
active: true,
};
user.age += 1;
println!("{} is {}", user.name, user.age);
println!("{user:?}");
println!("{user:#?}"); // con formato legible
}
La mutabilidad pertenece al enlace, no a los campos individuales: let mut user hace asignables todos los campos.
#[derive(Debug)] pide al compilador que genere el código que hace funcionar {:?}. Lo añadirás a casi todos los tipos que escribas.
Sintaxis abreviada y de actualización
#[derive(Debug, Clone)]
struct Config {
host: String,
port: u16,
verbose: bool,
}
fn main() {
let host = String::from("localhost");
let port = 8080;
let base = Config { host, port, verbose: false }; // abreviatura de inicialización de campos
let noisy = Config { verbose: true, ..base.clone() }; // toma el resto de otro valor
println!("{base:?}\n{noisy:?}");
}
Structs tupla y structs unitarios
struct Metres(f64);
struct Seconds(f64);
struct Marker;
fn speed(d: Metres, t: Seconds) -> f64 {
d.0 / t.0
}
fn main() {
let _m = Marker;
println!("{} m/s", speed(Metres(100.0), Seconds(9.58)));
// speed(Seconds(9.58), Metres(100.0)); // ❌ no compilaría: argumentos intercambiados
}
Envolver un tipo primitivo en un struct tupla es el patrón newtype. No cuesta nada en tiempo de ejecución y te impide mezclar valores que comparten representación pero no significado.
Métodos
El comportamiento va en un bloque impl.
#[derive(Debug)]
struct Rectangle {
width: f64,
height: f64,
}
impl Rectangle {
// Función asociada (sin self): se usa como constructor.
fn new(width: f64, height: f64) -> Self {
Self { width, height }
}
fn square(side: f64) -> Self {
Self::new(side, side)
}
// Toma prestado de forma inmutable: solo lee.
fn area(&self) -> f64 {
self.width * self.height
}
// Toma prestado de forma mutable: modifica el valor en el sitio.
fn scale(&mut self, factor: f64) {
self.width *= factor;
self.height *= factor;
}
// Toma la propiedad: consume el valor.
fn into_square(self) -> Rectangle {
let side = self.width.max(self.height);
Rectangle::square(side)
}
}
fn main() {
let mut r = Rectangle::new(3.0, 4.0);
println!("area {}", r.area());
r.scale(2.0);
println!("{r:?}");
let s = r.into_square(); // r se mueve; usarlo después de esto es un error
println!("{s:?}");
}
El receptor le dice a quien llama lo que el método puede hacer:
| Receptor | Significado | Úsalo cuando |
|---|---|---|
&self |
préstamo compartido | lees: el caso habitual |
&mut self |
préstamo exclusivo | modificas en el sitio |
self |
toma la propiedad | transformas en otra cosa, o consumes |
Self (con S mayúscula) es un alias del tipo que se está implementando. Rust no tiene una sintaxis especial para constructores; new es solo una convención.
Cuando escribes r.area(), Rust toma prestado automáticamente lo que haga falta: es lo mismo que Rectangle::area(&r).
La propiedad dentro de los structs
Un struct es dueño de sus campos. Cuando el struct se libera, se liberan los campos. Mover un campo fuera de un struct deja el struct parcialmente movido:
struct Article {
title: String,
body: String,
}
fn main() {
let a = Article {
title: String::from("Ownership"),
body: String::from("…"),
};
let title = a.title; // mueve el título hacia fuera
println!("{title}");
println!("{}", a.body); // los demás campos se pueden seguir usando
// let b = a; // ❌ a está parcialmente movido
}
Para guardar una referencia en un struct necesitas anotaciones de lifetime, que se tratan en el nivel 2. Hasta entonces, haz que los structs sean dueños de sus datos (String, no &str).
Ejercicios
- Define
struct Circle { radius: f64 }con los métodosnew,areaycircumference(usastd::f64::consts::PI). - Define un
Countercon un campocount: u32,new(),increment(&mut self)yget(&self) -> u32. - Añade
fn can_hold(&self, other: &Rectangle) -> boolaRectangle.
Solución del 3
struct Rectangle { width: f64, height: f64 }
impl Rectangle {
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
}
fn main() {
let big = Rectangle { width: 8.0, height: 6.0 };
let small = Rectangle { width: 3.0, height: 2.0 };
println!("{} {}", big.can_hold(&small), small.can_hold(&big));
}
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿Qué significa
&selfen la firma de un método?2.¿Cómo se llama a una función asociada como
new, que no tiene parámetroself?3.¿Qué te da
#[derive(Debug)]?