Símbolo de asterístico | Rust

• Símbolo de asterístico | Rust

---

📌 Visão Geral

O operador * no Rust é polimórfico — seu significado depende do contexto.

Ele pode representar:

• Desreferência (principal uso)
• Multiplicação
• Parte de tipos de ponteiros raw
• Pattern matching
• Sobrecarga via trait (Deref)

---

🔹 1. Desreferência (Deref)

Conceito

O * acessa o valor apontado por uma referência.

let x = 10;
let r = &x;

println!("{}", *r); // 10

Tipos envolvidos

• &T → referência
• * → retorna T

Modelo mental

&x  -> endereço
*x  -> valor

Rust trata referências como tipos seguros, garantindo validade em tempo de compilação

---

🔹 2. Multiplicação

Uso aritmético padrão:

let resultado = 5 * 3; // 15

Sem diferenças relevantes de outras linguagens.

---

🔹 3. Pattern Matching (Desestruturação)

Usado para “remover” referência em padrões:

let r = &10;

match r {
    &valor => println!("{}", valor),
}

Equivalente a:

let valor = *r;

---

🔹 4. Ponteiros Raw (*const / *mut)

Conceito

* faz parte da definição de ponteiros de baixo nível.

let p: *const i32;
let p2: *mut i32;

Características

• Não são seguros por padrão
• Exigem unsafe
• Não seguem regras de borrowing

Uso

let x = 10;
let p = &x as *const i32;

unsafe {
    println!("{}", *p);
}

---

🔹 5. Trait Deref (Sobrecarga do *)

O operador * pode ser customizado via:

• Deref
• DerefMut

Exemplo

use std::ops::Deref;

struct Wrapper(i32);

impl Deref for Wrapper {
    type Target = i32;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

let w = Wrapper(10);
println!("{}", *w); // 10

Observação

Esse mecanismo é usado internamente por:

• Box<T>
• Vec<T>
• String

---

🔹 6. Interação com Ownership

O * não move o valor automaticamente, depende do contexto:

let x = String::from("abc");
let r = &x;

// *r ainda é uma referência indireta
println!("{}", *r);

Movimento só ocorre se você consumir o valor explicitamente.

---

⚠️ Pontos de Atenção

• * em Rust não é igual C/C++

  • Não existe aritmética de ponteiros segura

• Desreferência automática acontece em muitos casos (coerção)

• Raw pointers (*const, *mut) devem ser evitados fora de casos específicos

---

📊 Resumo Geral

Contexto	Significado
*x	Desreferência
a * b	Multiplicação
*const T	Ponteiro raw imutável
*mut T	Ponteiro raw mutável
match &x	Desestruturação
Deref	Sobrecarga do operador

---

🧠 Regra de Ouro

Sempre leia * como: “acessar o valor por trás” Se você não usar *, você está lidando com a referência, não com o valor.

---