Punteros y Structs en Go: Aplicaciones Prácticas y Funciones
Contenido del curso
Luis Arturo Cruz Cruz
Raúl Humberto Peñate Ramírez
Royer Guerrero Pinilla
Rogger Vásquez Oviedo
J. Sebastián Botello. H.
Miguel Angel Luque Acevedo
Daniel Fernández Sánchez
Peter Jonathan Montalvo Garcia
Andres Giovanny Rodriguez Escobar
María Sol Battaglia
Juan Carlos García Esquivel
Miguel Buritica
Wilson Fernando Antury Torres
Guillermo Pedro Cuneo
Wilson Fernando Antury Torres
Anthony Aguilar
Anthony Aguilar
Ignacio Castillejo Gómez
Anibal Jose
José Gustavo Meoño Velázquez
Cristian Cepeda
Kebyn Enrique Ajin Elías
Xavier Flores
Fernando Pioli Martínez
Anibal Jose
Enzo Venturi
Mario Andrés Castro Martínez
Aldo Said Salas Rodríguez
Nicoll Idaly Angulo Mejia
Eliaz Bobadilla
Nicolás Peralta Páez
Wilmer León Chávez
Joserra Parada Fontaiña
Anibal Jose
Eso de los punteros es una herencia directa del lenguaje C, y si mal no recuerdo es ya una norma en los leguajes compilados.
Nunca entendí del todo los memes sobre punteros, con saber cómo funcionan el heap y el stack puede ya se entienden. En lenguajes que manejan la memoria automáticamente, como Java, el concepto de punteros se reemplaza por el manejo de referencias a objetos y esto molesta porque a vecez hacen falta jaja.
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.
Gracias! el curso de CS50 es muyyy bueno.
Gracias, material interesante
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() }
Genial
Perfecto!
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
Muy buen aporte, muchas gracias.
Considero esta lectura fundamental para entender como funciona y para que nos puede servir diferenciarlos
Te agrego un detalle:
Lo que pude entender:
Me pareció bueno tu aporte, y me surgió un duda con este punto:
Si no indicamos el apuntador, es posible acceder a los valores de las variables, pero no es posible modificarlos desde el método.
por lo que hice una prueba y esto es lo que vi:
type pc struct { ram int hdd int brand string } func (myPc pc) ping() { myPc.brand = "Apple" fmt.Println(myPc.brand, "pong") } func main() { myPC := pc{ram: 4, hdd: 500, brand: "Dell"} myPC.ping() fmt.Println(myPC) }
esto me imprime
Apple pong {4 500 Dell}
lo que me demuestra que:
Cuando NO se indica el apuntador en el método, es posible modificar los datos, pero SOLO dentro de esa función, en este caso la función ping() ya que imprimió Apple. pero no queda guardado en memoria ya que después imprimió Dell.
Por lo que el segundo punto seria:
Si no indicamos el apuntador al método, es posible acceder a los valores de las variables, pero no es posible modificarlos en memoria.
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.
siento que falta claridad en las explicaciones,
Van varias clases donde pasa exactamente lo mismo.
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 :)
estas explicaciones son muy vagas para quien recien esta aprendiendo a programar....
estas explicaciones son muy claras para alguien que ya sepa programar en otro lenguaje....
estas explicaciones son lo mejor cuando te quieres saltar de un lenguaje a otro y aprender las bases para comenzar a desarrollar en horas...
a mi criterio no esta bueno que cuando el profe te dice "Para profundizar tal tema..." te mande a una enciclopedia. Yo como profe, trataría de ser mas específico.
el profesor dice "agregamos el metodo ping, cuando no ha explicado que es un metodo, tampoco si es que la funcion se llama ping o es que existe una keyword que se llame ping, no lo se, la verdad falta mucha claridad en estas explicaciones"
También podemos duplicar la ram de esta forma:
myPc.ram *= 2
Mi reto:
En Go para escribir métodos a las "clases" o structs se les llama receiver functions y estas se distinguen de las funciones normales porque antes del nombre de la función reciben una variable de tipo struct que le pasemos.
Ejemplo en Go:
type pc struct { ram int disk int brand string } func (myPc pc) ping() { fmt.Println(myPc.brand, "Pong") } func main() { myPC := pc{ram: 16, disk: 200, brand: "msi"} myPC.ping() }
Su equivalente en Python:
class PC: def __init__(self, ram, disk, brand): self.ram = ram self.disk = disk self.brand = brand def ping(self): print(self.brand, "Pong") myPC = PC(16, 200, "msi") myPC.ping()
O su equivalente en TypeScript:
class PC { ram: number; disk: number; brand: string; constructor(ram: number, disk: number, brand: string) { this.ram = ram; this.disk = disk; this.brand = brand; } ping(): void { console.log(this.brand, "Pong"); } } let myPC: PC = new PC(16, 200, "msi"); myPC.ping();
Ver los nombres de un strong con %+v
package main import "fmt" type Pc struct { RAM int Disco int } func (pc *Pc) dupicateRam() { pc.RAM = pc.RAM * 2 } func main() { var Mypc = Pc{ RAM: 2, Disco: 120, } fmt.Printf("%+v\n", Mypc) Mypc.dupicateRam() fmt.Printf("%+v\n", Mypc) Mypc.dupicateRam() fmt.Printf("%+v\n", Mypc) }
Codigo de la clase:
package main import "fmt" type pc struct { ram int disk int brand string } func (myPC pc) ping() { fmt.Println(myPC.brand, "Pong") } func (myPC *pc) duplicateRam() { myPC.ram = myPC.ram * 2 } func (myPC *pc) duplicateDisk() { myPC.disk = myPC.disk * 2 } func main() { var a int = 50 b := &a fmt.Println(*b, b) *b = 100 fmt.Println(a) myPC := pc{ram: 16, disk: 200, brand: "linux"} fmt.Println(myPC) myPC.ping() fmt.Println(myPC) myPC.duplicateRam() myPC.duplicateDisk() fmt.Println(myPC) }
Esto esta mas documentado aquí.
Uuuff, Crack!
📄 Un buen artículo con ejemplo sobre los punteros, cómo crearlos y usar los operadores de dirección (&) y desreferenciación (*) https://ed.team/blog/que-son-los-punteros-en-go
Ahora si que estoy confuso, porque creo recordar que en C, se le tenía que pasar un puntero y, aquí veo que se le pasa el mismo valor pero se tipa de puntero, y ahí si que me pierdo.
falta claridad en lo que explica, que significa agregar algo antes del nombre de la funcion? me da bronca que solo diga "escribe aca el struct y listo" en vez de explicar bien
