Fundamentos de punteros en Go

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy — lección 19 de 107.

Un puntero es una variable que almacena la dirección de memoria de otra variable. En lugar de contener un valor directamente, contiene la ubicación donde vive ese valor en la memoria. Los punteros son fundamentales en Go y esenciales para una manipulación de datos eficiente.

Para crear un puntero, usa el operador & para obtener la dirección de una variable, y el operador * para declarar un tipo de puntero o acceder al valor en esa dirección.

x := 42
p := &x  // p contiene la dirección de memoria de x

fmt.Println(p)  // 0xc000018030 (dirección de memoria)
fmt.Println(*p) // 42 (valor en esa dirección)

El operador & significa "dirección de" y devuelve un puntero. El operador *, cuando se usa en un puntero, significa "valor en" y se llama desreferenciación. También puedes modificar el valor original a través del puntero.

x := 10
p := &x

*p = 25         // cambiar el valor a través del puntero
fmt.Println(x)  // 25 (la variable original cambió)

El tipo de puntero se escribe como *T donde T es el tipo al que se apunta. Un puntero a un int tiene el tipo *int.

var p *int      // declara un puntero a int
x := 100
p = &x          // p ahora apunta a x

El valor cero de un puntero es nil, lo que significa que no apunta a nada. Intentar desreferenciar un puntero nil provoca un pánico en tiempo de ejecución (runtime panic), por lo que siempre debes asegurarte de que los punteros estén inicializados antes de su uso.

Desafío

Fácil

Vamos a construir un intercambiador de valores simple que demuestre el poder de los punteros para modificar variables a través de sus direcciones de memoria.

Organizarás tu código en dos archivos:

swap.go: Crea una función llamada SwapValues que reciba dos punteros *int como parámetros. Esta función debe intercambiar los valores a los que apuntan estos punteros; después de llamarla, cada variable debe contener el valor original de la otra. La función no devuelve nada; modifica los valores directamente a través de los punteros.
main.go: Lee dos números enteros de la entrada, almacénalos en variables y luego usa tu función SwapValues para intercambiar sus valores. Imprime ambos valores antes y después del intercambio para mostrar el cambio.

Se proporcionarán las siguientes entradas:

Línea 1: Primer número entero
Línea 2: Segundo número entero

Formato de salida:

Before: a=[first] b=[second]
After: a=[first] b=[second]

Por ejemplo, dados 10 y 25, tu salida debería ser:

Before: a=10 b=25
After: a=25 b=10

Recuerda usar el operador & al pasar tus variables a la función, y el operador * dentro de la función para acceder y modificar los valores reales.

Hoja de referencia

Un puntero es una variable que almacena la dirección de memoria de otra variable. Utilice el operador & para obtener la dirección de una variable, y el operador * para declarar un tipo de puntero o acceder al valor en esa dirección.

x := 42
p := &x  // p holds the memory address of x

fmt.Println(p)  // 0xc000018030 (memory address)
fmt.Println(*p) // 42 (value at that address)

El operador & significa "dirección de" y devuelve un puntero. El operador *, cuando se usa en un puntero, significa "valor en" y se llama desreferenciación.

Puede modificar el valor original a través del puntero:

x := 10
p := &x

*p = 25         // change value through pointer
fmt.Println(x)  // 25 (original variable changed)

El tipo de puntero se escribe como *T donde T es el tipo al que se apunta:

var p *int      // declares a pointer to int
x := 100
p = &x          // p now points to x

El valor cero de un puntero es nil. Intentar desreferenciar un puntero nil provoca un pánico en tiempo de ejecución (runtime panic).

Pruébalo tú mismo

package main

import "fmt"

func main() {
	// Lee dos enteros de la entrada
	var a, b int
	fmt.Scanln(&a)
	fmt.Scanln(&b)

	// Imprime los valores antes del intercambio
	fmt.Printf("Before: a=%d b=%d\n", a, b)

	// TODO: Llama a la función SwapValues con punteros a a y b
	// Recuerda usar el operador & para pasar direcciones

	// Imprime los valores después del intercambio
	fmt.Printf("After: a=%d b=%d\n", a, b)
}