Cool there are pointers in Go!
Idiomatic Go code -- such as the standard library (or even the Go runtime itself!) -- is full of use cases for pointers! Whenever we want to pass something by reference -- and avoid creating a copy of it -- we send pointers. Go also abstracts away all of the deep details of the pointer implementation, so developers can focus on leveraging the higher-level features. Remember that the Go runtime's garbage collector will manage the references and reclaim memory automatically.
Basic Pointers Example
package main
import (
"fmt"
)
type FooStruct struct {
Children []*FooChild
}
type FooChild struct {
SampleVal int
}
func main() {
ptrToFoo := giveMePointer()
// Expect something like: &{[0x416020 0x416024 0x416028 0x41602c 0x416030 0x416034 0x416038 0x41603c 0x416040 0x416044]}
fmt.Println(ptrToFoo)
// Expect something like: Children: [0x416020 0x416024 0x416028 0x41602c 0x416030 0x416034 0x416038 0x41603c 0x416040 0x416044]
fmt.Println("Children:", ptrToFoo.Children)
for _, child := range ptrToFoo.Children {
// Child (ptr): &{42} Dereferenced: {42}
fmt.Println("Child (ptr):", child, "Dereferenced:", *child) // The * followed by a pointer, 'dereferences' a pointer and yields the value directly
}
// When you're playing with pointers, watch out for nil-pointer panics
var thisIsNil *FooStruct
// 💣 Boom! Nil-pointer panic and it's game over (this might be a good time to review panic/recover!)
fmt.Println(thisIsNil.Children)
}
func giveMePointer() *FooStruct {
// Initialize a FooStruct with an empty slice for children
foo := FooStruct{
// NB: The []*FooChild syntax means that we're going to have the slice be of pointers to FooChild's -- not directly FooChild's.
// Careful readers will note that this means we are *only* allocating the memory required to store 10 pointers, not 10 FooChild's
Children: make([]*FooChild, 10),
}
// Populate the foo.Children slice with pointers to FooChild's
for i := range foo.Children {
// The &FooChild syntax initializes the object and gives us the pointer -- as opposed to the struct directly (short-hand notation)
foo.Children[i] = &FooChild{
SampleVal: 42+i,
}
}
// Here, we use the &foo to return the pointer to foo, instead of a copy of foo
return &foo
}
What if I want to go crazy with pointers?
Go's unsafe packages offers 'unsafe' utilities for working with pointers. The warning is the name of the package. Have fun!
Keep it Idiomatic!
Use pointers liberally, they are frequently the most idiomatic way to pass data around
Generally avoid pointers to slices, maps, or channels -- that's redundant (since those are already reference-based) and actually might make things harder, for instance, you can't use range with a pointer to a slice.
Edit Me on GitHub!
