Definindo e instanciando estruturas

Estruturas (ou estruturas) em Rust são tipos de dados personalizados que permitem agrupar vários valores relacionados. Eles são semelhantes a objetos ou classes de outras linguagens, mas sem herança.

Definindo uma estrutura

Para definir uma estrutura, usamos a palavra-chave struct seguida do nome em PascalCase. Dentro, definimos os nomes e tipos dos campos:

struct User {
    username: String,
    email: String,
    active: bool,
    sign_in_count: u64,
}

Criando uma instância

Para usar uma struct, devemos criar uma instância preenchendo todos os campos especificados:

fn main() {
    let user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };

    // Access fields using dot notation
    println!("Is user {} active? {}", user1.username, user1.active);
}

Mutabilidade estrutural

No Rust, toda a instância deve ser marcada como mutável (mut) se você quiser modificar algum de seus campos. Rust não permite marcar apenas alguns campos como mutáveis:

fn main() {
    let mut user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };

    user1.active = false; // Valid because user1 is mutable!
}

Estruturas de tupla e estruturas semelhantes a unidades

Rust também oferece suporte a dois outros formatos de estrutura além das estruturas clássicas de campo nomeado:

1. Estruturas de Tupla: Possuem um nome associado mas os campos não possuem nomes individuais, apenas tipos. Eles são úteis para definir e diferenciar tipos específicos:
   Rust

   Copiar

   struct Point(i32, i32, i32);
   let origin = Point(0, 0, 0);

2. Estruturas semelhantes a unidades: Elas não definem nenhum campo. Eles se comportam como o tipo de unidade (). Eles são úteis quando você precisa implementar comportamentos (traços) em um tipo sem armazenar nenhum dado nele.

Experimente você mesmo