Como muitas outras linguagens, o Go tem ponteiros.
Se você está começando com ponteiros, eles podem parecer um pouco misteriosos, mas depois que você se acostuma, são bem simples.
Eles são uma parte crucial do Go, então reserve um tempo para entendê-los de verdade.
Antes de entrar nos detalhes, vale a pena entender para que servem os ponteiros.
Ponteiros são uma forma de compartilhar memória com outras partes do nosso programa, o que é útil por dois motivos principais:
- Quando temos grandes quantidades de dados, fazer cópias para passá-las entre funções é muito ineficiente.
Em vez disso, ao passar o endereço de memória onde os dados estão armazenados, podemos reduzir bastante o consumo de recursos dos nossos programas.
- Ao passar ponteiros entre funções, podemos acessar e modificar diretamente a única cópia dos dados. Isso significa que qualquer alteração feita por uma função fica imediatamente visível para as outras partes do programa quando a função termina.
Variáveis e memória
Digamos que temos uma variável inteira comum a:
var a int
Quando declaramos uma variável, o Go precisa encontrar um lugar na memória para guardar o valor dela.
Isso é bastante abstraído para nós. Quando precisamos buscar o valor guardado naquele pedaço de memória, basta nos referirmos a ele pelo nome da variável.
Por exemplo, quando escrevemos a + 2, estamos na prática buscando o valor guardado na memória associada à variável a e somando 2 a ele.
Da mesma forma, quando precisamos mudar o valor no pedaço de memória de a, podemos usar o nome da variável para fazer uma atribuição:
a = 3
O pedaço de memória associado a a agora vai guardar o valor 3.
Ponteiros
As variáveis nos permitem nos referir a valores na memória, mas às vezes é útil saber o endereço de memória para o qual a variável aponta. Os ponteiros guardam os endereços de memória desses valores.
Você declara uma variável com um tipo de ponteiro colocando um asterisco antes do tipo base:
var p *int // 'p' contains the memory address of an integer
Aqui declaramos uma variável p do tipo "ponteiro para int" (*int).
Isso significa que p vai guardar o endereço de memória de um inteiro.
O valor zero dos ponteiros é nil, porque um ponteiro nil não guarda nenhum endereço de memória.
Obtendo um ponteiro para uma variável
Para encontrar o endereço de memória do valor de uma variável, podemos usar o operador &.
Por exemplo, se quisermos encontrar e guardar o endereço de memória da variável a no ponteiro p, podemos fazer o seguinte:
var a int
a = 2
var p *int
p = &a // the variable 'p' contains the memory address of 'a'
Acessando o valor por meio de um ponteiro (desreferenciando)
Quando temos um ponteiro, pode ser que queiramos saber o valor guardado no endereço de memória que o ponteiro representa.
Podemos fazer isso com o operador *:
var a int
a = 2
var p *int
p = &a // the variable 'p' contains the memory address of 'a'
var b int
b = *p // b == 2
A operação *p busca o valor guardado no endereço de memória armazenado em p.
Essa operação costuma ser chamada de "desreferenciamento".
Também podemos usar o operador de desreferência para atribuir um novo valor ao endereço de memória referenciado pelo ponteiro:
var a int // declare int variable 'a'
a = 2 // assign 'a' the value of 2
var pa *int
pa = &a // 'pa' now contains to the memory address of 'a'
*pa = *pa + 2 // increment by 2 the value at memory address 'pa'
fmt.Println(a) // Output: 4
// 'a' will have the new value that was changed via the pointer!
Atribuir a *pa vai mudar o valor guardado no endereço de memória que pa contém.
Como pa guarda o endereço de memória de a, ao atribuir a *pa estamos na prática mudando o valor de a!
Um aviso, porém: sempre verifique se um ponteiro não é nil antes de desreferenciá-lo.
Desreferenciar um ponteiro nil vai fazer o programa quebrar em tempo de execução!
var p *int // p is nil initially
fmt.Println(*p)
// panic: runtime error: invalid memory address or nil pointer dereference
Ponteiros para structs
Até agora só vimos ponteiros para valores primitivos.
Também podemos criar ponteiros para structs:
type Person struct {
Name string
Age int
}
var peter Person
peter = Person{Name: "Peter", Age: 22}
var p *Person
p = &peter
Também poderíamos ter criado uma Person nova e guardado imediatamente um ponteiro para ela:
var p *Person
p = &Person{Name: "Peter", Age: 22}
Quando temos um ponteiro para uma struct, não precisamos desreferenciar o ponteiro antes de acessar um dos campos:
var p *Person
p = &Person{Name: "Peter", Age: 22}
fmt.Println(p.Name) // Output: "Peter"
// Go automatically dereferences 'p' to allow
// access to the 'Name' field
Slices e maps já são ponteiros
Slices e maps são tipos especiais porque já têm ponteiros na sua implementação.
Isso significa que, na maioria das vezes, não precisamos criar ponteiros para esses tipos para compartilhar o endereço de memória dos seus valores.
Imagine que temos uma função que incrementa o valor de uma chave em um map:
func incrementPeterAge(m map[string]int) {
m["Peter"] += 1
}
Se criarmos um map e chamarmos essa função, as mudanças que a função fez no map continuam valendo depois que a função termina.
É um comportamento parecido com o que teríamos se estivéssemos usando um ponteiro, mas repare que neste exemplo não usamos nenhuma referência, nenhuma desreferência, nem nenhuma sintaxe de ponteiro:
ages := map[string]int{
"Peter": 21
}
incrementPeterAge(ages)
fmt.Println(ages)
// Output: map[Peter:22]
// The changes the function 'incrementPeterAge' made to the map are visible after the function ends!
O mesmo vale quando alteramos um item que já existe em um slice.
No entanto, ações que retornam um novo slice, como append, são um caso especial e podem não modificar o slice fora da função.
Isso acontece por causa de como os slices funcionam internamente, mas não vamos cobrir isso em detalhe neste exercício, pois é um tópico mais avançado.
Se você estiver realmente curioso, pode ler mais sobre isso em Go Blog: Mechanics of 'append'
Exercício de aprendizagem
