Intro a Bloques de Implementación

Parte de la sección Object Oriented Programming del Journey de Rust de Coddy — lección 1 de 61.

En Rust, las structs definen qué datos contiene un tipo, pero no definen qué puede hacer ese tipo. Para darle comportamiento a una struct, usamos bloques de implementación con la palabra clave impl.

Un bloque de implementación conecta funciones (llamadas métodos) a una estructura (struct) específica. Aquí está la estructura básica:

struct Dog {
    name: String,
    age: u8,
}

impl Dog {
    fn bark(&self) {
        println!("{} says woof!", self.name);
    }
}

El bloque impl Dog le dice a Rust que todo lo que hay dentro pertenece a la estructura Dog. Esta separación mantiene limpia la definición de tus datos, a la vez que te permite añadir tantos métodos como sea necesario en el bloque de implementación.

Para llamar a un método, utiliza la notación de punto en una instancia:

fn main() {
    let my_dog = Dog {
        name: String::from("Rex"),
        age: 3,
    };
    
    my_dog.bark(); // Salida: ¡Rex dice woof!
}

Este patrón de separar los datos (el struct) del comportamiento (el bloque impl) es fundamental para organizar el código en Rust. En las próximas lecciones, exploraremos cómo los métodos acceden a los datos del struct a través del parámetro &self que ves en el ejemplo anterior.

Desafío

Fácil

Crea una estructura Cat con dos campos: name (String) y lives (u8).

Añade un bloque de implementación para Cat con un método llamado meow que toma &self e imprime el nombre del gato seguido de " says meow!".

Recibirás dos entradas:

Primera línea: el nombre del gato (String)
Segunda línea: el número de vidas (u8)

Crea una instancia de Cat con los valores proporcionados y llama al método meow en ella.

Formato de salida esperado:

{name} says meow!

Hoja de referencia

Los bloques de implementación conectan métodos a structs usando la palabra clave impl:

struct Dog {
    name: String,
    age: u8,
}

impl Dog {
    fn bark(&self) {
        println!("{} says woof!", self.name);
    }
}

El bloque impl separa la definición de datos (struct) del comportamiento (métodos). Los métodos se llaman usando la notación de punto:

let my_dog = Dog {
    name: String::from("Rex"),
    age: 3,
};

my_dog.bark(); // Salida: Rex says woof!

Los métodos usan el parámetro &self para acceder a los datos del struct.

Pruébalo tú mismo

use std::io;

// TODO: Definir la estructura Cat con los campos 'name' (String) y 'lives' (u8)


// TODO: Añadir un bloque de implementación para Cat con un método 'meow'


fn main() {
    let mut name = String::new();
    io::stdin().read_line(&mut name).expect("Failed to read line");
    let name = name.trim().to_string();
    
    let mut lives_input = String::new();
    io::stdin().read_line(&mut lives_input).expect("Failed to read line");
    let lives: u8 = lives_input.trim().parse().expect("Failed to parse lives");
    
    // TODO: Crear una instancia de Cat y llamar al método meow
    
}