No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Structs y Punteros

23/36
Recursos

Aportes 48

Preguntas 5

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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.

  • El s铆mbolo " & " accede a la memoria de la variable.
  • El s铆mbolo " * " accede al valor que est谩 guardado en memoria, usando la direcci贸n de memoria de la variable.

Lo que pude entender:

  • Podemos asociar una funci贸n o m茅todo a un struct.
  • Si no indicamos el apuntador, es posible acceder a los valores de las variables, pero no es posible modificarlos desde el m茅todo.
  • Si pasamos el apuntador al m茅todo, entonces tendremos acceso a la memoria donde podremos modificar los valores.

Un ejemplo para complementar el uso de Pointer receivers
https://tour.golang.org/methods/4

Para solucionar el reto, cre茅 una carpeta llamada 鈥減cpackage鈥 y dentro, un archivo llamado 鈥減cpackage.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 :)

Tambi茅n podemos duplicar la ram de esta forma:

myPc.ram *= 2 

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.

Mi reto:

a mi criterio no esta bueno que cuando el profe te dice 鈥淧ara profundizar tal tema鈥︹ te mande a una enciclopedia. Yo como profe, tratar铆a de ser mas espec铆fico.

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

馃搫 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

Me gustar铆a aportar que los m茅todos en Golang tambi茅n son conocidos como funciones receptoras 贸 receiver functions en ingl茅s

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)
}

Yo lo cambie un poco ```js package main import ( "fmt" ) type pc struct { ram int disk int brand string } func (somePc pc) format() { fmt.Println("The HD of", somePc.disk, "has been formated.") } func (somePc *pc) replaceRAM(newRAM int) { somePc.ram = newRAM fmt.Println("The RAM has been updated to", somePc.ram) } func main() { a := 50 b := &a fmt.Println(a) fmt.Println(b) fmt.Println(*b) *b = 100 fmt.Println(a) myLap := pc{ram: 16, disk: 512, brand: "Dell"} fmt.Printf("myLap: %v\n", myLap) myLap.format() myLap.replaceRAM(32) fmt.Printf("myLap: %v\n", myLap) } ```package main import (聽 聽 "fmt") type pc struct {聽 聽 ram 聽 int聽 聽 disk 聽int聽 聽 brand string} func (somePc pc) format() {聽 聽 fmt.Println("The HD of", somePc.disk, "has been formated.")} func (somePc \*pc) replaceRAM(newRAM int) {聽 聽 somePc.ram = newRAM聽 聽 fmt.Println("The RAM has been updated to", somePc.ram)} func main() {聽 聽 a := 50聽 聽 b := \&a聽 聽 fmt.Println(a)聽 聽 fmt.Println(b)聽 聽 fmt.Println(\*b) 聽 聽 \*b = 100聽 聽 fmt.Println(a) 聽 聽 myLap := pc{ram: 16, disk: 512, brand: "Dell"}聽 聽 fmt.Printf("myLap: %v\n", myLap)聽 聽 myLap.format()聽 聽 myLap.replaceRAM(32)聽 聽 fmt.Printf("myLap: %v\n", myLap)}

Los punteros son un recurso muy util pero solo necesario en casos muy espec铆ficos, ya que el compilador de go se encarga de la mayor parte de los casos en manejo de memoria

En Go para escribir m茅todos a las 鈥渃lases鈥 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();

Mi soluci贸n al reto:
package:

package mypackagepc

import "fmt"

type Pc struct { //struct public
	ram   int    //private
	disk  int    //private
	brand string //private
}

func Constructor(ram int, disk int, brand string) Pc {
	return Pc{ram: ram, disk: disk, brand: brand}
}

func (miPc *Pc) SetRam(ram int) {
	miPc.ram = ram
}

func (miPc Pc) Ping() { //se asocia una funcion al struct pc, es como si fuera un metodo de una clase llamada pc.
	fmt.Println("brand: ", miPc.brand, "desde Pong")
}

func (miPc *Pc) DuplicateRam() { //ahora accederemos a la struct pero mediante apuntadores
	miPc.ram = miPc.ram * 2
}

func (miPc *Pc) ToString() {
	fmt.Println("ram: ", miPc.ram, ", disk: ", miPc.disk, ", brand: ", miPc.brand, ". desde package")
}

main:

package main

import (
	"fmt"
	rt "mispackages/curso_golang_platzi/curso.01.basico/src/mypackagepc"
)

func structsAndPunteros() {
	fmt.Println("\n Reto de Structs y Punteros en Go...")

	//RETO. ejercicio de apuntadores y funciones y structs
	myPc := rt.Constructor(8, 200, "asus")

	fmt.Println("myPc: ", myPc)
	myPc.SetRam(12)
	fmt.Println("myPc: ", myPc)
	myPc.Ping() //es como si fuera un metodo de la clase pc (en este caso de la Struct pc definida antriormente)

	//empezaremos a usar los apuntadores
	myPc.SetRam(16) //una forma de duplicar la ram

	fmt.Println("antes de duplicar la ram de myPc: ", myPc)
	myPc.DuplicateRam()
	fmt.Println("despues 01 de duplicar la ram de myPc: ", myPc)
	myPc.DuplicateRam()
	fmt.Println("despues 02 de duplicar la ram de myPc: ", myPc)
	myPc.ToString()

}

func main() {
	structsAndPunteros()
}

salida:

 Reto de Structs y Punteros en Go...
myPc:  {8 200 asus}
myPc:  {12 200 asus}
brand:  asus desde Pong
antes de duplicar la ram de myPc:  {16 200 asus}
despues 01 de duplicar la ram de myPc:  {32 200 asus}
despues 02 de duplicar la ram de myPc:  {64 200 asus}
ram:  64 , disk:  200 , brand:  asus . desde package

Mi soluci贸n al reto

package pc

import "fmt"

type PC struct {
	ram   uint64
	disk  uint64
	brand string
}

func NewPC(ram, disk uint64, brand string) PC {
	return PC{
		ram:   ram,
		disk:  disk,
		brand: brand,
	}
}

func (pc PC) Ping() {
	fmt.Println(pc.brand, "Pong")
}

func (pc *PC) DuplicateRAM() {
	pc.ram *= 2
}

func (pc *PC) SetRAM(newRAM uint64) {
	pc.ram = newRAM
}

func (pc *PC) SetBrand(newBrand string) {
	pc.brand = newBrand
}

func (pc *PC) SetDisk(newDisk uint64) {
	pc.disk = newDisk
}

func (pc PC) GetRAM() uint64 {
	return pc.ram
}

func (pc PC) GetBrand() string {
	return pc.brand
}

func (pc PC) GetDisk() uint64 {
	return pc.disk
}

func (pc PC) Describe() string {
	return fmt.Sprintf("Soy un PC marca %s, con %d GB de RAM y %d GM de Disco", pc.brand, pc.ram, pc.disk)
}

Aplicaci贸n en el main

package main

import (
	"basicCourse/src/pc"
	"fmt"
)

func main() {
	fmt.Println("Hello World")
	myPC := pc.NewPC(16, 200, "Asus")
	myPC.Ping()
	fmt.Println(myPC.Describe())
	myPC.DuplicateRAM()
	fmt.Println(myPC.Describe())
	myPC.SetDisk(550)
	fmt.Println(myPC.Describe())
}

Algo que entendi es que esto es mas o meos lo mismo al static en Java no? alguien corrijame si no es asi.

Code Resume

package main

import (
	"curso_golang_platzi/src/mypackage"
	"fmt"
)

//POINTERS
func main() {

	a := 50
	// The & returns the memory address of the given var
	b := &a

	fmt.Println(b)
	// The * returns the content of a given memory address
	fmt.Println(*b)

	//In the same way we can change the content of the given memory address
	*b = 100
	fmt.Println(a)

	myPC := mypackage.Pc{Ram: 16, Brand: "MSI"}
	fmt.Println(myPC)

	myPC.DuplicateMemory()
}
package mypackage

import "fmt"

type Pc struct {
	Ram   int
	Brand string
}

//We pass as pre parameters the pointer of the object
//This way we have a method of the struct
func (p *Pc) DuplicateMemory() {
	p.Ram = p.Ram * 2
	fmt.Println(p.Ram)
	fmt.Println(p.Brand)
}

func mypackage() {

}

Reto:

Archivo main.go:

package main

import (
	pk "curso_golang_basico/src/mypackage"
	"fmt"
)

func main() {
	//RETO, hacer el c贸digo de p煤nteros y funciones-structs pero de forma publica

	var myPc pk.Pc
	myPc.Brand = "Lenovo"
	myPc.Ram = 8
	myPc.Disk = 500

	myPc.Ping()

	fmt.Println(myPc)

	myPc.DuplicateRam()
	fmt.Println(myPc)

	myPc.DuplicateRam()
	fmt.Println(myPc)

}

Archivo mypackage.go:


package mypackage

import "fmt"

//Creamos un struct
type Pc struct {
	Ram   int
	Disk  int
	Brand string
}

//Da a conocer el "Brand" de la "Pc"
func (otherPc Pc) Ping() {
	fmt.Println(otherPc.Brand, "pong")
}

//Duplica la ram de la Pc
func (otherPc *Pc) DuplicateRam() {
	otherPc.Ram = otherPc.Ram * 2

}

management / management.go

package mangement

type Pc struct {
	Ram   int
	Disk  int
	Brand string
}

func (myPc *Pc) DuplicateRam() {
	myPc.Ram = myPc.Ram * 2
}

main.go

package main

import (
	"fmt"
	"golang/fundamentos/mangement"
)

func main() {
myPc := mangement.Pc{Ram: 16, Disk: 200, Brand: "msi"}
	fmt.Println(myPc)
	myPc.DuplicateRam()
	fmt.Println(myPc)
}


Reto:
Hice esta clase en un paquete:

type DoctorPublic struct {
	Name       string
	Speciality string
	Age        int
}

Y le agregue estas funciones:

//Funcion de la clase
//ShowData Public Funcion publica
func (myDoctor DoctorPublic) ShowData() string {
	age := strconv.Itoa(myDoctor.Age)
	return "Name:" + myDoctor.Name + " Speciality:" + myDoctor.Speciality + " Age:" + age

}

//Funcion con un puntero
//ChangeAge funcion publica para cambiar un valor mediante puntero
func (myDoctor *DoctorPublic) ChangeAge(age int) {
	myDoctor.Age = age
}

En el main:

//Instanciando un objeto
myDoctor_dos := pk.DoctorPublic{Name: "Gaia", Speciality: "Oncologo", Age: 20}

//Cambia la edad mediante el puntero
myDoctor_dos.ChangeAge(40)

fmt.Println(myDoctor_dos.ShowData())

Repaso

Es incre铆ble trabajar con punteros en GO, cuando me toc贸 aprenderlos en C era un dolor de cabeza

main.go

package main

import "curso_golang_platzi/src/pc"

func main() {myPc := pc.PC{Ram: 16, Disk: 1024, Brand: "MSI"}
	fmt.Println(myPc)
	myPc.Ping()

	fmt.Println(myPc)
	myPc.DuplicateRAM()

	fmt.Println(myPc)
	myPc.DuplicateRAM()
	fmt.Println(myPc)
}

pc.go

package pc

import "fmt"

// PC Datos para un PC
type PC struct {
	Ram   int
	Disk  int
	Brand string
}

func (this PC) Ping() {
	fmt.Println(this.Brand, "Pong")
}

func (this *PC) DuplicateRAM() {
	this.Ram = this.Ram * 2
}

los punteros son el acceso a la direcci贸n de memoria.

Soluci贸n reto

package strucpc

import "fmt"

type Pc struct {
	brand string
	disk  int
	ram   int
}

func (pc *Pc) SetBrand(brand string) {
	pc.brand = brand
}

func (pc *Pc) SetDisk(disk int) {
	pc.disk = disk
}

func (pc *Pc) SetRam(ram int) {
	pc.ram = ram
}

func (pc Pc) Brand() string {
	return pc.brand
}

func (pc Pc) Disk() int {
	return pc.disk
}

func (pc Pc) Ram() int {
	return pc.ram
}

func (pc Pc) ToString() string {
	return fmt.Sprintf("Marca: %s \nDisco: %d\nRam: %d", pc.brand, pc.disk, pc.ram)
}

-----------------------------

package main

import (
	pkPc "curso_goland_platzi/strucsPunteros/src/strucpc"
	"fmt"
)

func main() {
//PC PRIVATE FOR METODS
	var myPcPrivate pkPc.Pc
	myPcPrivate.SetBrand("private marca")
	myPcPrivate.SetDisk(500)
	myPcPrivate.SetRam(16)

	fmt.Println(myPcPrivate.ToString())
}

Reto resuelto:

Modifiqu茅 un poco la l贸gica del programa. Obvi茅 la funci贸n de duplicado y en remplazo, iter茅 con un bucle for el valor de la ram haciendo que al final de cada vuelta de ciclo, el valor de dicha llave, tenga la misma din谩mica de aumento como lo explicado en clase. Entonces:

// [...]
func main(){
  myPc.Ping() 
  for i := 0; i <= 3; i++{
    fmt.Println(myPc.Ram)
    myPc.Ram *= 2
  }
}

V茅ase tambi茅n el m贸dulo utilizado. Este a su vez ha estado sujeto a algunos cambios como el archivo principal: Struct contiene Ram & Disk compactados en una sola l铆nea junto al tipo de valor que en com煤n tienen, y por supuesto, el nombre como valores del Struct est谩n con Letter case para asegurar su coherencia de estar para p煤blico uso. La funci贸n Ping() tiene la misma l贸gica:

// [...]
// Pc   BD de una PC
type Pc struct {
	Ram, Disk int
	Brand     string
}

func(myPc Pc) Ping() {
  fmt.Println(myPc.Brand)
}

N贸tese tambi茅n los datos ingresados al struct:

 myPc := pkg.Pc{Ram: 16, Disk: 500, Brand: "XYR"}

Estos datos est谩n en el c贸digo completo, exactamente por encima de myPc.Ping() ubicado en el prime recuadro de c贸digo. Para facilitar la lectura, omit铆 dicha parte.

Clase en c贸digo:

package main

import "fmt"

func main() {
	fmt.Println("")
	fmt.Println("==================")
	fmt.Println("Structs y Punteros")
	fmt.Println("==================")
	fmt.Println()

	fmt.Println("Al crear una variable en realidad se crea una direcci贸n de memoria en ella se guarda un valor:")
	fmt.Println("variable := 50")
	fmt.Println()

	variable := 50

	fmt.Println("Al crear un puntero podemos tener 'referencia' a esa direcci贸n de memoria. Para ello se usa el caracter '&':")
	fmt.Println("punteroDeVariable := &variable")
	fmt.Println()

	punteroDeVariable := &variable

	fmt.Println("El valor de 'variable' es >>>", variable, "...por otro lado")
	fmt.Println("El valor de 'punteroDeVariable' es >>>", punteroDeVariable)
	fmt.Println()

	fmt.Println("Teniendo un puntero, para acceder a su informaci贸n se usa el caracter '*' de la siguiente forma:")
	fmt.Println("var abc int = *punteroDeVariable")
	fmt.Println()

	var abc int = *punteroDeVariable

	fmt.Println("El valor de 'abc' es: ", abc)
	fmt.Println()

	fmt.Println("驴que pasa si sumamos 123 a la variable 'abc' y que efecto tiene en la variable original?")
	fmt.Println()

	abc = abc + 123
	fmt.Println("abc = abc + 123 >>> resultado abc =", abc)
	fmt.Println("'variable' = ", variable)
	fmt.Println()

	*punteroDeVariable = *punteroDeVariable + 234

	fmt.Println("驴Que pasa si sumamos 234 pero al puntero de la variable? Para ello le ponemos el * antes:")
	fmt.Println("*punteroDeVariable = *punteroDeVariable + 234")
	fmt.Println("'*punteroDeVariable' imprime >>>", *punteroDeVariable)
	fmt.Println("valor de 'variable' original =", variable)
	fmt.Println("modificando el valor con el puntero, se modifica el de la variable original.")
	fmt.Println()

	fmt.Println("________________________________________________________________________________________")
	fmt.Println()

	fmt.Println("En java las referencias (versi贸n de punteros) se crean por Default para los objetos.")
	fmt.Println("En Java no aplica para los tipos primitivos y para los 'wrap' en clases de los tipos primitivos.")
	fmt.Println()

	fmt.Println("En Golang requiere hacer todo lo que se presenta en esta clase")
	fmt.Println("Se menciona que esto permite crear funciones mas personalizadas y ")
	fmt.Println("permite llevar funciones de una librer铆a a otro paquete de forma eficiente")
	fmt.Println("________________________________________________________________________________________")
	fmt.Println()
	fmt.Println()

	objetoStruct := MayusculoStruct{brand: "pollito", disk: 256, ram: 16}

	fmt.Println("Se crea un struct llamado 'MayusculoStruct' ...por estar su nombre en may煤scula:")
	fmt.Printf("%+v", objetoStruct)
	fmt.Println()
	fmt.Println()

	fmt.Println("Se llama una funci贸n constru铆da para el struct que aumenta el tama帽o de memoria en el pero")
	fmt.Println("Al recibir el struct por 'valor' al final no tiene efecto en el objeto original.")
	fmt.Println()

	objetoStruct.func_structPorValor_noModificaAlFinal()

	fmt.Println()
	fmt.Println("Se imprime en el 'main()' el objeto original: ")
	fmt.Printf("%+v", objetoStruct)
	fmt.Println()
	fmt.Println()

	fmt.Println("Ahora se llamara la funci贸n que recibe el struct por referencia y al final si tiene efecto sobre el original")
	fmt.Println()

	objetoStruct.func_structPorReferencia_siModificaAlFinal()

	fmt.Println()
	fmt.Println("Se imprime en el 'main()' el objeto original: ")
	fmt.Printf("%+v", objetoStruct)
	fmt.Println()
	fmt.Println()
}

func (computadora MayusculoStruct) func_structPorValor_noModificaAlFinal() {
	fmt.Println("_______________________________________")
	fmt.Println("func_structPorValor_noModificaAlFinal()")
	fmt.Println()

	fmt.Println("computadora.ram = computadora.ram * 2")
	computadora.ram = computadora.ram * 2

	fmt.Println("Resultado del cambio:")
	fmt.Printf("%+v", computadora)
	fmt.Println()
	fmt.Println()

	fmt.Println("fin de - func_structPorValor_noModificaAlFinal")
	fmt.Println("______________________________________")

}

func (emputadora *MayusculoStruct) func_structPorReferencia_siModificaAlFinal() {
	fmt.Println("____________________________________________")
	fmt.Println("func_structPorReferencia_siModificaAlFinal()")
	fmt.Println()

	fmt.Println("computadora.ram = computadora.ram * 2")
	emputadora.ram = emputadora.ram * 2

	fmt.Println("Resultado del cambio:")
	fmt.Printf("%+v", emputadora)
	fmt.Println()
	fmt.Println()

	fmt.Println("fin de - func_structPorReferencia_siModificaAlFinal")
	fmt.Println("______________________________________")
}

type MayusculoStruct struct {
	ram   int
	disk  int
	brand string
}

Mi aporte

package mypackage

import "fmt"

// Clase para representar una computradora
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
}


//  Clase Principal
package main

import (
	"fmt"
	"Training/src/mypackage"
)
func main(){
	
	var myPc mypackage.Pc
	myPc.Ram = 16
	myPc.Disk = 512
	myPc.Brand = "DELL"
	fmt.Println(myPc)
	myPc.Ping()
	myPc.DuplicateRam()
	fmt.Println(myPc)
}

Me dieron en mi kora de cuando estudiaba C y Java 鉂o笍

馃槑

Interesante

Reto
main

package main

import (
	pk "curso_golang_platzi/src/mypackage"
	f "fmt"
)

func main() {

	var myPC pk.PcPublic
	myPC.Brand = "asus"
	myPC.Ram = 16
	myPC.Disk = 512

	f.Println(myPC)
	myPC.DuplicateRam()

	f.Println(myPC)
	myPC.DuplicateRam()

	f.Println(myPC)
	myPC.Ping()
}

package

package mypackage

import "fmt"

type PcPublic struct {
	Brand string
	Ram int
	Disk int
}

func (myPC PcPublic) Ping() {
	fmt.Println(myPC.Brand,"Pong")
}

func (myPC *PcPublic) DuplicateRam() {
	myPC.Ram *= 2
}
package main

import (
	"fmt"

	pk "example.com/golang_basic/src/13.RetoPunteros/mypackage"
)

func main() {
	var myPc pk.PcPublic
	myPc.Ram = 16
	myPc.Disk = 240
	myPc.Brand = "Kingston"
	// myPc := PcPublic{ram: 16, disk: 200, brand: "MSI"} // Instanciar struct
	myPc.PingPublic()
	fmt.Println(myPc)

	myPc.DuplicateRAM()
	fmt.Println(myPc)

	myPc.DuplicateRAM()
	fmt.Println(myPc)

}




package mypackage

import 鈥渇mt鈥

// Creamos un struc llamado pc
type PcPublic struct {
Ram int
Disk int
Brand string
}

// output: brand, "Pong"
func (myPc PcPublic) PingPublic() {
fmt.Println(myPc.Brand, 鈥淧ong鈥)
}

func (myPc *PcPublic) DuplicateRAM() {
myPc.Ram = myPc.Ram * 2
}


EJECUCION:

- Se crea instancia ==>  PC {Marca:"msi", RAM:16, Disco:200}
- Se duplica la RAM ==>  PC {Marca:"msi", RAM:32, Disco:200}
- Se cambia el Disco ==>  PC {Marca:"msi", RAM:32, Disco:500}
- Se cambia la RAM ==>  PC {Marca:"msi", RAM:64, Disco:500} 

Increible

package main

import "fmt"

type pc struct {
	ram int
	disk int
	brand string
}

// Creat funcion a una estructura
func (myPc pc) ping() {
	fmt.Println(myPc.brand, "Pong")
}

func (myPc *pc) duplicateRAM() {
	myPc.ram = myPc.ram * 2
}

func main() {
	a := 50
	b := &a

	fmt.Println(a, &a, b, *b)

	*b = 100
	fmt.Println(a)


	myPc := pc{ram: 16, disk: 200, brand: "msi"}
	fmt.Println(myPc)
	myPc.ping()

	myPc.duplicateRAM()
	fmt.Println(myPc)
	
	myPc.duplicateRAM()
	fmt.Println(myPc)
	
}

CODIGO:

package main

import (
	"fmt"
	"golang-base/practices/src/pc"
)

func main() {
	var myPc = pc.New(16, 200, "msi")
	fmt.Println("- Se crea instancia ==> ", myPc.Sprintf())
	myPc.DuplicateRAM()
	fmt.Println("- Se duplica la RAM ==> ", myPc.Sprintf())
	myPc.SetDisk(500)
	fmt.Println("- Se cambia el Disco ==> ", myPc.Sprintf())
	myPc.SetRam(64)
	fmt.Println("- Se cambia la RAM ==> ", myPc.Sprintf())
} 

CODIGO:
Archivo 鈥減c.go鈥:

package pc

import "fmt"

type Pc struct {
	ram int
	disk int
	brand string
}

func New(ram int, disk int, brand string) Pc {
	return Pc{ram, disk, brand}
}

func (pc *Pc) GetRam() int {
	return pc.ram
}

func (pc *Pc) SetRam(ram int) {
	pc.ram = ram
}

func (pc *Pc) GetDisk() int {
	return pc.disk
}

func (pc *Pc) SetDisk(disk int) {
	pc.disk = disk
}

func (pc *Pc) GetBrand() string {
	return pc.brand
}

func (pc *Pc) SetBrand(brand string) {
	pc.brand = brand
}

func (pc *Pc) DuplicateRAM() {
	pc.SetRam(pc.ram * 2)
}

func (pc *Pc) Println() {
	fmt.Printf("PC {Marca:\"%s\", RAM:%d, Disco:%d}\n", pc.brand, pc.ram, pc.disk)
}

func (pc *Pc) Sprintf() string {
	return fmt.Sprintf("PC {Marca:\"%s\", RAM:%d, Disco:%d}", pc.brand, pc.ram, pc.disk)
} 

Reto solucionado!!!