Go Academy · Aula

Ponteiros e funções

Passagem por valor versus passagem por ponteiro

Ponteiros e funções é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 2 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.

Passagem por valor

Go passa todos os argumentos de funções por valor — uma cópia é criada. Alterações dentro da função não afetam o original:

package main
import "fmt"

func increment(n int) { n++ }

func main() {
    x := 5
    increment(x)
    fmt.Println(x) // 5 — unchanged
}

Passagem por Ponteiro

Passe um ponteiro para permitir que a função altere o original:

package main
import "fmt"

func increment(n *int) { *n++ }

func main() {
    x := 5
    increment(&x)
    fmt.Println(x) // 6
}

Retorno de Ponteiros

As funções podem retornar ponteiros para valores alocados na memória dinâmica. A análise de escape de Go garante a segurança:

package main
import "fmt"

func newInt(v int) *int { return &v }

func main() {
    p := newInt(42)
    fmt.Println(*p) // 42
}

Eficiência com Estruturas Grandes

Passar uma estrutura grande por ponteiro evita uma cópia dispendiosa:

package main
import "fmt"

type BigData struct{ Data [1024]int }

func process(d *BigData) { d.Data[0] = 99 }

func main() {
    bd := BigData{}
    process(&bd)
    fmt.Println(bd.Data[0]) // 99
}

Ponteiro para Interface

Raramente necessário — as interfaces já armazenam internamente um ponteiro. Passar *interface{} quase sempre está errado:

package main
import "fmt"

type Stringer interface{ String() string }

func print(s Stringer) { fmt.Println(s.String()) }

// Pass interface directly, NOT *Stringer
type Name string
func (n Name) String() string { return string(n) }

func main() {
    print(Name("Alice"))
}

Parâmetros Opcionais com Ponteiros

Use parâmetros ponteiro para distinguir entre "não fornecido" e valor zero:

package main
import "fmt"

func greet(name *string) {
    if name == nil {
        fmt.Println("Hello, stranger")
        return
    }
    fmt.Println("Hello,", *name)
}

func main() {
    s := "Alice"
    greet(&s)
    greet(nil)
}

Mutação por Meio de Fatias

As fatias já contêm um ponteiro interno, portanto geralmente não é necessário usar *[]T. No entanto, quando append realoca a memória, é necessário um ponteiro para a própria fatia:

package main
import "fmt"

func addItem(s *[]int, v int) { *s = append(*s, v) }

func main() {
    nums := []int{1, 2, 3}
    addItem(&nums, 4)
    fmt.Println(nums) // [1 2 3 4]
}

Alias de Ponteiros

Vários ponteiros para a mesma variável criam aliases — uma alteração feita por meio de um ponteiro fica visível por meio de todos os outros:

package main
import "fmt"

func main() {
    x := 10
    a, b := &x, &x
    *a = 99
    fmt.Println(*b) // 99 — same memory
}

Evitando o Uso Excessivo de Ponteiros

Use ponteiros somente quando necessário:

Mutação dentro de uma função
Estruturas grandes (>= ~64 bytes)
Nil para representar "ausente"

O uso excessivo de ponteiros aumenta a pressão sobre o coletor de lixo e reduz a clareza do código.

Padrão de Ponteiro de Função

Armazene ponteiros de funções em um mapa para criar tabelas de despacho:

package main
import "fmt"

func add(a, b int) int { return a + b }
func sub(a, b int) int { return a - b }

func main() {
    ops := map[string]func(int,int)int{
        "+": add, "-": sub,
    }
    fmt.Println(ops["+"](10, 3)) // 13
    fmt.Println(ops["-"](10, 3)) // 7
}

Verificação Rápida

Como permitir que uma função modifique uma variável inteira definida por quem a chama?

Recapitulação

Principais conclusões:

Go usa passagem por valor — use ponteiros para fazer mutações
Retorne ponteiros a partir de construtores para alocação na memória dinâmica
As fatias carregam um ponteiro interno, mas append pode exigir *[]T
Evite o uso excessivo de ponteiros — prefira valores para tipos pequenos

Proposta de Prática

Escreva uma função normalize que receba *[]string e converta todas as strings para minúsculas no próprio local usando strings.ToLower.

Perguntas Frequentes

A aula “Ponteiros e funções” é grátis?

Sim — o texto completo de “Ponteiros e funções” é 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 “Ponteiros e funções”?

Passagem por valor versus passagem por ponteiro 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 2 de 4.

Quanto tempo leva a aula “Ponteiros e funções”?

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