Estructuras - Rust By Example
Description: Rust by Example (RBE) is a collection of runnable examples that illustrate various Rust concepts and standard libraries.

## Keyboard shortcuts

Press `←` or `→` to navigate between chapters

Press `S` or `/` to search in the book

Press `?` to show this help

Press `Esc` to hide this help

# 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