Lesson 15: Pointer

mkdir pointer
touch pointer/example_test.go pointer/pointer.go

package pointer

package pointer_test

// PassByValue passes an int by value. When an integer is passed by value it is
// copied into the function meaning whatever we do to this `intValue` it will
// never change the original because it's a copy.
func PassByValue(intVal int) {
	intVal = 100
	fmt.Println("intVal in function:", intVal)
}

func ExamplePassByValue() {
	intVal := 8
	pointer.PassByValue(intVal)
	fmt.Println("intVal after passing value:", intVal)
	// Output:
	// intVal in function: 100
	// intVal after passing value: 8
}

// PassByReference passes a pointer to the function. This value is an address,
// like your street address. If we derefence it `*intPointer` we can change the
// original value it was pointing to.
func PassByReference(intPointer *int) {
	*intPointer = 100
	// We can't check address in test because it's different every time the
	// program starts again.
	// fmt.Println("intPointer in function:", intPointer) <-- Check address
	fmt.Println("intVal in function:", *intPointer)
}

func ExamplePassByReference() {
	intVal := 8
	intPtr := &intVal
	pointer.PassByReference(intPtr)
	// pointer.PassByReference(&intVal) <-- Also works!
	fmt.Println("intVal after derefence:", intVal)
	// Output:
	// intVal in function: 100
	// intVal after derefence: 100
}

// PassMoreByReferences shows you that you can pass all of the other primitive
// data types and derefence '*' them and change their values.
func PassMoreByReferences(sPtr *string, bPtr *bool, rPtr *rune, fPtr *float64) {
	// Uncomment and `go test` to see what these values are before you
	// dereference them and change the values at their locations.
	// fmt.Printf("string: %p\nbool: %p\nrune: %p\nfloat: %p\n",
	// 	sPtr, bPtr, rPtr, fPtr)
	// fmt.Println("addresses:", sPtr, bPtr, rPtr, fPtr)
	*sPtr = "Dereferenced and changed"
	*bPtr = true
	*rPtr = '🤡'
	*fPtr = 3.14159
}

string: 0xc0001a4000
bool: 0xc00018c015
rune: 0xc00018c018
float: 0xc00018c020
addresses: 0xc0001a4000 0xc00018c015 0xc00018c018 0xc00018c020

func ExamplePassMoreByReferences() {
	s := "This is going to change"
	b := false
	r := '🔥'
	f := 2.139284094893
	fmt.Printf(`Before changing values:
string value: %q
bool value: %t
rune as emoji value: %s
float value: %f

`, s, b, string(r), f)

	pointer.PassMoreByReferences(&s, &b, &r, &f)
	fmt.Printf(`After changing values:
string value: %q
bool value: %t
rune as emoji value: %s
float value: %f

`, s, b, string(r), f)
	// Output:
	// Before changing values:
	// string value: "This is going to change"
	// bool value: false
	// rune as emoji value: 🔥
	// float value: 2.139284
	//
	// After changing values:
	// string value: "Dereferenced and changed"
	// bool value: true
	// rune as emoji value: 🤡
	// float value: 3.141590
}

int *mySlice = calloc(8,  sizeof(int));
mySlice += 5;
*mySlice = 20;
mySlice -= 5;

int mySlice[8];
mySlice[5] = 20;

type ChangeThings struct {
	Int  int
	Str  string
	Rune rune
}

// PassCollections shows what happens when we try to dereference slices, maps,
// and structs. Structs are special in that they are NOT a pointer like slices
// and maps and therefore need to have a pointer passed in if we want to change
// their inner values.
func PassCollections(slice []string, mp map[string]rune, ctCopy ChangeThings,
	ctPtr *ChangeThings) {

	// With fmt.Printf("%p, %p, %p, %p", slice, mp, ctCopy, ctPtr) you can see
	// the address of all of the arguments, we don't do it here because every
	// time the function executes the address will change! 🤯 and therefore the
	// test would, Never! pass.
	for i := range slice {
		if i == 0 {
			slice[i] = "Dereferenced by `[]` operator. It acts just like `*` operator"
		} else {
			slice[i] = fmt.Sprintf("me %d", i+1)
		}
	}
	for k, v := range mp {
		mp[k] = v % 7 // Dereferenced again with `[]` operator
	}
	ctCopy.Int = 0xF4B1E
	ctCopy.Str = "Changing a copies value doesn't work on the original."
	ctCopy.Rune = '🌞'
	ctPtr.Int = 0xF4B1E
	ctPtr.Str = "Dereferenced with the `.` operator, like `*` and `[]`."
	ctPtr.Rune = '🌞'
	// These lines do nothing, as the function makes a copy of everything it
	// receives. What we really wanted was to release the original collection
	// types to garbage collection. That must be done where it is instantiated.
	// Not when it is passed to a function as a copy.
	slice = nil
	mp = nil
	ctPtr = nil
	// NOTE(jay): won't work
	// ctCopy = nil
	//
	// This makes it more obvious that we have don't have a pointer. A pointer
	// can always be set to nil. We set it to a zero valued ChangeThings struct.
	ctCopy = ChangeThings{}
}

func ExamplePassCollections() {
	sl := []string{"Look", "at", "all", "my", "values"}
	mp := map[string]rune{
		"boxing":     '🥊',
		"chestnut":   '🌰',
		"ocean":      '🌊',
		"heart-eyes": '😍',
		"microphone": '🎤',
		"hibiscus":   '🌺',
	}
	asCopy := pointer.ChangeThings{
		Int:  777,
		Str:  "Will I change?",
		Rune: '🌔',
	}
	asCopy2 := pointer.ChangeThings{
		Int:  777,
		Str:  "Will I change?",
		Rune: '🌔',
	}
	asPtr := &asCopy2
	/////////////////////////////////////////////////////////////////////////////
	fmt.Printf(`Before changing values:
slice value: %#v
map value: %#v
copy of struct value: %#v
pointer to struct value: %#v
copy2 of struct value: %#v

`, sl, mp, asCopy, asPtr, asCopy2)

	pointer.PassCollections(sl, mp, asCopy, asPtr)
	/////////////////////////////////////////////////////////////////////////////
	fmt.Printf(`After changing values:
slice value: %#v
map value: %#v
copy of struct value: %#v
pointer to struct value: %#v
copy2 of struct value: %#v

`, sl, mp, asCopy, asPtr, asCopy2)

	/////////////////////////////////////////////////////////////////////////////
	sl = nil
	mp = nil
	asPtr = nil
	asCopy = pointer.ChangeThings{}
	asCopy2 = pointer.ChangeThings{}
	fmt.Printf(`Actually remove all elements from collection types:
pointer: %#v
pointer: %#v
pointer: %#v
literal: %#v
literal: %#v
`, sl, mp, asPtr, asCopy, asCopy2)
	// Output:
	// Before changing values:
	// slice value: []string{"Look", "at", "all", "my", "values"}
	// map value: map[string]int32{"boxing":129354, "chestnut":127792, "heart-eyes":128525, "hibiscus":127802, "microphone":127908, "ocean":127754}
	// copy of struct value: pointer.ChangeThings{Int:777, Str:"Will I change?", Rune:127764}
	// pointer to struct value: &pointer.ChangeThings{Int:777, Str:"Will I change?", Rune:127764}
	// copy2 of struct value: pointer.ChangeThings{Int:777, Str:"Will I change?", Rune:127764}
	//
	// After changing values:
	// slice value: []string{"Dereferenced by `[]` operator. It acts just like `*` operator", "me 2", "me 3", "me 4", "me 5"}
	// map value: map[string]int32{"boxing":1, "chestnut":0, "heart-eyes":5, "hibiscus":3, "microphone":4, "ocean":4}
	// copy of struct value: pointer.ChangeThings{Int:777, Str:"Will I change?", Rune:127764}
	// pointer to struct value: &pointer.ChangeThings{Int:1002270, Str:"Dereferenced with the `.` operator, like `*` and `[]`.", Rune:127774}
	// copy2 of struct value: pointer.ChangeThings{Int:1002270, Str:"Dereferenced with the `.` operator, like `*` and `[]`.", Rune:127774}
	//
	// Actually remove all elements from collection types:
	// pointer: []string(nil)
	// pointer: map[string]int32(nil)
	// pointer: (*pointer.ChangeThings)(nil)
	// literal: pointer.ChangeThings{Int:0, Str:"", Rune:0}
	// literal: pointer.ChangeThings{Int:0, Str:"", Rune:0}
}