Acceso a los campos de un Struct

Parte de la sección Logic & Flow del Journey de Rust de Coddy — lección 22 de 66.

Una vez que hayas creado una instancia de una estructura, necesitas una forma de recuperar los valores almacenados dentro de ella. Rust utiliza la notación de puntos para acceder a los campos individuales dentro de una estructura.

La sintaxis es sencilla: escribes el nombre de la instancia de la estructura, seguido de un punto y luego el nombre del campo al que quieres acceder:

let product = Product {
    name: String::from("Laptop"),
    price: 999,
};

println!("Product: {}", product.name);
println!("Price: ${}", product.price);

Esta notación de punto funciona igual que el acceso a propiedades en otros lenguajes de programación. Puedes usar los valores accedidos en expresiones, asignarlos a variables o pasarlos a funciones; se comportan exactamente como cualquier otro valor de ese tipo.

Desafío

Fácil

Recibirás tres entradas: el nombre del modelo de un coche, el año del coche (como un entero) y su kilometraje (como un entero). Define una estructura Car con tres campos: model de tipo String, year de tipo i32 y mileage de tipo i32. Crea una instancia de esta estructura utilizando los valores de entrada, luego accede e imprime cada campo.

Requisitos:

Define una estructura Car con los campos: model: String, year: i32 y mileage: i32
Lee la primera entrada como el modelo del coche
Lee la segunda entrada y conviértela a i32 para el año
Lee la tercera entrada y conviértela a i32 para el kilometraje
Crea una instancia de la estructura Car con estos valores
Usa la notación de punto para acceder a cada campo e imprimir la información del coche en el formato exacto que se muestra a continuación

Entrada:

Primera línea: Modelo del coche (por ejemplo, Tesla Model 3)
Segunda línea: Año como un entero (por ejemplo, 2022)
Tercera línea: Kilometraje como un entero (por ejemplo, 15000)

Salida:

Primera línea: Car: [model]
Segunda línea: Year: [year]
Tercera línea: Mileage: [mileage] km

Hoja de referencia

Para acceder a los campos dentro de una instancia de struct, utiliza la notación de punto:

let product = Product {
    name: String::from("Laptop"),
    price: 999,
};

println!("Product: {}", product.name);
println!("Price: ${}", product.price);

La sintaxis es: instance_name.field_name. Los valores accedidos pueden utilizarse en expresiones, asignarse a variables o pasarse a funciones.

Pruébalo tú mismo

use std::io;

// TODO: Define la estructura Car aquí con los campos: model, year y mileage

fn main() {
    // Leer el modelo del coche
    let mut model = String::new();
    io::stdin().read_line(&mut model).expect("Failed to read line");
    let model = model.trim().to_string();
    
    // Leer el año
    let mut year_input = String::new();
    io::stdin().read_line(&mut year_input).expect("Failed to read line");
    let year: i32 = year_input.trim().parse().expect("Invalid year");
    
    // Leer el kilometraje
    let mut mileage_input = String::new();
    io::stdin().read_line(&mut mileage_input).expect("Failed to read line");
    let mileage: i32 = mileage_input.trim().parse().expect("Invalid mileage");
    
    // TODO: Crear una instancia de la estructura Car usando los valores de entrada
    
    // TODO: Acceder e imprimir cada campo en el formato requerido
    // Car: [model]
    // Year: [year]
    // Mileage: [mileage] km
}