FerrousPath

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

  1. Define struct Circle { radius: f64 } con los métodos new, area y circumference (usa std::f64::consts::PI).
  2. Define un Counter con un campo count: u32, new(), increment(&mut self) y get(&self) -> u32.
  3. Añade fn can_hold(&self, other: &Rectangle) -> bool a Rectangle.
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. 1.¿Qué significa &self en la firma de un método?

  2. 2.¿Cómo se llama a una función asociada como new, que no tiene parámetro self?

  3. 3.¿Qué te da #[derive(Debug)]?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?