Learn Rust Coding · Aula

Structs e enums genéricos

Crie tipos de dados flexíveis.

Structs e enums genéricos é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 2 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.

Estruturas de Dados Genéricas

Assim como as funções, estruturas e enumerações podem ser genéricas em relação a um ou mais tipos. Isso permite que uma única definição armazene valores de qualquer tipo.

A biblioteca padrão é construída dessa forma: Vec<T>, Option<T> e Result<T, E> são todos genéricos.

Uma Estrutura Genérica

Declare o parâmetro de tipo depois do nome da estrutura e use-o nos campos. Aqui, Point armazena dois valores do mesmo tipo T.

Agora uma única definição atende a pontos inteiros, pontos de ponto flutuante e muito mais.

struct Point<T> {
    x: T,
    y: T,
}

Construindo Estruturas Genéricas

Ao criar uma instância, o compilador infere T a partir dos valores dos campos. Ambos os campos precisam concordar com o mesmo tipo.

Este programa constrói um ponto inteiro e um ponto de ponto flutuante a partir da mesma estrutura.

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let a = Point { x: 1, y: 2 };
    let b = Point { x: 1.5, y: 4.0 };
    println!("{} {}", a.x, b.y);
}

Parâmetros de Tipo Mistos

Usar dois parâmetros permite que os campos sejam diferentes. Pair<T, U> pode armazenar um inteiro e uma string ao mesmo tempo.

Escolha um parâmetro quando os campos precisarem coincidir e vários quando eles puderem variar.

struct Pair<T, U> {
    first: T,
    second: U,
}

Métodos em Estruturas Genéricas

Para adicionar métodos, repita o parâmetro de tipo no bloco impl: impl<T> Point<T>. O parâmetro depois de impl o declara; depois do nome do tipo, ele o aplica.

Aqui, um acessador retorna uma referência ao campo x.

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

Métodos com Restrições

Você pode escrever métodos apenas para determinados tipos concretos ou para tipos que atendam a uma restrição. Este impl se aplica somente a Point<f64>.

Assim, dist_from_origin existe em pontos de ponto flutuante, mas não em pontos inteiros.

struct Point<T> { x: T, y: T }

impl Point<f64> {
    fn dist_from_origin(&self) -> f64 {
        (self.x * self.x + self.y * self.y).sqrt()
    }
}

Uma Enumeração Genérica

Enumerações também podem ser genéricas. Cada variante pode carregar dados genéricos. Isso reproduz o funcionamento padrão de Option, que é ou Some(T) ou None.

Definir sua própria enumeração ajuda a entender como o tipo da biblioteca funciona.

enum Maybe<T> {
    Just(T),
    Nothing,
}

Dois Parâmetros em uma Enumeração

Result usa dois parâmetros para que os valores de sucesso e de erro possam ser diferentes. Esta é uma versão simplificada.

Vários parâmetros de tipo em enumerações permitem um tratamento flexível de erros em todo o ecossistema.

enum Either<L, R> {
    Left(L),
    Right(R),
}

Correspondência de Enumerações Genéricas

Você faz correspondência de padrões com enumerações genéricas exatamente como com as concretas. O conteúdo da variante restrita se torna uma vinculação dentro do braço.

Este programa remove o invólucro de um Maybe personalizado e imprime o valor contido ou uma alternativa.

enum Maybe<T> { Just(T), Nothing }

fn main() {
    let m: Maybe<i32> = Maybe::Just(5);
    match m {
        Maybe::Just(n) => println!("got {}", n),
        Maybe::Nothing => println!("empty"),
    }
}

Envolvendo um Valor

Um padrão comum é uma estrutura envoltória com um campo do tipo T e métodos auxiliares. Aqui, Wrapper armazena e retorna qualquer valor.

Essa é a base dos padrões newtype e dos tipos semelhantes a ponteiros inteligentes.

struct Wrapper<T> { inner: T }

impl<T> Wrapper<T> {
    fn new(v: T) -> Self {
        Wrapper { inner: v }
    }
}

fn main() {
    let w = Wrapper::new("hi");
    println!("{}", w.inner);
}

Sem Sobrecarga em Tempo de Execução

Estruturas e enumerações genéricas também são monomorfizadas. Point<i32> e Point<f64> tornam-se dois tipos distintos e totalmente especializados após a compilação.

Não há indireção oculta nem marcador para o próprio tipo genérico.

Verificação Rápida

Teste sua compreensão sobre estruturas e enumerações genéricas.

Recapitulação

Estruturas e enumerações declaram parâmetros de tipo depois do nome e os usam em campos e variantes, permitindo contêineres reutilizáveis como Option e Result.

Os métodos repetem os parâmetros em impl<T>, e você pode escrever blocos impl especializados para tipos concretos. Tudo é monomorfizado, sem sobrecarga.

Perguntas Frequentes

A aula “Structs e enums genéricos” é grátis?

Sim — o texto completo de “Structs e enums genéricos” é 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 “Structs e enums genéricos”?

Crie tipos de dados flexíveis. 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 2 de 4.

Quanto tempo leva a aula “Structs e enums genéricos”?

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

← Voltar para Learn Rust Coding