A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Punteros

13/42
Recursos

Aportes 26

Preguntas 1

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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)

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

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

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.

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 


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

Buena clase

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

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

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 鈥減aso 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

驴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.

驴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