Golang: Ponteiros (Parte - 10)

Agora sim as coisas começam a ficar interessantes. Vamos falar sobre Ponteiros.

O conceito de ponteiros é o mesmo em outras linguagens.

Um ponteiro é uma variável que armazena o endereço de memória de outra variável. Por exemplo:

Você tem uma variável x que armazena o valor 10. O ponteiro p armazena o endereço de memória onde x está armazenado. Digamos que o endereço de x seja 0x1234. Então, p armazena 0x1234.

Até aqui, tudo certo, nada de novo.

Veja um exemplo simples de como usar ponteiros em Go:

package main
import "fmt"

// Exemplo de uso de ponteiros
func main() {
    x := 10
    fmt.Println("Valor original de x:", x) // 10

    // Chamando a função que altera o valor de x
    alteraValor(&x)
    fmt.Println("Valor alterado de x:", x) // 20
}

// Função que altera o valor de x usando ponteiros
func alteraValor(p *int) {
    *p = 20
}

Explicando o código:

• A variável x é inicializada com o valor 10.
• A função alteraValor recebe um ponteiro para um inteiro (*int).

Esse detalhe é importante: você pode criar uma função que recebe um ponteiro como argumento. Isso significa que é possível alterar o valor da variável original dentro da função.

No exemplo acima, a função alteraValor recebe o endereço de x (ou seja, o ponteiro para x).

• Dentro da função, o valor apontado pelo ponteiro p é alterado para 20.

No primeiro fmt.Println, o valor de x é 10. No segundo fmt.Println, o valor de x é 20, pois foi alterado dentro da função.

Como alterei o valor no endereço de memória, independentemente de onde x estiver no sistema, seu valor será alterado.

Ponteiros com Structs

Agora, vamos combinar os conceitos e ver como usar ponteiros com structs.

Veja um exemplo simples, parecido com o anterior, mas agora usando uma struct.

package main

import "fmt"

type Pessoa struct {
    Nome  string
    Idade int
}

func main() {
    p := Pessoa{
        Nome:  "Lucas",
        Idade: 25,
    }

    fmt.Println("Antes da alteração:", p)

    // Chamando a função que altera o valor da struct
    alteraIdade(&p)
    fmt.Println("Depois da alteração:", p)
}
// Função que altera a idade da pessoa usando ponteiros

func alteraIdade(p *Pessoa) {
    p.Idade = 30
}

Ponteiros com Slices

Você também pode usar ponteiros com slices.

Veja um exemplo:

package main

import "fmt"

// Exemplo de uso de ponteiros com slices

func main() {
    numeros := []int{1, 2, 3, 4, 5}
    fmt.Println("Antes da alteração:", numeros)

    // Chamando a função que altera o valor do slice
    alteraSlice(&numeros)
    fmt.Println("Depois da alteração:", numeros)
}
// Função que altera o valor do slice usando ponteiros
func alteraSlice(s *[]int) {
    (*s)[0] = 10
    (*s)[1] = 20
}

Conclusão

Esse é o uso básico de ponteiros em Go. É possível fazer muito mais com ponteiros, mas, por enquanto, isso é suficiente para entender o conceito.