Ponteiros e o Operador de Endereço

Ponteiros armazenam o endereço de um valor, permitindo mutação entre limites de função e evitando grandes cópias.

Go tem ponteiros, mas não aritmética de ponteiros, mantendo a segurança de memória simplificada.

Resumo

&x obtém o endereço de x; *p desreferencia o ponteiro p.

Argumentos de função são passados por valor; compartilhe mutação passando ponteiros.

Receptores de métodos podem ser valores ou ponteiros; receptores de ponteiro são necessários quando métodos modificam o estado.

Receita

Cartão de referência rápida - pronto para copiar e colar.

package main
 
import "fmt"
 
func increment(n *int) {
    *n++
}
 
func main() {
    count := 10
    increment(&count)
    fmt.Println(count)
}

Quando usar isso:

• Modificar o estado do chamador a partir de uma função.
• Evitar copiar structs grandes em caminhos de acesso frequente (perfile primeiro).
• Representar campos opcionais ou anuláveis com *T.
• Implementar métodos que modificam campos do receptor.

Exemplo de Trabalho

package main
 
import "fmt"
 
type Config struct {
    Host string
    Port int
}
 
func (c *Config) SetPort(p int) {
    c.Port = p
}
 
func clone(cfg Config) Config {
    return cfg // struct copiada por valor
}
 
func main() {
    cfg := Config{Host: "localhost", Port: 8080}
    cfg.SetPort(9090)
 
    copy := clone(cfg)
    copy.Port = 1
    fmt.Println(cfg.Port, copy.Port)
 
    var p *int
    if p != nil {
        fmt.Println(*p)
    } else {
        fmt.Println("p é nulo")
    }
}

O que isso demonstra:

• O receptor de ponteiro SetPort modifica cfg no local.
• A atribuição de struct copia valores - copy.Port não afeta cfg.
• A verificação de ponteiro nulo antes da desreferenciação evita pânico.
• & não é necessário ao chamar métodos de receptor de ponteiro em valores endereçáveis.

Mergulho Profundo

Como Funciona

• Variáveis vivem na pilha ou no heap com base na análise de escape, não se você usa &.
• new(T) aloca um T zerado e retorna *T; código idiomático frequentemente usa &T{}.
• Ponteiros nil comparam igual entre si e com nil não tipado em contexto de ponteiro tipado.
• Interfaces que contêm ponteiros nulos tipados não são iguais a uma interface nil.

Passagem por Valor vs. Ponteiro

Seleção de Receptor

Notas de Go

// Campo opcional
type User struct {
    Name string
    Nick *string // nil significa não definido
}
 
// Não passe ponteiro para variável de loop sem copiar
for i := 0; i < 3; i++ {
    n := i
    go func() { fmt.Println(&n) }()
}

Armadilhas

• Desreferenciação de ponteiro nulo - *p quando p == nil causa pânico. Correção: verifique p != nil ou garanta a construção.
• Nil tipado em interfaces - return (*T)(nil), err ainda torna a interface não nula. Correção: retorne uma interface nula ou um valor concreto.
• Ponteiro para cabeçalho de mapa/slice - Raramente necessário; slices/mapas já modificam através de um cabeçalho compartilhado. Correção: passe o slice/mapa diretamente.
• Obter endereço da variável de range - Antes de 1.22, as variáveis de loop reutilizavam um único endereço. Correção: copie item := item dentro do loop.
• Uso excessivo de ponteiros - Structs pequenas custam menos para copiar do que a indireção e a pressão do GC. Correção: passe por valor até que a análise de desempenho diga o contrário.
• Modificar através de ponteiro para dados constantes - Não é possível apontar para constantes não tipadas; deve-se apontar para variáveis.

Alternativas

FAQs

Relacionados

• Structs, Embedding & Field Promotion - Receptores de ponteiro em tipos compostos
• Valores Zero e Inicialização - Ponteiros nulos e new
• Variáveis, Constantes & Escopo - Endereço de variáveis de loop
• Arrays, Slices & Maps em um Relance - Quando ponteiros agregam pouco valor para slices

Links Relacionados Externos

• A Tour of Go - Introdução interativa oficial ao Go.
• Effective Go - Guia oficial para escrever Go claro e idiomático.
• Go by Example - Exemplos práticos de código anotados.
• Learning Go (2nd Edition) - Jon Bodner.
• Get Programming with Go (Manning) - Nathan Youngman & Roger Peppé.

Versões de Stack: Esta página foi escrita para Go 1.26.x (padrão Green Tea GC, go fix modernizers - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).