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
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. Sovar x float64declares a variable that holds afloat64directly, butvar x *float64declares a variable that holds a POINTER to a afloat64 -
&: "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.
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
[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 upYou need to sign up for Treehouse in order to set up Workspace
Sign up