Semântica de Move e Cópia

Atribuição e passagem por valor movem (transferem propriedade) ou copiam (duplicam bits) dependendo do tipo. Clone fornece duplicação explícita quando necessário.

Receita

#[derive(Clone, Debug)]
struct Config { host: String, port: u16 }
 
fn main() {
    let port: u16 = 8080; // Cópia
    let p2 = port;
 
    let cfg = Config { host: "localhost".into(), port };
    let cfg2 = cfg.clone(); // cópia profunda explícita
    println!("{port} {:?} {:?}", cfg, cfg2);
}

Quando usar isso: Decidir se um tipo deve ser Copy, quando usar clone(), e projetar APIs que movem vs. emprestam.

Exemplo de Trabalho

#[derive(Copy, Clone, Debug)]
struct Point { x: i32, y: i32 }
 
fn translate(p: Point, dx: i32) -> Point {
    Point { x: p.x + dx, y: p.y }
}
 
fn main() {
    let origin = Point { x: 0, y: 0 };
    let moved = origin; // Cópia - ambos válidos
    let shifted = translate(moved, 5);
    println!("{origin:?} {shifted:?}");
}

O que isso demonstra:

• Point é Copy porque todos os campos são Copy
• origin permanece utilizável após a atribuição
• Pequenos agregados apenas na stack são bons candidatos a Copy
• String não pode ser Copy (propriedade do heap)

Mergulho Profundo

Semântica de Move

• Atribuição não-Copy invalida o binding de origem
• Moves são baratos para tipos de heap (cópia de ponteiro)
• Parâmetros de função por valor assumem propriedade, a menos que emprestados
• Vec, String, HashMap sempre movem na atribuição

Requisitos de Copy

// Todos os campos Copy, sem impl Drop (geralmente)
#[derive(Copy, Clone)]
struct Flags(u32);

Tipos com Drop customizado geralmente não podem ser Copy.

Clone vs Copy

Clone em Coleções

let v1 = vec![1, 2];
let v2 = v1.clone(); // clona elementos se T: Clone

Armadilhas

• Derivar Copy em struct com String - Erro de compilação. Correção: Remover Copy ou usar &str/Arc<str> se o compartilhamento for necessário.
• Clonar em loops - Oculta problemas de desempenho. Correção: Reestruturar para emprestar ou reutilizar buffers.
• Assumir que a atribuição copia Vec - Ela move. Correção: Usar .clone() explicitamente quando a duplicata for necessária.
• Conflito Copy + Drop - Drop customizado significa que a semântica de move importa. Correção: Não implementar Copy.
• Move parcial e depois usa struct - Campos movidos invalidam o uso da struct inteira em alguns casos. Correção: Desestruturar ou emprestar campos.

Alternativas

FAQs

Relacionados

• Noções Básicas de Propriedade - regra de proprietário único
• Empréstimos e Referências - evitar moves
• Rc & Arc - propriedade compartilhada
• Cow - clone sob demanda

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+.