Introdução
Os ponteiros inteligentes em Cairo são estruturas de dados avançadas que garantem uma gestão de memória segura e eficiente ao adicionar funcionalidades de segurança aos ponteiros normais, prevenindo problemas comuns como desreferenciar ponteiros nulos ou aceder a memória não inicializada.
O que é um ponteiro inteligente?
Um ponteiro inteligente comporta-se como um ponteiro normal, mas controla a propriedade e garante um acesso seguro à memória, prevenindo problemas como a desreferenciação de ponteiros nulos ou pendentes.
Tipos de ponteiros inteligentes
Cairo fornece vários tipos de ponteiros inteligentes, como Box<T> e Nullable<T>:
-
Box<T>: Armazena dados num 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 da memória
Os ponteiros inteligentes ajudam a prevenir acessos inseguros à memória, garantindo que a memória é automaticamente libertada quando já não é necessária, reduzindo assim o risco de fugas de memória.
Exemplo: Utilizar Box<T> para tipos recursivos
Ponteiros inteligentes como Box<T> permitem um manuseamento seguro de tipos recursivos, como numa árvore binária, ao alocar memória de forma eficiente e evitar a 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);
}
Vantagens de desempenho
Os ponteiros inteligentes melhoram o desempenho ao passar referências para os dados em vez de copiar grandes estruturas, reduzindo 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 lidam muitas vezes não só com árvores de linhas temporais, mas também com Chrono Chains: sequências de TimeNodes ligados entre si, cada um a representar um momento específico no tempo.
Uma Chrono Chain é um caminho reto de momentos sequenciais, em que cada TimeNode se liga ao seguinte.
Estas Chrono Chains são úteis quando se viaja por uma série de eventos específicos, pois permitem aos Time Keepers seguir uma única linha temporal.
No entanto, para lidar com estas Chrono Chains potencialmente longas, os Time Keepers usam apontadores inteligentes (Box<t>)</t> para gerir e percorrer com segurança estas listas de momentos, sem causar duplicação desnecessária de memória nem transbordo.
Cada TimeNode guarda uma referência ao nó seguinte, formando uma estrutura recursiva.
A tua tarefa, como aprendiz, é implementar uma Chrono Chain como uma estrutura de lista recursiva com apontadores inteligentes.
Neste exercício, vais:
- Criar um enumerado recursivo
ChronoChain, que representa uma lista de momentos.
- Usar o apontador inteligente
Box<T> para guardar os nós recursivos.
- Implementar uma função que cria uma
ChronoChain a partir de um array de valores u32.
- Implementar uma função que percorre a
ChronoChain e soma os valores guardados na lista.
1. Define o enumerado recursivo ChronoChain
Cria um enumerado recursivo ChronoChain com duas variantes:
-
End: representa o fim da lista.
-
Link: contém um valor u32 e uma referência ao nó seguinte da cadeia, guardada numa Box.
2. Cria uma função para construir uma ChronoChain
Escreve uma função ChronoChain::build que recebe um array de valores u32 e devolve uma ChronoChain, ligando os valores em sequência com apontadores inteligentes.
3. Implementa a função de soma
Escreve uma função ChronoChain::sum que percorre a ChronoChain recursivamente e soma os valores de todos os nós.
Exemplo de utilização
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
