Ponteiros para Structs

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy — lição 20 de 107.

Ao trabalhar com structs, você frequentemente usará ponteiros para evitar a cópia de grandes estruturas de dados e para modificar a struct original. Um ponteiro para uma struct armazena o endereço de memória daquela instância da struct.

Você pode criar um ponteiro de struct usando o operador & em uma struct existente, ou usando o operador de endereço diretamente com um literal de struct.

type Person struct {
    Name string
    Age  int
}

p := Person{Name: "Alice", Age: 30}
ptr := &p  // ponteiro para struct existente

// Ou crie diretamente
ptr2 := &Person{Name: "Bob", Age: 25}

O Go fornece um atalho conveniente ao acessar campos de uma struct por meio de um ponteiro. Em vez de escrever (*ptr).Name, você pode simplesmente escrever ptr.Name. O Go desreferencia automaticamente o ponteiro para você.

ptr := &Person{Name: "Alice", Age: 30}

// Ambos funcionam de forma idêntica
fmt.Println((*ptr).Name)  // desreferência explícita
fmt.Println(ptr.Name)     // desreferência automática

Essa desreferenciação automática também se aplica ao modificar campos. Alterações por meio do ponteiro afetam a struct original.

p := Person{Name: "Alice", Age: 30}
ptr := &p

ptr.Age = 31           // modifica o original
fmt.Println(p.Age)     // 31

Ponteiros para structs são essenciais nos padrões de POO do Go. Eles permitem que métodos modifiquem o estado do receptor, possibilitam a passagem eficiente de structs grandes para funções e formam a base para a construção de estruturas de dados encadeadas, como árvores e listas.

Desafio

Fácil

Vamos construir um sistema de conta bancária que demonstra como ponteiros de struct permitem que você modifique os dados originais de forma eficiente. Você criará uma conta que pode ser atualizada através de operações com ponteiros.

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

account.go: Defina uma struct BankAccount com os campos Owner (string), Balance (float64) e AccountNumber (string). Crie uma função chamada NewAccount que recebe um nome de proprietário e um número de conta como parâmetros e retorna um ponteiro para uma nova BankAccount com um saldo inicial de 0. Além disso, crie uma função Deposit que recebe um ponteiro *BankAccount e um valor, e então adiciona esse valor ao saldo da conta através do ponteiro.
main.go: Leia as informações da conta a partir da entrada, crie uma conta usando sua função construtora (que retorna um ponteiro), realize um depósito usando o ponteiro e exiba os detalhes da conta para confirmar que o saldo foi modificado.

As seguintes entradas serão fornecidas:

Linha 1: Nome do proprietário
Linha 2: Número da conta
Linha 3: Valor do depósito (float)

Formato de saída:

Account: [AccountNumber]
Owner: [Owner]
Balance: [Balance]

Por exemplo, dados John Smith, ACC-12345 e 500.50, sua saída deve ser:

Account: ACC-12345
Owner: John Smith
Balance: 500.50

Lembre-se de que sua função NewAccount deve retornar *BankAccount usando o operador &, e sua função Deposit pode modificar o saldo diretamente através do ponteiro usando a desreferenciação automática do Go (por exemplo, account.Balance em vez de (*account).Balance).

Folha de consulta

Um ponteiro para uma struct armazena o endereço de memória de uma instância de struct. Crie ponteiros de struct usando o operador &:

type Person struct {
    Name string
    Age  int
}

p := Person{Name: "Alice", Age: 30}
ptr := &p  // ponteiro para struct existente

// Ou crie diretamente
ptr2 := &Person{Name: "Bob", Age: 25}

O Go fornece desreferenciação automática ao acessar campos de struct através de um ponteiro. Em vez de (*ptr).Name, você pode escrever ptr.Name:

ptr := &Person{Name: "Alice", Age: 30}

// Ambos funcionam de forma idêntica
fmt.Println((*ptr).Name)  // desreferenciação explícita
fmt.Println(ptr.Name)     // desreferenciação automática

Alterações através de um ponteiro afetam a struct original:

p := Person{Name: "Alice", Age: 30}
ptr := &p

ptr.Age = 31           // modifica o original
fmt.Println(p.Age)     // 31

Ponteiros de struct permitem que métodos modifiquem o estado do receptor, permitem a passagem eficiente de structs grandes para funções e formam a base para estruturas de dados encadeadas.

Experimente você mesmo

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	
	// Ler o nome do titular
	ownerName, _ := reader.ReadString('\n')
	ownerName = strings.TrimSpace(ownerName)
	
	// Ler o número da conta
	accountNumber, _ := reader.ReadString('\n')
	accountNumber = strings.TrimSpace(accountNumber)
	
	// Ler o valor do depósito
	amountStr, _ := reader.ReadString('\n')
	amountStr = strings.TrimSpace(amountStr)
	amount, _ := strconv.ParseFloat(amountStr, 64)
	
	// TODO: Criar uma nova conta usando a função NewAccount (retorna um ponteiro)
	
	// TODO: Realizar um depósito usando a função Deposit com o ponteiro da conta
	
	// TODO: Imprimir os detalhes da conta no formato exigido:
	// Conta: [AccountNumber]
	// Titular: [Owner]
	// Saldo: [Balance]
}