Structs de tupla

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

Mientras que las estructuras regulares utilizan campos con nombre, Rust ofrece otro tipo llamado tuple structs. Estas proporcionan una forma más concisa de crear tipos personalizados cuando no es necesario nombrar cada campo individualmente.

Una estructura de tupla combina los beneficios de crear un nuevo tipo con la simplicidad de una tupla. Se define utilizando la palabra clave struct seguida del nombre del tipo y los tipos de los campos entre paréntesis:

struct Color(i32, i32, i32);

Esto crea un tipo Color que contiene tres valores i32, que representan valores de color RGB. A diferencia de las structs regulares, no especificas nombres de campos: accedes a los valores por su posición, al igual que con las tuplas.

Para crear una instancia de una estructura de tupla, proporcionas los valores entre paréntesis:

let red = Color(255, 0, 0);

Puedes acceder a campos individuales utilizando la notación de puntos con el índice del campo: red.0 te da el primer valor, red.1 el segundo, y así sucesivamente.

Desafío

Fácil

Recibirás tres entradas: un valor rojo (como un entero), un valor verde (como un entero) y un valor azul (como un entero). Define una estructura de tupla Color que contenga tres valores i32 que representen los componentes de color RGB. Crea una instancia de esta estructura de tupla utilizando los valores de entrada, luego accede e imprime cada componente de color utilizando la notación de índice.

Requisitos:

Define una estructura de tupla Color con tres campos i32
Lee la primera entrada y conviértela a i32 para el valor rojo
Lee la segunda entrada y conviértela a i32 para el valor verde
Lee la tercera entrada y conviértela a i32 para el valor azul
Crea una instancia de la estructura de tupla Color con estos valores
Accede a cada campo utilizando la notación de punto con índices (0, 1, 2) e imprime la información del color en el formato exacto que se muestra a continuación

Entrada:

Primera línea: Valor rojo como un entero (por ejemplo, 255)
Segunda línea: Valor verde como un entero (por ejemplo, 128)
Tercera línea: Valor azul como un entero (por ejemplo, 0)

Salida:

Primera línea: Red: [red_value]
Segunda línea: Green: [green_value]
Tercera línea: Blue: [blue_value]

Hoja de referencia

Una tuple struct es una estructura sin campos con nombre. Combina los beneficios de crear un nuevo tipo con la simplicidad de una tupla.

Define una tuple struct usando la palabra clave struct seguida del nombre del tipo y los tipos de los campos entre paréntesis:

struct Color(i32, i32, i32);

Crea una instancia proporcionando valores entre paréntesis:

let red = Color(255, 0, 0);

Accede a los campos usando la notación de punto con el índice del campo:

red.0  // primer valor
red.1  // segundo valor
red.2  // tercer valor

Pruébalo tú mismo

use std::io;

// TODO: Define su estructura de tupla Color aquí

fn main() {
    // Leer el valor rojo
    let mut red_input = String::new();
    io::stdin().read_line(&mut red_input).expect("Failed to read line");
    let red: i32 = red_input.trim().parse().expect("Invalid input");
    
    // Leer el valor verde
    let mut green_input = String::new();
    io::stdin().read_line(&mut green_input).expect("Failed to read line");
    let green: i32 = green_input.trim().parse().expect("Invalid input");
    
    // Leer el valor azul
    let mut blue_input = String::new();
    io::stdin().read_line(&mut blue_input).expect("Failed to read line");
    let blue: i32 = blue_input.trim().parse().expect("Invalid input");
    
    // TODO: Crear una instancia de la estructura de tupla Color usando los valores de entrada
    
    // TODO: Acceder e imprimir cada componente de color usando la notación de índice
    // Formato: Red: [value], Green: [value], Blue: [value]
}