0Pricing
Learn Rust Coding · Aula

Despacho estático versus dinâmico

Compensações

Despacho estático versus dinâmico é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

Duas formas de despacho

Quando você chama um método de traço, o Rust precisa decidir qual implementação concreta será executada. Há duas estratégias: despacho estático (decidido em tempo de compilação) e despacho dinâmico (decidido durante a execução).

Despacho estático com genéricos

Funções genéricas usam despacho estático. O compilador gera uma cópia especializada para cada tipo concreto — um processo chamado monomorfização.

trait Area { fn area(&self) -> f64; }
struct Square { s: f64 }
impl Area for Square { fn area(&self) -> f64 { self.s * self.s } }

fn print_area<T: Area>(shape: &T) {
    println!("{}", shape.area());
}

fn main() {
    print_area(&Square { s: 4.0 });
}

Monomorfização

Para cada tipo com o qual você chama a função, o compilador cria uma versão dedicada. A chamada do método se torna uma chamada direta, sem consulta, e fica tão rápida quanto código escrito manualmente.

Despacho dinâmico com dyn

Objetos de traço usam despacho dinâmico. Uma função lida com todos os tipos; o endereço do método é encontrado durante a execução por meio de uma vtable.

trait Area { fn area(&self) -> f64; }
struct Square { s: f64 }
impl Area for Square { fn area(&self) -> f64 { self.s * self.s } }

fn print_area(shape: &dyn Area) {
    println!("{}", shape.area());
}

fn main() {
    print_area(&Square { s: 4.0 });
}

A vtable

Um objeto de traço é um ponteiro amplo: uma parte aponta para os dados e a outra para uma vtable que lista os endereços dos métodos. Cada chamada indexa essa tabela.

Essa indireção adicional é o custo durante a execução.

Compromisso de velocidade

O despacho estático é mais rápido por chamada e pode ser incorporado, mas gera mais código de máquina. O despacho dinâmico adiciona uma pequena indireção, mas mantém o tamanho do código reduzido.

Para a maioria das aplicações, a diferença é insignificante; escolha com base na flexibilidade.

Compromisso de tamanho do código

Chamar uma função genérica com muitos tipos cria muitas cópias, o que pode aumentar excessivamente o binário. Uma única função com dyn evita essa duplicação.

É por isso que às vezes as bibliotecas preferem objetos de traço internamente.

Compromisso de flexibilidade

Os genéricos exigem um tipo concreto por ponto de chamada, portanto não podem conter tipos mistos em uma coleção. Os objetos de traço podem. Se precisar de uma lista heterogênea, o despacho dinâmico é a resposta.

trait Area { fn area(&self) -> f64; }
struct Square { s: f64 }
struct Rect { w: f64, h: f64 }
impl Area for Square { fn area(&self) -> f64 { self.s * self.s } }
impl Area for Rect { fn area(&self) -> f64 { self.w * self.h } }

fn main() {
    let shapes: Vec<Box<dyn Area>> = vec![Box::new(Square { s: 2.0 }), Box::new(Rect { w: 3.0, h: 4.0 })];
    let total: f64 = shapes.iter().map(|s| s.area()).sum();
    println!("{}", total);
}

Combinando os dois

Você pode combiná-los: uma função genérica pode aceitar impl Trait na fronteira e armazenar valores como Box<dyn Trait> internamente. Use cada um onde for mais adequado.

Um guia para decidir

Regras rápidas:

  • Um tipo por chamada, em um caminho crítico? Use genéricos (estático).
  • Tipos mistos em uma coleção? Use dyn (dinâmico).
  • Preocupado com o tamanho do binário? Prefira dyn.

Ambos não têm custo onde importa

Rust nunca adiciona custos que você não solicitou. Os genéricos não têm custo em tempo de execução; os objetos de traço custam apenas uma indireção de ponteiro. Você escolhe explicitamente a compensação.

Verificação rápida

Teste seus conhecimentos sobre despacho.

Recapitulação

Você comparou os dois estilos de despacho:

  • Estático (genéricos): monomorfizado, rápido, binário maior, um tipo por chamada
  • Dinâmico (dyn): consulta à tabela de métodos virtuais, flexível, código menor, permite coleções mistas
  • Escolha com base nas necessidades de flexibilidade, desempenho e tamanho do binário

Perguntas Frequentes

A aula “Despacho estático versus dinâmico” é grátis?

Sim — o texto completo de “Despacho estático versus dinâmico” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Despacho estático versus dinâmico”?

Compensações Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Despacho estático versus dinâmico”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Definição de traits
  2. Objetos de trait e dyn
  3. Despacho estático versus dinâmico
  4. Métodos padrão
← Voltar para Learn Rust Coding