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 copiar grandes estruturas de dados e para modificar a struct original. Um ponteiro para uma struct armazena o endereço de memória dessa instância de struct.

Você pode criar um ponteiro para uma struct usando o operador & em uma struct existente ou usando diretamente o operador de endereço 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}

Go oferece 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. 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. As alterações feitas 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 criar um sistema de conta bancária que demonstra como ponteiros para structs permitem modificar os dados originais de forma eficiente. Você criará uma conta que pode ser atualizada por meio 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 o nome do titular e o número da conta como parâmetros e retorna um ponteiro para uma nova BankAccount com saldo inicial de 0. Crie também uma função Deposit que recebe um ponteiro *BankAccount e um valor, e então adiciona esse valor ao saldo da conta por meio 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), faça 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 titular
Linha 2: Número da conta
Linha 3: Valor do depósito (float)

Formato da saída:

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

Por exemplo, dados John Smith, ACC-12345 e 500.50, sua saída deverá 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 por meio do ponteiro usando a desreferenciação automática do Go (por exemplo, account.Balance em vez de (*account).Balance).

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]
}