Hey Gopher, how’s it going?
Lately, I’ve been dedicating my free time to studying Golang, and I must admit it’s been an interesting and challenging journey.
During my learning process, I initially had some “resistance” in understanding what pointers actually are. Coincidentally, while following some blogs and pages about Go, I noticed that many people face the same obstacle — and that’s completely normal.
That’s why I decided to create this space to write a bit about them.
So, what is a pointer?
A pointer is simply a variable whose content is a memory address. If you share this pointer elsewhere, we can directly access the address where the data is stored, and from there, manipulate that memory space in some way.
Here’s a brief summary of how memory works:
In short, memory is made up of addresses that store data, referred to as “values” in the image above. Each variable created in the code receives a memory address, and its corresponding value is stored at that address.
package main
func main() {
a := 15
b := "foo"
}
In the code snippet above, two variables were declared: one named a with the value 15, and another named b with the value “foo”.
The image above shows the memory address assigned to each one and their respective values.
How to declare a pointer?
A pointer is declared using * followed by the data type you want to declare, such as int, string, etc.
package main
func main() {
var p *int
/* Here, the pointer is declared,
but no memory address is assigned to it. */
}
How to assign a memory address to a pointer?
You assign the address of a given variable to the pointer using & before the variable (e.g., &a).
package main
import "fmt"
func main() {
var p *int
a := 15 // declaring a variable of type int
p = &a // getting the address of the variable (a)
//and assigning it to the pointer (*)
fmt.Println(p) // OUTPUT: memory address assigned, example:
// 0x140000140a5
}
How to know the value stored at the memory address?
To get the value stored at the memory address assigned to the pointer, simply use * before the pointer (e.g., p).
package main
import "fmt"
func main() {
var p *int
a := 15
p = &a
fmt.Println(*p) // OUTPUT: 15 -> Value stored at the address.
}
When to use pointers?
It’s well known that pointers help when it comes to performance. But when should you use them?
Mutability
The only way to modify a variable passed to a function is by passing a pointer. By default, passing by value means that any changes are made to a copy you’re working with. As a result, they are not reflected in the calling function. Here’s an example:
package main
import "fmt"
type dog struct {
name string
}
func main() {
d := dog{"Fifo"}
changeDogName(d)
fmt.Println(d)
}
func changeDogName(d dog) {
d.name = "Mike"
}
The output of fmt.Println will be “Fifo” and not “Mike” because the dog’s name is being changed in a “copy” of the variable. To fix this, just use a pointer.
package main
import "fmt"
type dog struct {
name string
}
func main() {
d := dog{"Fifo"}
changeDogName(&d)
fmt.Println(d)
}
func changeDogName(d *dog) {
d.name = "Mike"
}
Now the output will be “Mike" 🙂
There are other cases where using pointers is recommended, but in my opinion, mutability is the main one. You can find others in a very good article that I used as a reference for my studies.
Anyway, that’s it…
Just a reminder: I came up with the idea of writing this brief summary about pointers mainly for learning purposes and maybe to help someone who has questions about the topic.
I used this excellent article by Dylan Meeus as a reference — I highly recommend checking it out. 😁