Como os ponteiros funcionam em Go?

Question

Accepted Answer

Um **ponteiro** armazena o **endereço de memória** de um valor em vez do próprio valor. Go possui ponteiros (como C) mas os mantém simples e seguros — sem aritmética de ponteiros, e o coletor de lixo gerencia a memória. Eles são usados para compartilhar e modificar dados de forma eficiente.

## Os dois operadores: & e *

```go
x := 42
p := &x          // & = "address of" → p is a *int (pointer to x)
fmt.Println(p)   // 0xc0000... (the address)
fmt.Println(*p)  // 42 — * = "dereference" (get the value at the address)

*p = 100         // change the value THROUGH the pointer
fmt.Println(x)   // 100 — x was modified via p
```

`&` obtém o endereço de uma variável; `*` (em um ponteiro) acessa ou define o valor para o qual aponta.

## Por que isso importa: modificando via funções

```go
// ❌ value parameter — the function gets a COPY; changes don't affect the caller
func incrementValue(n int) { n++ }       // caller's variable unchanged

// ✅ pointer parameter — the function can modify the caller's variable
func incrementPointer(n *int) { *n++ }

x := 5
incrementValue(x)     // x still 5
incrementPointer(&x)  // x is now 6
```

Como Go passa argumentos **por valor** (cópias), uma função só pode modificar os dados do chamador se receber um **ponteiro** para eles. Esta é a razão principal para usar ponteiros.

## Ponteiros com structs (muito comum)

```go
type Counter struct { count int }

// pointer receiver → method can modify the struct
func (c *Counter) Increment() { c.count++ }

c := &Counter{}      // a pointer to a Counter
c.Increment()        // modifies it (Go auto-dereferences: (*c).count++)
```

Os receptores de ponteiro são como os métodos mutam sua struct, e passar ponteiros de struct evita cópia de structs grandes.

## O ponteiro nil e o valor zero

```go
var p *int           // zero value of a pointer is nil
fmt.Println(p)       // <nil>
*p = 5               // 💥 PANIC: nil pointer dereference (no value to point to)
if p != nil { *p = 5 }   // guard against nil
```

Desreferenciar um ponteiro `nil` causa pânico — um erro de tempo de execução comum para proteger contra.

## O que os ponteiros de Go NÃO possuem (segurança)

```text
✗ NO pointer arithmetic (can't do p++ to move through memory like C)
✗ NO manual free — garbage collector reclaims memory
→ Pointers are about sharing/modifying data, not low-level memory hacking
```

## Por que isso importa

Os ponteiros são essenciais em Go para dois propósitos principais: **modificar** os dados do chamador (como Go passa por valor, apenas um ponteiro permite que uma função altere o original) e **eficiência** (passar um ponteiro evita cópia de structs grandes).

Eles são fundamentais para métodos com receptores de ponteiro (a forma padrão de mutar structs) e aparecem em toda Go idiomática.

Compreender `&`/`*`, semântica de valor versus ponteiro, o pânico de ponteiro nil, e que os ponteiros de Go são deliberadamente *seguros* (sem aritmética, gerenciados por GC) — focados em compartilhamento/mutação em vez de manipulação de memória ao estilo C — é conhecimento essencial para escrever Go correto e eficiente e um ponto frequente de confusão para iniciantes e em entrevistas.