Visión general de los Structs

Parte de la sección Lógica y Flujo del Journey de Rust de Coddy. Lección 21 de 66.

Ahora que entiendes qué son las estructuras, aprendamos a crearlas y utilizarlas realmente. Esto implica dos pasos: primero definir la estructura de la estructura y después crear instancias de ella.

Para definir una estructura, usas la palabra clave struct seguida del nombre de la estructura y sus campos entre llaves. Cada campo tiene un nombre y un tipo:

struct User {
    username: String,
    active: bool,
}

Esto crea un modelo para una estructura User con dos campos: username de tipo String y active de tipo bool.

Convención de nomenclatura: Los nombres de las estructuras en Rust deben usar PascalCase (también llamado UpperCamelCase), lo que significa que cada palabra comienza con una letra mayúscula, por ejemplo, User, ProductItem o ShoppingCart. Rust te advertirá si no sigues esta convención.

Una vez que hayas definido una estructura, puedes crear instancias de ella especificando valores para cada campo:

let user1 = User {
    username: String::from("alice"),
    active: true,
};

Observa que proporcionas el nombre de la estructura seguido de llaves que contienen cada nombre de campo, dos puntos y su valor. El orden de los campos no tiene que coincidir con el orden de la definición.

Para acceder a los campos de una instancia de una estructura, usa la notación de punto: escribe el nombre de la instancia seguido de un punto y del nombre del campo:

println!("Username: {}", user1.username);
println!("Active: {}", user1.active);

Aquí, user1.username accede al campo username de user1, y user1.active accede al campo active. Puedes usar estos valores de campo en cualquier lugar donde usarías una variable normal.

Desafío

Fácil

Recibirás tres entradas: un nombre de producto, un precio (como número decimal) y una cantidad en stock (como entero). Define una estructura Product con tres campos: name de tipo String, price de tipo f64 y stock de tipo i32. Después crea una instancia de esta estructura usando los valores de entrada e imprime la información del producto.

Requisitos:

Define una estructura Product con los campos: name: String, price: f64 y stock: i32
Lee la primera entrada como el nombre del producto
Lee la segunda entrada y conviértela a f64 para el precio
Lee la tercera entrada y conviértela a i32 para la cantidad en stock
Crea una instancia de la estructura Product con estos valores
Imprime la información del producto en el formato exacto que se muestra a continuación

Entrada:

Primera línea: Nombre del producto (por ejemplo, Laptop)
Segunda línea: Precio como número decimal (por ejemplo, 999.99)
Tercera línea: Cantidad en stock como entero (por ejemplo, 15)

Salida:

Primera línea: Product: [name]
Segunda línea: Price: $[price]
Tercera línea: Stock: [quantity]

Pruébalo tú mismo

use std::io;

// TODO: Define tu struct Product aquí


fn main() {
    // Lee el nombre del producto
    let mut name = String::new();
    io::stdin().read_line(&mut name).expect("Failed to read line");
    let name = name.trim().to_string();
    
    // Lee el precio
    let mut price_input = String::new();
    io::stdin().read_line(&mut price_input).expect("Failed to read line");
    let price: f64 = price_input.trim().parse().expect("Failed to parse price");
    
    // Lee la cantidad de stock
    let mut stock_input = String::new();
    io::stdin().read_line(&mut stock_input).expect("Failed to read line");
    let stock: i32 = stock_input.trim().parse().expect("Failed to parse stock");
    
    // TODO: Crea una instancia del struct Product usando los valores de entrada
    
    
    // TODO: Imprime la información del producto en el formato requerido
    
}