Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll

Preview

Start a free Courses trial
to watch this video

Sign up for Treehouse

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.

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.

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

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

Sign up