Go Academy · Aula

O que são ponteiros?

Operador de endereço, desreferenciamento e ponteiros nil

O que são ponteiros? é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Endereços de memória

Cada variável vive em um endereço de memória. Um ponteiro armazena esse endereço. Em Go, os ponteiros têm tipo: um *int armazena o endereço de um int.

Operador de obtenção de endereço &

Use & para obter o endereço de uma variável:

package main
import "fmt"

func main() {
    x := 42
    p := &x
    fmt.Println(p)  // 0xc000... (address)
    fmt.Println(*p) // 42 (value at address)
}

Desreferenciação *

Use * para ler ou gravar o valor no endereço do ponteiro:

package main
import "fmt"

func main() {
    n := 10
    p := &n
    *p = 99
    fmt.Println(n) // 99
}

Ponteiros nulos

O valor zero de um ponteiro é nil. Desreferenciar um ponteiro nulo causa um pânico:

package main
import "fmt"

func main() {
    var p *int
    fmt.Println(p)        // <nil>
    fmt.Println(p == nil) // true
    // *p = 1 — PANIC
}

Tipos de ponteiro

Cada tipo de ponteiro é específico ao que ele aponta:

package main
import "fmt"

func main() {
    i := 1
    s := "hello"
    pi := &i   // *int
    ps := &s   // *string
    fmt.Printf("%T %T\n", pi, ps) // *int *string
}

Verificação de nulo antes do uso

Sempre verifique se é nulo antes de desreferenciar um ponteiro recebido de fora do seu código:

package main
import "fmt"

func printInt(p *int) {
    if p == nil {
        fmt.Println("nil pointer")
        return
    }
    fmt.Println(*p)
}

func main() {
    v := 7
    printInt(&v)
    printInt(nil)
}

Ponteiros para estruturas

Acessar campos de uma estrutura por meio de um ponteiro usa a mesma notação de ponto — Go faz a desreferenciação automaticamente:

package main
import "fmt"

type Point struct{ X, Y int }

func main() {
    p := &Point{1, 2}
    p.X = 10         // same as (*p).X = 10
    fmt.Println(*p)  // {10 2}
}

Comparação de ponteiros

Dois ponteiros são iguais quando apontam para a mesma variável (mesmo endereço) ou quando ambos são nulos:

package main
import "fmt"

func main() {
    a := 1
    p1 := &a
    p2 := &a
    p3 := new(int)
    *p3 = 1
    fmt.Println(p1 == p2) // true  — same address
    fmt.Println(p1 == p3) // false — different address
}

Pilha versus memória dinâmica

O compilador do Go decide se uma variável ficará na pilha ou na memória dinâmica por meio da análise de escape. Quando você obtém o endereço de uma variável local e o retorna, Go a move automaticamente para a memória dinâmica — você não precisa gerenciar isso manualmente.

Quando NOT usar ponteiros

Nem tudo precisa de um ponteiro:

Tipos de valor pequenos (int, bool, estruturas pequenas) são mais baratos de copiar do que de desreferenciar
Dados imutáveis compartilhados entre gorrotinas são seguros como valor
Use ponteiros principalmente para modificação ou estruturas grandes

Verificação rápida

O que o operador & retorna?

Recapitulação: ponteiros

Principais aprendizados:

&v obtém o endereço; *p faz a desreferenciação
O valor zero é nulo — sempre verifique antes de desreferenciar
Go faz automaticamente a desreferenciação ao acessar campos de estruturas por ponteiro
A análise de escape gerencia automaticamente a pilha e a memória dinâmica

Exercício prático

Escreva uma função swap(a, b *int) que troque os valores de dois inteiros usando ponteiros. Chame-a de main e imprima os valores antes e depois.

Perguntas Frequentes

A aula “O que são ponteiros?” é grátis?

Sim — o texto completo de “O que são ponteiros?” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “O que são ponteiros?”?

Operador de endereço, desreferenciamento e ponteiros nil Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “O que são ponteiros?”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy