Punteros en Go, ¿Por qué tendría que usarlos?

Los que ya llevan cierto tiempo en la programación sabrán que uno de los conceptos más difíciles de aprender y usar son los famosos punteros: variables que almacenan la dirección de memoria de otra variable.

Y es que una variable (en lenguajes de tipado estático como C) se compone de:

1. Un tipo de dato. 
2. Un nombre. 
3. Un valor. 
4. Una dirección de memoria.

Las dos primeras características las define el programador, el valor depende del flujo del programa. La memoria la designa el sistema.

En el lenguaje de programación C tenemos que:

// Definimos una variable de tipo entero con un valor
int numeroInt = 33;

// Definimos un puntero que almacena la dirección de la variable numeroInt
int *punteroInt = &numeroInt;

Esto nos permite trabajar con datos de manera más eficiente y flexible, especialmente cuando quieres modificar valores dentro de funciones o estructuras sin copiar todo el contenido.

Pero, ¿Qué tiene que ver con Go? La respuesta es: tiene mucho que ver.

Recordemos que Go se considera como una evolución natural de C y lenguajes similares.

El uso de punteros es uno de sus sellos particulares.

En Go se representan con el operador * (para declarar o acceder al valor apuntado) y & (para obtener la dirección de una variable). Como en C.

Veamos un ejemplo:

puntero.go

package main

import "fmt"

func main() {
    numeroInt := 10
    punteroInt := &numeroInt // punteroInt es un puntero a numeroInt

    fmt.Println("Valor de numeroInt:", numeroInt)
    fmt.Println("Dirección de numeroInt:", punteroInt)
    fmt.Println("Valor apuntado por punteroInt:", *punteroInt)
}

En este ejemplo definimos una variable de tipo int (Go induce su tipo) y un puntero que almacena la dirección de memoria de esa variable. Mostramos el valor de la variable entera, su dirección de memoria y el valor apuntado por el puntero.

Compilación y ejecución:

$ go build puntero.go
$ ./puntero

Salida:

Valor de numeroInt: 10
Dirección de numeroInt: 0xc00008a058
Valor apuntado por punteroInt: 10

A todo esto, ¿Para qué sirven? Algunas de las cosas en las que nos sirven pueden ser:

• Evitar copias innecesarias: en lugar de pasar grandes estructuras por valor, puedes pasar un puntero y trabajar directamente sobre la memoria original. 
• Modificar valores dentro de funciones: Go pasa los argumentos por valor, pero si pasas un puntero puedes cambiar el contenido original. 
• Eficiencia en memoria: útil en estructuras grandes o cuando necesitas compartir datos entre distintas funciones.

Con los punteros obtenemos la dirección de una variable (&).

Accedemos al valor almacenado en la dirección (*).

Además los punteros en Go son seguros (no hay aritmética de punteros como en C).

Veamos otro ejemplo donde vemos como incrementar el valor de una variable.

incremento.go

package main

import "fmt"

func incrementar(n *int) {
    *n = *n + 1 // modificamos el valor apuntado
}

func main() {
    x := 5
    fmt.Println("Valor de x:", x)
    incrementar(&x) // pasamos la dirección de x
    fmt.Println("Valor de x después:", x) // imprime 6
    incrementar(&x) // pasamos la dirección de x
    fmt.Println("Valor de x después:", x) // imprime 7
}

Compilación y ejecución:

$ go build incremento.go
$ ./incremento

Salida:

Valor de x: 5
Valor de x después: 6
Valor de x después: 7

Go es un lenguaje que ha tomado mucho del lenguaje C. Y esto se puede ver en los structs: una colección tipada de campos utilizada para agrupar datos relacionados y formar registros personalizados (parecido a una clase). Las cuales van de la mano con los punteros.

Veamos otro ejemplo con punteros y colecciones structs.

persona.go

package main

import "fmt"

type Persona struct {
    Nombre string
    Edad   int
}

func cumple(p *Persona) {
    p.Edad++ // modificamos directamente la edad
}

func main() {
    p := Persona{"Thomas Muller", 30}
    fmt.Println(p) // {Thomas Muller 30}
    cumple(&p)
    fmt.Println(p) // {Thomas Muller 31}
}

Compilación y ejecución:

$ go build persona.go
$ ./persona

Salida:

{Thomas Muller 30}
{Thomas Muller 31}

Hemos visto lo que son los punteros y algunos de sus usos

Continuaremos con más de Go en próximas entregas.

Enlaces:

https://ed.team/blog/que-son-los-punteros-en-go
https://alquimistadecodigo.blogspot.com/2026/04/creando-proyectos-go-con-go-blueprint.html
https://alquimistadecodigo.blogspot.com/2025/12/creando-proyectos-con-go.html