Noções Básicas de Structs

9 exemplos para você começar com structs - 6 básicos e 3 intermediários.

Pré-requisitos

• Noções Básicas de Rust
• Variáveis, Mutabilidade e Sombreamento

Exemplos Básicos

1. Definição de Struct Nomeada

struct User {
    id: u64,
    active: bool,
}
 
fn main() {
    let u = User { id: 1, active: true };
    println!("{} {}", u.id, u.active);
}

• Campos são nomeados e tipados
• Acesso com notação de ponto: u.id
• A ordem dos campos no literal pode diferir da definição (desde Rust 2021)
• A struct possui seus campos, a menos que sejam referências

Relacionado: Métodos e Funções Associadas

2. Atalho de Inicialização de Campo

struct Point { x: i32, y: i32 }
 
fn main() {
    let x = 3;
    let y = 4;
    let p = Point { x, y };
    println!("({}, {})", p.x, p.y);
}

• Point { x, y } expande para Point { x: x, y: y }
• Funciona quando os nomes das variáveis correspondem aos nomes dos campos
• Reduz a repetição em construtores
• Comum em código estilo builder

3. Struct de Tupla

struct Meters(f64);
 
fn main() {
    let d = Meters(10.0);
    println!("{}", d.0);
}

• Structs de tupla dão significado a um único valor (padrão newtype)
• Acesse campos de tupla com .0, .1, ...
• Distinto de f64 puro, apesar da mesma representação
• Útil para unidades e IDs

4. Struct Unit

struct Marker;
 
fn main() {
    let _m = Marker;
}

• Sem campos - tipo de tamanho zero (ZST) frequentemente
• Usado como marcadores em padrões de estado de tipo
• PhantomData é frequentemente preferido para marcadores genéricos
• Implementa traits sem carregar dados

5. Sintaxe de Atualização

struct Config { host: String, port: u16 }
 
fn main() {
    let base = Config { host: "localhost".into(), port: 8080 };
    let alt = Config { port: 3000, ..base };
    println!("{}:{}", alt.host, alt.port);
}

• ..base copia os campos restantes de base
• base é movido campo a campo para alt para campos não especificados
• Após a movimentação de host, base.host é inválido
• Padrão para variantes em padrões

6. Campos Mutáveis de Struct

struct Counter { value: u32 }
 
fn main() {
    let mut c = Counter { value: 0 };
    c.value += 1;
    println!("{}", c.value);
}

• mut na ligação permite a mutação de campos
• Campos individuais não podem ser mut na definição da struct
• Mutabilidade interna usa Cell/RefCell para handles compartilhados
• Prefira métodos que encapsulam a mutação

Exemplos Intermediários

7. Struct com Referências

struct Excerpt<'a> {
    text: &'a str,
}
 
fn main() {
    let article = String::from("Hello");
    let e = Excerpt { text: &article };
    println!("{}", e.text);
}

• Parâmetro de lifetime ao armazenar empréstimos
• Excerpt não pode sobreviver a article
• Um campo String possuído não precisaria de 'a
• Veja a seção de Propriedade para lifetimes

8. #[derive(Debug)]

#[derive(Debug)]
struct Event { kind: u32, ts: u64 }
 
fn main() {
    println!("{:?}", Event { kind: 1, ts: 99 });
}

• Macros derive implementam automaticamente traits comuns
• Debug habilita a impressão com {:?}
• Nem todos os traits são deriváveis (Display requer implementação manual)
• Veja a página Deriving Traits

9. Desestruturação de Structs

struct Pair { a: i32, b: i32 }
 
fn sum(Pair { a, b }: Pair) -> i32 {
    a + b
}
 
fn main() {
    println!("{}", sum(Pair { a: 2, b: 3 }));
}

• O padrão de correspondência extrai campos em parâmetros let e fn
• let Pair { a, .. } = p ignora o restante com ..
• Funciona em braços match
• Veja a página Destructuring

Relacionado: Melhores Práticas de Structs e Enums

Versões da Stack: Esta página foi escrita para Rust 1.97.0 (edição 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, e Polars 0.46+.