Fundamentos de Ponteiros em Go

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy. Lição 19 de 107.

Um ponteiro é uma variável que armazena o endereço de memória de outra variável. Em vez de armazenar um valor diretamente, ele armazena o local onde esse valor reside na memória. Os ponteiros são fundamentais para Go e essenciais para a manipulação eficiente de dados.

Para criar um ponteiro, use o operador & para obter o endereço de uma variável e o operador * para declarar um tipo de ponteiro ou acessar o valor nesse endereço.

x := 42
p := &x  // p contém o endereço de memória de x

fmt.Println(p)  // 0xc000018030 (endereço de memória)
fmt.Println(*p) // 42 (valor nesse endereço)

O operador & significa "endereço de" e retorna um ponteiro. O operador *, quando usado em um ponteiro, significa "valor em" e é chamado de desreferenciação. Você também pode modificar o valor original por meio do ponteiro.

x := 10
p := &x

*p = 25         // altera o valor através do ponteiro
fmt.Println(x)  // 25 (variável original alterada)

O tipo pointer é escrito como *T, em que T é o tipo apontado. Um pointer para um int tem o tipo *int.

var p *int      // declara um ponteiro para int
x := 100
p = &x          // p agora aponta para x

O valor zero de um ponteiro é nil, o que significa que ele não aponta para nada. Tentar desreferenciar um ponteiro nil causa um pânico em tempo de execução; portanto, sempre garanta que os ponteiros sejam inicializados antes do uso.

Desafio

Fácil

Vamos criar um simples trocador de valores que demonstra o poder dos ponteiros para modificar variáveis por meio de seus endereços de memória.

Você organizará seu código em dois arquivos:

swap.go: Crie uma função chamada SwapValues que recebe dois ponteiros *int como parâmetros. Essa função deve trocar os valores para os quais esses ponteiros apontam; depois de chamá-la, cada variável deverá conter o valor original da outra. A função não retorna nada; ela modifica os valores diretamente por meio dos ponteiros.
main.go: Leia dois números inteiros da entrada, armazene-os em variáveis e use sua função SwapValues para trocar seus valores. Imprima ambos os valores antes e depois da troca para mostrar a alteração.

As seguintes entradas serão fornecidas:

Linha 1: Primeiro número inteiro
Linha 2: Segundo número inteiro

Formato da saída:

Before: a=[first] b=[second]
After: a=[first] b=[second]

Por exemplo, dados 10 e 25, sua saída deverá ser:

Before: a=10 b=25
After: a=25 b=10

Lembre-se de usar o operador & ao passar suas variáveis para a função e o operador * dentro da função para acessar e modificar os valores reais.

Experimente você mesmo

package main

import "fmt"

func main() {
	// Lê dois inteiros da entrada
	var a, b int
	fmt.Scanln(&a)
	fmt.Scanln(&b)

	// Imprime os valores antes da troca
	fmt.Printf("Before: a=%d b=%d\n", a, b)

	// TODO: Chame a função SwapValues com ponteiros para a e b
	// Lembre-se de usar o operador & para passar os endereços

	// Imprime os valores depois da troca
	fmt.Printf("After: a=%d b=%d\n", a, b)
}