Estructuras - struct

Se puede ver este capítulo en YouTube en inglés: Parte 1 y Parte 2

Con las estructuras se pueden crear nuevos tipos de datos. Se utilizan constantemente en Rust, puesto que son muy útiles. Las estructuras se crean con la palabra reservada struct. El nombre de las estructuras debería estar en UpperCamelCase (una letra mayúscula por cada palabra sin espacios, ni guiones bajos). Si se escribe todo en minúsculas, el compilador avisará.

Existen tres tipos de estructuras.

La primera de ellas es la estructura unitaria "unit struct", que no tiene nada. Simplemente se escribe su nombre seguido de un punto y coma.

struct FileDirectory;
fn main() {}

La segunda de ellas es la estructura tupla, o estructura sin nombres. Solo es necesario escribir los tipos de dato que contiene, sin nombres de campo. Las estructuras de tupla son indicadas cuando se necesita una estructura simple sin necesidad de utilizar nombres.

struct Colour(u8, u8, u8);

fn main() {
    let my_colour = Colour(50, 0, 50); // Crea un color RGB (red, green, blue)
    println!("La segunda parte del color (la componente verde) es: {}", my_colour.1);
}

Este código imprime La segunda parte del color (la componente verde) es: 0.

El tercer tipo es la estructura con nombres. Que es, probablemente, la más habitual. En estas estructuras se declaran los nombres de los campos y sus tipos en un bloque {}. Estos bloques no se terminan con punto y coma.

struct Colour(u8, u8, u8); // Declara la misma estructura tupla para el color

struct SizeAndColour {
    size: u32,
    colour: Colour, // y la inserta en una estructura con nombres
}

fn main() {
    let my_colour = Colour(50, 0, 50);

    let size_and_colour = SizeAndColour {
        size: 150,
        colour: my_colour
    };
}

Los campos de una estructura con nombres se separan con comas. El último campo puede llevar o no la coma. En el caso anterior, se puso una coma después de definir el campo colour: Colour,, pero no es necesario. Normalmente, se considera buena idea poner siempre la coma, porque en ocasiones resulta necesario cambiar el orden de los campos o añadir uno al final y de este modo es sistemática la modificación:

struct Colour(u8, u8, u8); 

struct SizeAndColour {
    size: u32,
    colour: Colour // Sin coma
}

fn main() {}

Se dedice cambiar su orden, cortando y pegando la fila...

struct SizeAndColour {
    colour: Colour // ⚠️ ¡Error! ya que no tiene coma.
    size: u32,
}

fn main() {}

En todo caso, no es muy importante si se usa la coma o no.

En el siguiente ejemplo, se crea una estructura Pais que tiene los campos poblacion, capitaly presidente.

struct Pais {
    poblacion: u32,
    capital: String,
    presidente: String
}

fn main() {
    let poblacion = 500_000;
    let capital = String::from("Elista");
    let presidente = String::from("Batu Khasikov");

    let kalmykia = Pais {
        poblacion: poblacion,
        capital: capital,
        presidente: presidente,
    };
}

Se observa que resuta prolijo tener que escribir el nombre del campo y su valor. Se escribe doble. poblacion: poblacion, capital: capital y presidente: presidente. Como se trata de alto habitual, Rust proporciona un atajo si tanto el campo, como la variable que contiene el valor se llaman igual. En ese caso, se puede simplificar así:

struct Pais {
    poblacion: u32,
    capital: String,
    presidente: String
}

fn main() {
    let poblacion = 500_000;
    let capital = String::from("Elista");
    let presidente = String::from("Batu Khasikov");

    let kalmykia = Pais {
        poblacion,
        capital,
        presidente,
    };
}