How to declare a pointer?¶

For any given type T, there is an associated type *T for pointers to variables of type T.

Example:

1
2
3
4
5
6
7

var i int
var hello string
var p *int //p is of type *int, so p is a pointer to variables of type int

//we can assign to p the address of i like this:
p = &i //now p points to i (i.e. p stores the address of i
hello_ptr := &hello //hello_ptr is a pointer variable of type *string and it points hello

How to access the value of a pointed-to variable?¶

If Ptr is a pointer to Var then Ptr == &Var. And *Ptr == Var.

In other words: you precede a variable with the & operator to obtain its address (a pointer to it), and you precede a pointer by the * operator to obtain the value of the variable it points to. And this is called: dereferencing.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main
import "fmt"

func main() {
    hello := "Hello, mina-san!"
    //declare a hello_ptr pointer variable to strings
    var hello_ptr *string
    // make it point our hello variable. i.e. assign its address to it
    hello_ptr = &hello
    // and int variable and a pointer to it
    i := 6
    i_ptr := &i //i_ptr is of type *int

    fmt.Println("The string hello is: ", hello)
    fmt.Println("The string pointed to by hello_ptr is: ", *hello_ptr)
    fmt.Println("The value of i is: ", i)
    fmt.Println("The value pointed to by i_ptr is: ", *i_ptr)
}

Output:

And that is all! Pointers are variables that store other variables addresses, and if a variable is of type int, its pointer will be of type *int, if it is of type float32, its pointer is of type *float32 and so on...

Why do we need pointers?¶

Since we can access variables, assign values to them using only their names, one might wonder why and how pointers are useful. This is a very legitimate question, and you’ll see the answer is quite simple.

Suppose that your program as it runs needs some to store some results in some new variables not already declared. How would it do that? You’ll say: I’ll prepare some variables just in case. But wait, what if the number of new variables differs on each execution of your program?

The answer is runtime allocation: your program will allocate some memory to store some data while it is running.

Go has a built-in allocation function called new which allocates exactly the amount of memory required to store a variable of a given type, and after it allocates the memory, it returns a pointer.

You use it like this: new(Type) where Type is the type of the variable you want to use.

Here’s an example to explain the new function.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main
import "fmt"

func main() {
    sum := 0
    var  double_sum *int //a pointer to int
    for i:=0; i<10; i++{
        sum += i
    }
    double_sum = new(int) //allocate memory for an int and make double_sum point to it
    *double_sum = sum*2 //use the allocated memory, by dereferencing double_sum
    fmt.Println("The sum of numbers from 0 to 10 is: ", sum)
    fmt.Println("The double of this sum is: ", *double_sum)
}

Another good reason, that we will see when we will study functions is that passing parameters by reference can be useful in many cases. But that’s a story for another day. Until then, I hope that you have assimilated the notion of pointers, but don’t worry, we will work with them gradually in the next chapters, and you’ll see that the fear some people have about them is unjustified.