Recebedores de Ponteiro

Parte da seção Lógica & Fluxo do Journey de GO da Coddy. Lição 8 de 68.

Enquanto receptores de valor trabalham com cópias de structs, receptores de ponteiro trabalham diretamente com a instância original da struct. Quando você define um método com um receptor de ponteiro, o método pode modificar os dados originais porque recebe um ponteiro para a struct, em vez de uma cópia.

Para criar um receptor de ponteiro, você adiciona um asterisco * antes do nome do tipo na declaração do receptor:

type Person struct {
    Name string
    Age  int
}

func (p *Person) haveBirthday() {
    p.Age++  // Isso modifica a struct original
}

Neste exemplo, (p *Person) é um receptor de ponteiro. Quando você chama o método haveBirthday em uma instância de Person, o método recebe um ponteiro para a struct original. Quaisquer alterações feitas nos campos da struct por meio desse ponteiro modificarão permanentemente os dados originais.

Receptores de ponteiro são essenciais quando seus métodos precisam atualizar os campos da struct, tornando-os perfeitos para operações que alteram o estado dos seus dados.

Desafio

Fácil

Neste desafio, você praticará a criação de métodos com receptores de ponteiro construindo um sistema simples de conta bancária. Você criará uma struct Account e definirá métodos que podem modificar o saldo da conta usando receptores de ponteiro.

Você receberá três entradas:

Uma string representando o nome do titular da conta (por exemplo, "John Smith")
Uma string representando o saldo inicial da conta (por exemplo, "1000.50")
Uma string representando o valor da transação (por exemplo, "250.75")

Sua tarefa é:

Definir uma struct Account com dois campos: Name (string) e Balance (float64)
Criar um método chamado deposit com um receptor de ponteiro que adiciona o valor informado ao saldo da conta
Criar um método chamado withdraw com um receptor de ponteiro que subtrai o valor informado do saldo da conta
Criar um método chamado displayBalance com um receptor por valor que exibe as informações da conta no formato: "Account: [name], Balance: $[balance]"
Analisar as entradas para criar uma instância de Account
Chamar displayBalance para mostrar o saldo inicial
Chamar deposit com o valor da transação
Chamar displayBalance para mostrar o saldo após o depósito
Chamar withdraw com o valor da transação
Chamar displayBalance para mostrar o saldo final

O saldo deve ser exibido com precisão de duas casas decimais. Este desafio demonstra como os receptores de ponteiro permitem que os métodos modifiquem os dados da struct original, ao contrário dos receptores por valor, que trabalham com cópias.

Experimente você mesmo

package main

import (
	"fmt"
	"strconv"
)

// TODO: Defina a struct Account aqui

// TODO: Defina o método deposit com um pointer receiver aqui

// TODO: Defina o método withdraw com um pointer receiver aqui

// TODO: Defina o método displayBalance com um value receiver aqui

func main() {
	// Ler a entrada
	var name string
	var initialBalanceStr string
	var transactionAmountStr string
	
	fmt.Scanln(&name)
	fmt.Scanln(&initialBalanceStr)
	fmt.Scanln(&transactionAmountStr)
	
	// Converter as entradas de string para os tipos apropriados
	initialBalance, _ := strconv.ParseFloat(initialBalanceStr, 64)
	transactionAmount, _ := strconv.ParseFloat(transactionAmountStr, 64)
	
	// TODO: Criar uma instância de Account
	
	// TODO: Exibir o saldo inicial, realizar o depósito, exibir o saldo, realizar o saque, exibir o saldo final
}