# Valores, tipos e memória

Entenda como Go descreve valores, copia structs e usa ponteiros para acessar um valor existente.

**Trilha:** [Go por Dentro — Entenda a linguagem além da sintaxe](../../go-por-dentro.md) · **Aula:** 2 · **Duração:** 50 minutos

## Etapas

## Etapa 1: Um valor tem um tipo

Go é uma linguagem estaticamente tipada: cada variável tem um tipo conhecido pelo compilador. O tipo limita as operações válidas e ajuda a detectar incompatibilidades antes de executar o programa.

Em `var retries int`, `int` é o tipo e `retries` recebe seu valor zero, que é `0`. `endpoint` recebe a string vazia e `active`, por ser `bool`, começa como `false`. A forma curta `:=` declara uma variável local e deixa o compilador inferir o tipo a partir do valor.

**examples/declarations/main.go**

```go
package main

import "fmt"

func main() {
	var retries int
	var endpoint string
	active := false

	retries++
	fmt.Printf("retries=%d endpoint=%q active=%t\n", retries, endpoint, active)
}
```

`:=` só pode ser usado dentro de funções. Para uma variável no escopo do pacote, use uma declaração com `var`. Em `retries++`, o operador incrementa o valor inteiro em uma unidade.

A especificação descreve [declarações e tipos em Go](/reference/go/methods-and-types).

## Etapa 2: Uma struct é copiada ao ser passada

Uma `struct` reúne campos relacionados sob um tipo definido pelo programa. Neste exemplo, `Account` contém um saldo inteiro.

Quando `deposit` recebe um `Account` como parâmetro, recebe uma cópia do valor. A função altera essa cópia; a variável `account` de `main` continua com o saldo original. Isso é o comportamento esperado quando se passa um valor comum em Go.

**examples/value-copy/main.go**

```go
package main

import "fmt"

type Account struct {
	Balance int
}

func deposit(account Account, amount int) {
	account.Balance += amount
}

func main() {
	account := Account{Balance: 100}
	deposit(account, 25)
	fmt.Println(account.Balance) // 100
}
```

> **Valor inicial do campo:** `Account{Balance: 100}` é um literal composto: ele cria um valor do tipo `Account` e define o campo pelo nome. Se o campo for omitido, `Balance` começa em zero.

## Etapa 3: Usando um ponteiro para alterar o valor original

Um ponteiro guarda o endereço de um valor. O tipo `*Account` significa ponteiro para `Account`. O operador `&account` obtém o endereço da variável `account` existente; ele não cria uma cópia do saldo.

A função abaixo recebe esse ponteiro e, por isso, altera o mesmo valor que `main` consulta depois. Go permite escrever `account.Balance` em vez de `(*account).Balance`: ao selecionar um campo, o compilador faz essa indireção para você.

A localização física do valor não é definida por `&`. O compilador analisa se o valor precisa continuar acessível depois da função e decide sua alocação. Veja [ponteiros e endereços](/reference/go/pointers) e [literais compostos](/reference/go/composite-literals).

**examples/pointer-update/main.go**

```go
package main

import "fmt"

type Account struct {
	Balance int
}

func deposit(account *Account, amount int) {
	account.Balance += amount
}

func main() {
	account := Account{Balance: 100}
	deposit(&account, 25)
	fmt.Println(account.Balance) // 125
}
```

### Quiz (100% para aprovação recomendada)

1. O que `&account` representa no exemplo?
   - a) O endereço da variável account existente
   - b) Uma cópia completa de todos os campos
   - c) Uma instrução que força a alocação no heap
   - **Resposta:** a
   - **Explicação:** `&` obtém o endereço do valor. Ele não copia a struct e não determina sozinho se o compilador usará stack ou heap.

## Etapa 4: Valores zero e ponteiros nil

Toda variável declarada sem valor inicial recebe o valor zero do seu tipo. Para `int`, é `0`; para `string`, é `""`; para `bool`, é `false`; e para ponteiros, slices, maps, funções, canais e interfaces, é `nil`.

Um ponteiro `nil` não aponta para uma `Account`. Tentar acessar `account.Balance` nesse estado provoca panic. Se um ponteiro puder estar ausente, verifique `nil` antes de usá-lo.

**examples/nil-pointer/main.go**

```go
package main

import "fmt"

type Account struct {
	Balance int
}

func main() {
	var account *Account
	if account == nil {
		fmt.Println("a conta não foi informada")
		return
	}

	fmt.Println(account.Balance)
}
```

Os exemplos desta etapa ficam em diretórios separados, como `examples/value-copy/main.go`. A ferramenta Go compila juntos os arquivos `.go` de um diretório, formando um pacote. Por isso, cada exemplo tem sua própria pasta e pode declarar `main`, `Account` e `deposit` sem colidir com os outros. Consulte o [guia oficial sobre organização de módulos Go](https://go.dev/doc/modules/layout).

Para executar um exemplo a partir da raiz do módulo, use, por exemplo, `go run ./examples/value-copy`.

O coletor de lixo libera objetos que não estão mais alcançáveis pelo programa. Não é preciso manter um ponteiro só para impedir que o valor seja coletado: o compilador e o runtime acompanham as referências usadas pelo programa.

Na raiz do módulo, execute `go build -gcflags="-m" ./...` para compilar os pacotes e observar decisões de escape do compilador. Essa saída é um diagnóstico e pode variar com a versão do Go e com mudanças no código.

## Etapa 5: Desafio: atualize o saldo

### Desafio: Escolha como representar uma alteração

Declare uma struct `Account` com o campo `Balance`. Escreva uma função `deposit` que receba a conta e um valor. Faça o saldo original mudar depois da chamada e imprima o resultado. Explique por que a assinatura recebe um ponteiro.

<details>
<summary>Solução possível</summary>

Salve o código completo em `main.go` e execute `go run main.go`:

```go
package main

import "fmt"

type Account struct {
	Balance int
}

func deposit(account *Account, amount int) {
	account.Balance += amount
}

func main() {
	account := Account{Balance: 100}
	deposit(&account, 25)
	fmt.Println(account.Balance)
}
```

A saída é `125`. `*Account` indica que `deposit` recebe um ponteiro para uma conta. `&account` passa o endereço da variável original; por isso, a alteração feita pela função aparece quando `main` lê o saldo. `fmt.Println` escreve o resultado no terminal.

</details>

### Quiz (70% para aprovação recomendada)

1. Qual é o valor inicial de `var retries int`?
   - a) 0, o valor zero do tipo int
   - b) nil, para qualquer variável sem inicialização
   - c) Um valor aleatório escolhido pelo runtime
   - **Resposta:** a
   - **Explicação:** O valor zero depende do tipo. `int` começa em 0; `nil` é usado por ponteiros e alguns outros tipos, e variáveis Go não começam com valores aleatórios.

2. O que acontece quando uma `Account` é passada por valor para `deposit`?
   - a) A função recebe uma cópia da struct
   - b) A função recebe sempre um ponteiro para a original
   - c) O compilador converte a struct em uma interface
   - **Resposta:** a
   - **Explicação:** Parâmetros são passados por valor. Para alterar a struct original, a função pode receber um `*Account`; Go não troca automaticamente o parâmetro por um ponteiro.

3. O operador `&` garante que o valor será alocado no heap?
   - a) Não. O compilador decide a alocação conforme o tempo de vida necessário
   - b) Sim. Todo endereço obtido com `&` fica no heap
   - c) Sim, mas apenas quando o valor é uma struct
   - **Resposta:** a
   - **Explicação:** `&` produz um ponteiro para o valor. A análise de escape do compilador decide onde ele deve viver; o operador não força heap por si só.

