Introdução
Os ponteiros inteligentes em Cairo são estruturas de dados avançadas que garantem um gerenciamento de memória seguro e eficiente ao adicionar recursos de segurança aos ponteiros comuns, evitando problemas comuns como desreferenciar ponteiros nulos ou acessar memória não inicializada.
O que é um ponteiro inteligente?
Um ponteiro inteligente se comporta como um ponteiro comum, mas rastreia a propriedade dos dados e garante um acesso seguro à memória, evitando problemas como desreferenciar ponteiros nulos ou pendentes.
Tipos de ponteiros inteligentes
Cairo oferece vários tipos de ponteiro inteligente, como Box<T> e Nullable<T>:
-
Box<T>: Armazena dados em um segmento de memória especial, ideal para dados grandes ou de tamanho dinâmico.
Permite transferir a propriedade sem copiar os dados.
-
Nullable<T>: Aponta para um valor válido do tipo T ou para null, útil para lidar com valores opcionais.
Segurança de memória
Os ponteiros inteligentes ajudam a evitar acessos inseguros à memória. A memória é desalocada automaticamente quando não é mais necessária, o que reduz o risco de vazamentos de memória.
Exemplo: usar Box<T> para tipos recursivos
Ponteiros inteligentes como Box<T> permitem lidar com tipos recursivos com segurança, como em uma árvore binária, alocando memória de forma eficiente e evitando recursão infinita.
use core::box::{BoxTrait};
#[derive(Copy, Drop)]
enum BinaryTree {
Leaf: u32,
Node: (u32, Box<BinaryTree>, Box<BinaryTree>),
}
fn main() {
let leaf1 = BinaryTree::Leaf(1);
let leaf2 = BinaryTree::Leaf(2);
let node = BinaryTree::Node((3, BoxTrait::new(leaf1), BoxTrait::new(leaf2)));
println!("{:?}", node);
}
Benefícios de desempenho
Os ponteiros inteligentes melhoram o desempenho passando referências aos dados em vez de copiar estruturas grandes, o que reduz a sobrecarga de memória.
// `Cart` is a large struct that contains a lot of information
fn pass_pointer(cart: Box<Cart>) {
let cart = cart.unbox();
println!("{} is shopping today and bought {} items", cart.buyer, cart.items);
}
Instruções
Em Chrono Realms, os Time Keepers muitas vezes lidam não apenas com árvores de linhas do tempo, mas com Chrono Chains: sequências de TimeNodes encadeados, cada um representando um momento específico no tempo.
Uma Chrono Chain é um caminho reto de momentos sequenciais, em que cada TimeNode se conecta ao próximo.
Essas Chrono Chains são úteis ao viajar por uma série de eventos específicos, pois permitem que os Time Keepers sigam uma única linha do tempo.
No entanto, para lidar com essas Chrono Chains potencialmente longas, os Time Keepers usam Ponteiros Inteligentes (Box<t>)</t> para gerenciar e percorrer com segurança essas listas de momentos sem causar duplicação desnecessária de memória nem estouro.
Cada TimeNode guarda uma referência para o próximo nó, formando uma estrutura recursiva.
Sua tarefa como aprendiz é implementar uma Chrono Chain como uma estrutura de lista recursiva usando ponteiros inteligentes.
Neste exercício, você vai:
- Criar um enum recursivo
ChronoChain, representando uma lista de momentos.
- Usar o ponteiro inteligente
Box<T> para armazenar os nós recursivos.
- Implementar uma função para criar uma
ChronoChain a partir de um array de valores u32.
- Implementar uma função para percorrer a
ChronoChain e somar os valores armazenados na lista.
1. Defina o enum recursivo ChronoChain
Crie um enum recursivo ChronoChain com duas variantes:
-
End: representa o fim da lista.
-
Link: contém um valor u32 e uma referência acondicionada em Box para o próximo nó da cadeia.
2. Crie uma função para construir uma ChronoChain
Escreva uma função ChronoChain::build que recebe um array de valores u32 e retorna uma ChronoChain, encadeando os valores em sequência com ponteiros inteligentes.
3. Implemente a função de soma
Escreva uma função ChronoChain::sum para percorrer a ChronoChain recursivamente e somar os valores de todos os nós.
Exemplo de uso
fn main() {
// Create a ChronoChain from an array of values
let chrono_chain = ChronoChain::build(array![10, 20, 30]);
// Sum the values in the ChronoChain
let total_sum = chrono_chain.sum();
println!("Total Time Power: {}", total_sum);
}
Exercício de aprendizagem
