Um recurso importante que torna o Rust poderoso e mais atraente é o suporte a structs. Estruturas são tipos de dados compostos para agrupar dados relacionados. Eles permitem que você defina tipos de dados personalizados com campos nomeados que melhoram a organização do código e facilitam a manipulação de dados.
Você pode usar structs para representar vários objetos, incluindo configurações e tipos de dados definidos pelo usuário. As estruturas são mais flexíveis do que muitas outras estruturas de dados. Sua capacidade de encapsular dados relacionados os torna úteis, pois criam um modelo mais lógico de objetos do mundo real.
Definindo Structs e Campos Struct
Você definirá uma estrutura usando o estrutura palavra-chave seguida por um nome para a estrutura. Siga isso especificando os nomes dos campos da struct e seus Tipos de dados de ferrugem dentro de um par de chaves.
estruturaPessoa {
nome: Corda,
idade: u8,
é_aluno: bool,
}
Esse Pessoa struct tem três campos. O nome campo é uma string, o idade campo é um inteiro sem sinal de 8 bits, e o campo é_aluno campo é um booleano.
Você pode usar literais de struct para criar instâncias de struct após a definição de struct. Literais struct especificam os valores dos campos de uma struct.
deixar pessoa = Pessoa {
nome: Corda::de("John"),
idade: 27,
é_aluno: verdadeiro,
};
O pessoa variável é uma instância do Pessoa struct, criado com um struct literal. Esse literal instancia todos os campos da struct com valores de seu tipo de dados correspondente.
Usando Construtores para Criar Estruturas
Você também pode usar uma função de construtor para criar uma instância de um struct.
implicar Pessoa {
// Define uma função construtora `new` que recebe `name`, `age` e
// Parâmetros `is_student`
fnnovo(nome: Corda, idade: u8, is_student: bool) -> Auto {
// Cria uma nova instância da estrutura `Person` e inicializa seus campos
// com os valores fornecidos
Auto {
nome,
idade,
é_aluno,
}
}
}
// Chame a função construtora `new` da estrutura `Person` e atribua o
// instância resultante para `person`
deixar pessoa = Pessoa:: novo(Corda::de("John"), 27, verdadeiro);
O programa acima define um construtor para o Pessoa estrutura com o implicar palavra-chave. O novo O construtor recebe os campos struct como argumentos e retorna uma nova instância do struct com os valores inicializados.
Você pode criar um Pessoa instância com o novo construtor, passando os argumentos apropriados.
Acessando e Modificando Campos Struct
Você pode acessar e modificar campos struct usando uma notação de ponto. Você simplesmente usa o ponto (.) seguido do nome do campo para acessar ou alterar seu valor.
// declara uma estrutura Person
estruturaPessoa {
nome: Corda,
idade: u8,
é_aluno: bool,
}fnprincipal() {
// instancia uma struct
deixarmudo pessoa = Pessoa {
nome: Corda::de("John"),
idade: 27,
é_aluno: verdadeiro,
};// imprime os campos nome e idade da struct
println!("Nome: {}", nome.pessoa);
println!("Idade: {}", pessoa.idade);// modifica o campo is_student
person.is_student = falso;
println!("É aluno: {}", pessoa.é_aluno);
}
O programa cria uma estrutura, instancia a estrutura, imprime o nome, e idade campos e modifica os é_aluno campo antes de imprimir o campo.
Declarando Métodos para Estruturas
Diferente estruturas em C, você pode definir métodos em estruturas Rust que operam em uma instância. Métodos são funções que usam uma referência a uma estrutura para acesso e modificação. Você também pode usar a notação de ponto para chamar os métodos de uma estrutura e acessar sua funcionalidade.
Veja como você pode declarar métodos para structs e usar esses métodos para realizar operações:
estruturaPessoa {
nome: Corda,
idade: u8,
é_aluno: bool,
}implicar Pessoa {
fndiga olá(&auto) {
println!("Olá, meu nome é {} e tenho {} anos.", auto.nome,
auto.idade);
}fnter_aniversário(&mudoauto) {
auto.idade += 1;
}
}fnprincipal() {
deixarmudo pessoa = Pessoa {
nome: Corda::de("John"),
idade: 27,
é_aluno: verdadeiro,
};person.say_hello();
pessoa.tem_aniversário();
println!("Nova era: {}", pessoa.idade);
}
O programa define dois métodos para o Pessoa struct. O diga olá método leva uma referência a auto e imprime uma saudação que inclui o nome e a idade da pessoa. O ter_aniversário método leva uma referência mutável para auto e incrementa a idade da pessoa.
O modelo de propriedade do Rust otimiza o gerenciamento de memória
Structs são estruturas de dados versáteis, agindo como uma espécie de classe mínima equivalente.
Assim como em outras estruturas de dados do Rust, você deve seguir as regras de propriedade do Rust ao trabalhar com variáveis struct. O modelo de propriedade garante que você gerencie a memória com eficiência em seus programas, evitando problemas comuns como ponteiros nulos e pendentes.