Punteros

Apuntes 😉

En Go hay dos tipos de parámetros que podemos usar en nuestras funciones o métodos:

• Pass by value (por valor) : Aquí la función ara una copia de la variable que se esta pasando y modificara la copia.
• Pass by pointer/reference (por puntero) : Aquí la función obtendrá un puntero que apunta a la misma dirección donde esta el valor de la variable o struct

Usos comunes:
Pass by value es usado cuando necesitamos utilizar los valores de las variables o propiedades de un struct SIN CAMBIAR EL VALOR DE ELLAS.
Por ejemplo si tengo un struct person:

type person struct {
   name string
   age int
}

// y quiero una función que imprima la información (va utilizar los 
//  valores para imprimirlos pero no los necesita cambiar), 
//  la funcion seria así:

func displayInfo(p person) {
   fmt.Printf("Name: %s, Age: %d", p.name, p.age)
}

// Y desde main la llamaríamos así 
//  (asumiendo que ya tienes p:= person{...}):
displayInfo(p)

2022 profesor Néstor Escoto, sabe explicar muy bien !

Explicación fácil de punteros:

x := 25 // Aqui lo que sucede es que en memoria RAM se va reservar un lugar en la memoria que tendrá 2 cosas: una dirección de memoria (la que obtenemos con &) y un valor, que es 25
y := &x // Aqui lo que decimos es que habrá un lugar en la memoria que también tendrá 2 cosas: su propia dirección de memoria y un valor, que será la dirección de memoria de x
fmt.Println(x) // Imprimirá 25
fmt.Println(&x) // Imprimirá la dirección de memoria donde se guarda x
fmt.Println(y) // Imprimirá el valor de y, que a su vez es la dirección de memoria de x, lo mismo de la línea de arriba
fmt.Println(*y) // Cuando tenemos una variable que guarda una dirección de memoria (su valor es una dirección de memoria), con el operador * accedemos a ese valor, aqui imprime 25 el valor de x
fmt.Println(&y) // También es importante notar que asi sea que y guarde como valor una dirección de memoria, y tiene su propia dirección de memoria donde reside, distinto a la dirección de memoria que tiene como valor

Espero no haya sido muy confuso y le ayude a la gente a entender!

Para que realmente modifiquemos el valor que pasamos por parametro (pasaje por referencia). Hacemos lo siguiente:

func cambiarValor(a *int){
	*a = 36
}

func main() {
	x := 25
	fmt.Println(x)
	cambiarValor(&x)
	fmt.Println(x)
}

Definimos como puntero el parametro y lo usamos asi para asignaciones, y el & cuando pasamos el parametro a la funcion

Muy buena la explicacion

la forma en que explicaste el concepto de puntero fue mejor que en otros videos que he visto.
No sabia que se llamaban operadores pero es valido para entender lo pesado que son los punteros.

¿Para qué nos sirven los punteros?
Los punteros son muy útiles en los casos en los que queremos pasar una variable como argumento a una función para que su valor sea modificado, lo que se conoce como pasar valores por referencia a una función.

Cuando creamos una función y le pasamos una variable como argumento, lo que hace la función es hacer una copia del valor de la variable y trabajar con ese valor, por lo que la variable que pasamos como argumento no se modifica.

x := 25 // x = 25

y := &x // y = dirección en memoria

z := *y // z = 25 - valor almacenado en la dirección de memoria, a la que apunta la variable y 

& Acede a la dirección de memoria de la variable
*Accede al valor almacenado en la dirección de memoria

Los apuntadores funcionan igual que en el lenguaje C++, todo bien.

Buena clase

Codigo para actualizar el valor de la clase

package main

import "fmt"

func main() {
        i := 10
        fmt.Println(i)
        fmt.Println(&i)
        cambiarValor(&i)
        fmt.Println(i)
}

func cambiarValor(i *int) {
        fmt.Println(i)
        *i = 20
}

Gracias

Información sobre punteros
https://www.digitalocean.com/community/conceptual_articles/understanding-pointers-in-go-es

Buena explicación Nestor!

Me recuerda a mis clases de programación 1 en la universidad cuando veíamos lenguaje C, ahora entiendo porque Go es primo-hermano de C 😄

Super … entendido 😃 usar apuntadores para actualización

&parameter esto imprime un valor exadecimal, una direccion de memoria

*variable va a la direccion de memoria y trae el valor de esta referencia

Buena clase.

Utilizar el ampersand (&) previo a una variable, es la sintaxis en Go para acceder a la dirección de memoria de una variable.

x := 25
fmt.Println(&x) // prints: 0xc0000a6000

Un dato importante es que cuando pasamos una variable como argumento a una función y dicha variable le hacemos algún tipo de manejo dentro de la función; la variable dentro del scope de la función es simplemente una copia con el valor de la original. En otros lenguajes se le conoce como “paso por referencia”.
La referencia de una variable también es un valor que se puede asignar a otras variables, esto es lo que se le conocería como una variable de tipo puntero y se definen con un asterisco previo al tipo de dato, indicando el tipo de dato al que va apuntar.

var y *int
y = &x
fmt.Println(y) // prints: 0xc0000a6000
fmt.Println(*y) // prints: 25

El caso opuesto es que usando asterisco (*) previo a una variable de tipo puntero, se obtiene el valor que está guardando.

package main

import (
	"fmt"
)

func cambiarValor(valor *int) {
	fmt.Println("cambiarValor: ", valor, *valor)
	*valor = 50
}

func main() {
	x := 25

	fmt.Println(x)
	fmt.Println(&x)
	fmt.Println(*&x)
	
	cambiarValor(&x)
	fmt.Println("cambiarValor(x): ", x)

	y := &x
	fmt.Println(y)
	fmt.Println(*y)
}```

me gusta que en este lenguaje haya paso por valor y por dirección.
No me gusta mucho su sintaxis pero bueno

package main

import "fmt"

func main() {
	x := 25
	fmt.Println(&x)
	pasoPorValor(x)
	fmt.Println(x)

	y := &x
	fmt.Println(y)
	fmt.Println(*y)

	z := 15
	pasoPorReferencia(&z)
	fmt.Println(z)

}

func pasoPorValor(a int) {
	fmt.Println(&a)
	a = 36
}

func pasoPorReferencia(a *int) {
	*a = 12
}

Programo en muchos lenguajes de programación pero esto de apuntadores me parece muy útil, debería tenerlo los lenguajes de programación jovenes

¿Qué son los punteros en Go?
Un puntero en Go es una variable que nos permite acceder a la dirección en memoria de otra variable.

Esto en C, mejorado y limpio