0Pricing
Go Academy · Aula

new() e quando usar ponteiros

Alocação com new e padrões comuns de ponteiros

new() e quando usar ponteiros é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 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.

O Elemento Integrado new()

new(T) aloca um T zerado e retorna um *T. Para estruturas, ele equivale a &T{}:

package main
import "fmt"

func main() {
    p := new(int)
    fmt.Println(*p)     // 0
    *p = 42
    fmt.Println(*p)     // 42

    type Point struct{ X, Y int }
    pt := new(Point)
    fmt.Println(*pt)    // {0 0}
}

new versus &T{}

Para estruturas, &T{} é mais idiomático e permite inicializar campos. new é raramente usado no Go moderno:

package main
import "fmt"

type Config struct{ Port int; Host string }

func main() {
    a := new(Config)          // zeroed
    b := &Config{Port: 8080}  // initialized
    fmt.Println(a, b)
}

Quando Retornar um Ponteiro

Retorne um ponteiro a partir de um construtor quando:

  • A estrutura tiver estado e os chamadores precisarem compartilhar a mesma instância
  • A estrutura tiver métodos com receptores de ponteiro (necessários para satisfazer interfaces)
  • A estrutura for grande e as cópias forem dispendiosas

Quando Retornar um Valor

Retorne um valor quando:

  • O tipo for pequeno (com poucos campos)
  • For uma configuração imutável
  • Você quiser deixar claro que os chamadores receberão cópias independentes

Exemplo: time.Time é retornado por valor apesar de ter muitos métodos.

Ponteiros em Fatias e Mapas

Armazenar ponteiros em coleções permite compartilhar mutações:

package main
import "fmt"

type User struct{ Name string; Score int }

func main() {
    users := []*User{{"Alice", 0}, {"Bob", 0}}
    users[0].Score = 100
    fmt.Println(users[0]) // &{Alice 100}
}

Ponteiro para Primitivo como Opção

Um campo *int ou *string pode ser nil para significar "não definido", o que é útil para JSON com omitempty ou colunas opcionais de bancos de dados:

package main
import "fmt"

type Profile struct {
    Name string
    Age  *int // nil means not provided
}

func main() {
    p := Profile{Name: "Alice"}
    fmt.Println(p.Age == nil) // true
    age := 30
    p.Age = &age
    fmt.Println(*p.Age) // 30
}

Evitando a Proliferação de Ponteiros

O uso excessivo de ponteiros aumenta a pressão sobre o coletor de lixo e reduz a localidade do cache. Faça uma avaliação de desempenho antes de trocar tipos de valor por ponteiros apenas por motivos de desempenho.

make versus new

make inicializa fatias, mapas e canais (eles precisam de uma configuração interna). new aloca qualquer tipo zerado e retorna um ponteiro. Eles têm finalidades diferentes:

package main
import "fmt"

func main() {
    s := make([]int, 5)           // usable slice
    m := make(map[string]int)     // usable map
    p := new(int)                 // *int pointing to 0
    fmt.Println(s, m, *p)
}

Padrão de Ponteiro Imutável

Retorne *T, mas documente-o como imutável; os consumidores não deverão modificá-lo. Isso é comum em objetos de configuração compartilhados entre goroutines.

Resumo da Segurança dos Ponteiros

Regras para usar ponteiros com segurança:

  • Verifique sempre se o valor é nil antes de desreferenciá-lo
  • Não armazene ponteiros para variáveis da pilha por mais tempo que o tempo de vida da variável (a análise de escape de Go cuida disso)
  • Nunca converta para unsafe.Pointer, a menos que seja absolutamente necessário
  • Deixe o compilador gerenciar a pilha e a memória dinâmica

Verificação Rápida

O que new(int) retorna?

Recapitulação: new e Ponteiros

Principais conclusões:

  • new(T) retorna *T zerado — é raramente usado; prefira &T{}
  • Retorne valores quando forem pequenos ou imutáveis; ponteiros quando tiverem estado ou forem grandes
  • Campos *T permitem a semântica de nil como ausente
  • Não use ponteiros em excesso — o coletor de lixo tem um custo

Proposta de Prática

Crie uma estrutura Settings com um campo *int para MaxConnections. Escreva uma função que aceite *Settings e defina um valor padrão somente quando o campo for nil.

Perguntas Frequentes

A aula “new() e quando usar ponteiros” é grátis?

Sim — o texto completo de “new() e quando usar 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 “new() e quando usar ponteiros”?

Alocação com new e padrões comuns de ponteiros 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 4 de 4.

Quanto tempo leva a aula “new() e quando usar 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

  1. O que são ponteiros?
  2. Ponteiros e funções
  3. Receptores de ponteiro em métodos
  4. new() e quando usar ponteiros
← Voltar para Go Academy