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