Estructuras

Hay tres tipos de estructuras ("struct") que se pueden crear usandola palabra clave 'struct`:

• Estructuras de tupla, las cuales son básicamente tuplas nombradas.
• Las clásicas estructuras struct de C
• Las structs unitarias, las cuales no tienen campos, y son útiles para los genéricos.

// Un atributo para esconder las advertencias del código no utilizado.
#![allow(dead_code)]

#[derive(Debug)]
struct Person {
    name: String,
    age: u8,
}

// Una struct unitariastruct Unit;

// Una struct de tuplastruct Pair(i32, f32);

// Una struct de dos campos
struct Point {
    x: f32,
    y: f32,
}

// Las Structs pueden reutilizar los campos de otras structs
struct Rectangle {
    // Un rectángulo se puede escpecificar por dónde las esquinas de arriba a la izquierda y abajo a la derecha    // se encuentran en el espacio.
    top_left: Point,
    bottom_right: Point,
}

fn main() {
    // Abreviación para crear un struct con un campo ya inicializado
    let name = String::from("Peter");
    let age = 27;
    let peter = Person { name, age };

    // Imprime un struct de depuración
    println!("{:?}", peter);

    // Instanciar un `Point`
    let point: Point = Point { x: 5.2, y: 0.4 };
    let another_point: Point = Point { x: 10.3, y: 0.2 };

    // Accesa los campos del punto
    println!("coordenadas del punto: ({}, {})", point.x, point.y);

    // Crea un nuevo punto usando la sintáxis de update de struct para usar los campos
    // del otro struct
    let bottom_right = Point { x: 10.3, ..another_point };

    // `abajo_derecha.y` va a ser lo mismo que `otro_punto.y` por que usamos ese campo 
    // de `otro_punto`
    println!("segundo punto: ({}, {})", bottom_right.x, bottom_right.y);

    // Destructura el punto con un enlace `let`
    let Point { x: left_edge, y: top_edge } = point;

    let _rectangle = Rectangle {
        // también se puede hacer la instanciación de un struct con una expresión        top_left: Point { x: left_edge, y: top_edge },
        bottom_right: bottom_right,
    };

    // Instacia una struct unitaria    let _unit = Unit;

    // Instancia una estructura de tupla
    let pair = Pair(1, 0.1);

    // Accesa los campos de una estructura de tupla
    println!("un par contiene {:?} y {:?}", pair.0, pair.1);

    // Destructura una estructura de tupla    let Pair(integer, decimal) = pair;

    println!("un par contiene {:?} y {:?}", integer, decimal);
}

Actividad

1. Agregue una función rect_area que calcula el área de un Rectangle (intentausar de la destructación anidada).
2. Agregue una función square que toma un Punto y un f32 como argumentos, y devuelve un Rectangle con su esquina superior izquierda en el punto, y un ancho yaltura correspondiente al f32.

Véase también

attributes, raw identifiers y destructuring