Eso de los punteros es una herencia directa del lenguaje C, y si mal no recuerdo es ya una norma en los leguajes compilados.

Comprender cómo Go gestiona la memoria es fundamental para escribir código eficiente y escalable. Los punteros permiten trabajar directamente con direcciones de memoria, mientras que las funciones asociadas a structs amplían las capacidades de estas estructuras de datos. Dominar ambos conceptos abre la puerta a patrones de programación más limpios y optimizados.
¿Qué son los punteros y cómo funcionan en Go?
Cuando declaras una variable, el runtime de Go le asigna una dirección de memoria donde almacena su valor. Un puntero es simplemente una variable que guarda esa dirección en lugar del valor en sí [0:30].
Para obtener la dirección de memoria de una variable se utiliza el operador ampersand (&). Para acceder al valor almacenado en esa dirección se usa el asterisco (*), que cumple la función inversa [1:29].
go a := 50 b := &a // b almacena la dirección de memoria de a
fmt.Println(a) // 50 fmt.Println(b) // dirección de memoria, por ejemplo 0xc0000b4008 fmt.Println(*b) // 50, accede al valor mediante el puntero
¿Por qué modificar un puntero afecta a la variable original?
Una característica esencial de los punteros es que, al compartir la misma dirección de memoria, cualquier modificación a través del puntero se refleja en la variable original [2:15].
go *b = 100 fmt.Println(*b) // 100 fmt.Println(a) // 100, también cambió
Tanto a como *b apuntan a la misma ubicación en memoria. Modificar desde cualquiera de los dos puntos actualiza el mismo dato.
¿Cómo agregar funciones a un struct en Go?
Los structs en Go pueden tener métodos asociados que les agregan comportamiento. Para ilustrarlo, se define un struct que representa una PC [3:14]:
go type pc struct { ram int disco int marca string }
Después de instanciarlo, se le asocia una función llamada ping. La clave está en los paréntesis adicionales antes del nombre de la función, donde se declara el receptor (receiver), que vincula el método con el struct [4:07].
go func (myPC pc) ping() { fmt.Println(myPC.marca) fmt.Println("pong") }
miPC := pc{ram: 16, disco: 200, marca: "MSI"} miPC.ping() // Imprime: MSI y pong
El editor de código incluso autocompleta los atributos y métodos disponibles al escribir el punto después de la variable, lo que facilita el desarrollo.
¿Cómo usar punteros dentro de funciones de structs?
Aquí es donde los punteros muestran su verdadero potencial. Para modificar los valores internos de un struct desde un método, el receptor debe ser un puntero. Esto se logra agregando el asterisco antes del tipo de dato en el receptor [5:30].
go func (myPC *pc) duplicateRAM() { myPC.ram = myPC.ram * 2 }
Al ejecutar esta función varias veces, el cambio persiste en la instancia original porque se trabaja directamente con la dirección de memoria:
go fmt.Println(miPC) // {16 200 MSI} miPC.duplicateRAM() fmt.Println(miPC) // {32 200 MSI} miPC.duplicateRAM() fmt.Println(miPC) // {64 200 MSI}
Sin el asterisco en el receptor, Go crearía una copia del struct y los cambios no se reflejarían en la variable original. Esta es una de las formas más comunes de utilizar punteros en Go [6:40].
¿Por qué los punteros en Go son más sencillos que en otros lenguajes?
En muchos lenguajes de programación, el manejo de punteros implica complejidad adicional y riesgos como fugas de memoria. Go simplifica esto reduciendo toda la operación a dos símbolos [7:15]:
& (ampersand): obtiene la dirección de memoria.* (asterisco): accede al valor almacenado en esa dirección.Esta simplicidad no sacrifica potencia. Los punteros permiten crear funciones customizadas, transferir funcionalidad entre paquetes de forma eficiente y modificar estructuras de datos sin copias innecesarias.
Un detalle importante es que al imprimir un struct directamente con fmt.Println, el output puede resultar difícil de interpretar para alguien sin contexto del código. La solución a esto viene de la mano de los stringers, que permiten personalizar cómo se representa un struct al imprimirlo.
Si quieres poner en práctica lo aprendido, el reto propuesto consiste en organizar esta estructura de código en un paquete separado, definir qué métodos serán públicos y cuáles privados, y obtener el mismo resultado. Comparte tu solución en los comentarios.
Comprender cómo Go gestiona la memoria es fundamental para escribir código eficiente y escalable. Los punteros permiten trabajar directamente con direcciones de memoria, mientras que las funciones asociadas a structs amplían las capacidades de estas estructuras de datos. Dominar ambos conceptos abre la puerta a patrones de programación más limpios y optimizados.
Cuando declaras una variable, el runtime de Go le asigna una dirección de memoria donde almacena su valor. Un puntero es simplemente una variable que guarda esa dirección en lugar del valor en sí [0:30].
Para obtener la dirección de memoria de una variable se utiliza el operador ampersand (&). Para acceder al valor almacenado en esa dirección se usa el asterisco (*), que cumple la función inversa [1:29].
go a := 50 b := &a // b almacena la dirección de memoria de a
fmt.Println(a) // 50 fmt.Println(b) // dirección de memoria, por ejemplo 0xc0000b4008 fmt.Println(*b) // 50, accede al valor mediante el puntero
Una característica esencial de los punteros es que, al compartir la misma dirección de memoria, cualquier modificación a través del puntero se refleja en la variable original [2:15].
go *b = 100 fmt.Println(*b) // 100 fmt.Println(a) // 100, también cambió
Tanto a como *b apuntan a la misma ubicación en memoria. Modificar desde cualquiera de los dos puntos actualiza el mismo dato.
Los structs en Go pueden tener métodos asociados que les agregan comportamiento. Para ilustrarlo, se define un struct que representa una PC [3:14]:
go type pc struct { ram int disco int marca string }
Después de instanciarlo, se le asocia una función llamada ping. La clave está en los paréntesis adicionales antes del nombre de la función, donde se declara el receptor (receiver), que vincula el método con el struct [4:07].
go func (myPC pc) ping() { fmt.Println(myPC.marca) fmt.Println("pong") }
miPC := pc{ram: 16, disco: 200, marca: "MSI"} miPC.ping() // Imprime: MSI y pong
El editor de código incluso autocompleta los atributos y métodos disponibles al escribir el punto después de la variable, lo que facilita el desarrollo.
Aquí es donde los punteros muestran su verdadero potencial. Para modificar los valores internos de un struct desde un método, el receptor debe ser un puntero. Esto se logra agregando el asterisco antes del tipo de dato en el receptor [5:30].
go func (myPC *pc) duplicateRAM() { myPC.ram = myPC.ram * 2 }
Al ejecutar esta función varias veces, el cambio persiste en la instancia original porque se trabaja directamente con la dirección de memoria:
go fmt.Println(miPC) // {16 200 MSI} miPC.duplicateRAM() fmt.Println(miPC) // {32 200 MSI} miPC.duplicateRAM() fmt.Println(miPC) // {64 200 MSI}
Sin el asterisco en el receptor, Go crearía una copia del struct y los cambios no se reflejarían en la variable original. Esta es una de las formas más comunes de utilizar punteros en Go [6:40].
En muchos lenguajes de programación, el manejo de punteros implica complejidad adicional y riesgos como fugas de memoria. Go simplifica esto reduciendo toda la operación a dos símbolos [7:15]:
& (ampersand): obtiene la dirección de memoria.* (asterisco): accede al valor almacenado en esa dirección.Esta simplicidad no sacrifica potencia. Los punteros permiten crear funciones customizadas, transferir funcionalidad entre paquetes de forma eficiente y modificar estructuras de datos sin copias innecesarias.
Un detalle importante es que al imprimir un struct directamente con fmt.Println, el output puede resultar difícil de interpretar para alguien sin contexto del código. La solución a esto viene de la mano de los stringers, que permiten personalizar cómo se representa un struct al imprimirlo.
Si quieres poner en práctica lo aprendido, el reto propuesto consiste en organizar esta estructura de código en un paquete separado, definir qué métodos serán públicos y cuáles privados, y obtener el mismo resultado. Comparte tu solución en los comentarios.
Eso de los punteros es una herencia directa del lenguaje C, y si mal no recuerdo es ya una norma en los leguajes compilados.

Quiero compartir con ustedes este video CS50 2020 - Lecture 4 - Memory
Allí explican por qué lucen algo como 0xc0000b8010 spoiler está en hexadecimal el número y el 0x es un prefijo en la computación cuando se escribe un número hexadecimal.
Reto: Decidí dejar las variables del struct privadas y acceder a ellas mediante un get y set. Ya que hice uso de variables privadas cree un tipo de constructor.
package reto
import "fmt"
type Pc struct {
ram int
disk int
brand string
}
func New(rm, dsk int, brn string) Pc {
myPc := Pc{ram: rm, disk: dsk, brand: brn}
return myPc
}
func (myPc Pc) FormatPrint() {
fmt.Printf("Esta pc marca %s cuenta con una ram de %dGB y un disco de %dGB.\n", myPc.brand, myPc.ram, myPc.disk)
}
func (myPc *Pc) DuplicateRAM() {
myPc.ram = myPc.ram * 2
}
func (myPc Pc) GetRam() int {
return myPc.ram
}
func (myPc *Pc) SetRam(rm int) {
myPc.ram = rm
}
package main
import (
rt "curso-golang/src/16.Punteros/reto"
"fmt"
)
func main() {
myPc := rt.New(12, 200, "HP")
myPc.SetRam(16)
myPc.FormatPrint()
fmt.Println("Se duplica la ram")
myPc.DuplicateRAM()
myPc.FormatPrint()
}
Creo que en esta clase falto mas detalle de lo que sucede con las funciones y la sintaxis de golang para associarlas con los structs. Por favor revisar lo que son las Receiver Functions, los value receivers y los pointer receivers. En resumen es lo que el intento demostrar el final del video pero sin esta terminologia la explicacion esta desconectada de las definiciones de la sintaxis de go.
Este en un muy buen articulo donde explican punteros en Go https://www.digitalocean.com/community/conceptual_articles/understanding-pointers-in-go-es
Lo que pude entender:
me hizo gracia que dijera al final de la clase que se podía hacer una cosa y de repente la clase finalizará sin explicarla. Una lastima que desde hace ya varios años hacía aquí la calidad de la formación en platzi ha decaído muchísimo.
Un ejemplo para complementar el uso de Pointer receivers https://tour.golang.org/methods/4
Para solucionar el reto, creé una carpeta llamada "pcpackage" y dentro, un archivo llamado "pcpackage.go". Allí, escribí el siguiente código:
package pcpackage
import "fmt"
// PC struct with public access
type PC struct {
Ram int
Disk int
Brand string
}
func (myComputer *PC) DuplicateRAM() {
myComputer.Ram = myComputer.Ram * 2
fmt.Println(myComputer)
}
Luego, en el main.go para acceder al struct creado en pcpackage, escribí el siguiente código:
package main
import (
computer "curso_golang_platzi/src/pcpackage"
"fmt"
)
func main() {
var newComputer computer.PC
newComputer.Ram = 32
newComputer.Disk = 256
newComputer.Brand = "Razer"
fmt.Println(newComputer)
newComputer.DuplicateRAM()
// Output:
// {32 256 Razer}
// &{64 256 Razer}
}
}```
Espero que sea de utilidad :)