Pointers

5:32 with Jay McGavren

In Go, most variables hold values directly. So if you assign the value "1.23" to a variable, then for all intents and purposes, that's what the variable holds, "1.23". But it's also possible to create a "pointer" to a value. Pointers point to a value in memory. That is, pointers are a value that just gives the address of another value elsewhere in memory.

Teacher's Notes
Video Transcript
Downloads

Pointers point to a value in memory. That is, pointers are a value that just gives the address of another value elsewhere in memory. If you're familiar with object references in C# or Java, those work almost exactly like pointers. And if you already know Pointers from C or C++, Go pointers work almost exactly the same way, except that you can't alter an existing pointer like you can in C or C++.

To declare a variable that holds a pointer to a type of value, put a star (*) before the type. So var x float64 declares a variable that holds a float64 directly, but var x *float64 declares a variable that holds a POINTER to a a float64
&: "address of" operator
*: gets the value at an address

package main

import "fmt"

func main() {
    var aValue float64 = 1.23
    var aPointer *float64 = &aValue
    fmt.Println("aPointer:", aPointer) // prints something like "aPointer: 0x1040a128"
    fmt.Println("*aPointer:", *aPointer) // prints "*aPointer: 1.23"
}

There are a couple circumstances where it's better to use a pointer:

Function arguments are pass-by-value: the function always receives a COPY of the value
- So if functions alter the value they receive, they'll be altering the copy, not the original
- But if the function receives a pointer, and alters the value that pointer points to, then the function's changes will still be effective outside the function
For complex values, passing a copy to a function wastes memory.
- Passing a pointer doesn't.

0:00
[SOUND] In Go, most variables hold values directly.
0:07
So if you assign the value 1.23 to a variable.
0:11
Then for all intents and purposes, that's what the variable holds, 1.23.
0:15
But it's also possible to create a pointer to a value.
0:18
Pointers point to a value in memory.
0:21
That is pointers are a value that just gives the address of another value
0:24
elsewhere in memory.
0:26
If you're familiar with object references in CSharp or
0:29
Java, those work almost exactly like pointers.
0:32
And if you already know pointers from C or C++,
0:35
Go pointers work almost exactly the same way.
0:37
Except that you can't alter an existing pointer like you can in C or C++.
0:42
To declare a variable that holds a pointer to a type of value,
0:45
just put a star before the type.
0:46
So var x float64 declares a variable that holds the float64 directly.
0:52
But var x *float64 declares a variable that holds a pointer to a float64.
0:57
The ampersand operator is the address of operator.
1:02
So you can read this as address of a value.
1:05
Basically, this takes the avalue variable and returns the address that holds it.
1:10
And then assigns it to a variable, that holds a flip 64 pointer.
1:15
The star operator is the reverse of the ampersand operator.
1:19
It takes a pointer and gets the value at the address that pointer points to.
1:23
So, if we were to run this.
1:29
First it would take the value 1.23 and store it in the variable A value.
1:35
Then the ampersand address of operator would take the address
1:39
of the A value variable.
1:42
And store it in this A pointer variable that holds a pointer.
1:46
First we print out the pointer and then we print out the value,
1:50
that's at the memory address pointed to by that pointer.
1:53
There are a couple of circumstances where it's better to use
1:56
a pointer than using a value directly.
1:58
The first is functions that need to affect their arguments in some way.
2:02
Function arguments in Go are passed by value,
2:05
function always receives a copy of the value that's being passed in.
2:09
So if a function needs to alter the value that it receives in some way,
2:12
they'll be altering the copy, not the original.
2:15
For example, here we have a halve function that is supposed to cut
2:18
the argument it receives in half.
2:20
So up here, we assign a number to the myNumber variable and
2:24
then we call halve on it.
2:26
Expecting it to cut the number in half from 2.6 down to 1.3.
2:31
It's received down here in the number parameter.
2:34
And we divide number in half, but
2:36
because number contains a copy of 2.6 not the original value?
2:41
Our change is only effective here within the body of the halve function.
2:46
So that's what gets printed out down here, number in half, we see 1.3.
2:51
But then when we get back up to the main function and
2:53
print my number in main, we get 2.6.
2:56
Because the number in my number was completely unaffected by
2:59
the halve function.
3:00
But if we update the halve function to receive a pointer and
3:03
alter the value that that pointer points to,
3:06
then the functions changes will still be effective outside the function.
3:09
So up here in the main function,
3:11
let's instead pass the address of my number to halve.
3:15
Then let's update the have function to take a pointer to a float64 value,
3:20
instead of an actual float64 value.
3:24
We'll take the value to that pointer points to and divide that by half.
3:30
And then update the value at that address.
3:34
And finally, we'll update our print line statement here,
3:37
to reflect the fact that we are working with the value at an address,
3:41
rather than a value directly here in the function.
3:45
Let's save this and try running it again.
3:48
And this time, our number gets updated both within the halve function and
3:53
the changes are still visible outside of it, in the main function.
3:57
We don't pass myNumber itself to that halve function,
4:00
instead we pass the address of myNumber.
4:03
Then we update the value at that address.
4:07
And because we updated the value at that address,
4:10
rather than a copy of that value, those changes are still effective,
4:13
but when we get back up here to the main function.
4:16
The other situation where it may make sense to use pointers instead of
4:19
passing values directly, is when you need to pass a complex value to a function.
4:24
For example, here we're passing a complex struct to the describe function.
4:30
And if we were to pass a copy of that, it would take up a lot of extra memory.
4:34
But if we were to update the function to accept a pointer instead,
4:37
we wouldn't have to worry about passing a copy.
4:40
We'd just pass the memory address of the structure in memory and
4:43
then print that structure out.
4:45
So, for example, if we update the describe function to accept a pointer to a car,
4:51
and update the call, to describe.
4:56
To pass the address of the car variable rather than the car variable value itself.
5:02
It'll still work the same, but
5:03
it wont copy the car value when passing it to the scribe, saving us memory.
5:07
Let's try running this and you'll see that we get the exact same result.
5:12
Those are the basics of how to use pointers in Go.
5:15
It's not very complex, but it may take a little time to get an intuitive grasp of
5:19
situations where you need to use them.
5:21
You'll often find you need to use pointers when calling various functions.
5:24
Either because the function needs to alter the value you're passing to it, or
5:28
because the value is large and would be inefficient to create a copy of.

You need to sign up for Treehouse in order to download course files.

Go Language Overview

Pointers

Sign in