Go - Pointers

---

---

Pointers in Go are easy and fun to learn. Some Go programming tasks are performed more easily with pointers, and other tasks, such as call by reference, cannot be performed without using pointers. So it becomes necessary to learn pointers to become a perfect Go programmer.

As you know, every variable is a memory location and every memory location has its address defined which can be accessed using ampersand (&) operator, which denotes an address in memory. Consider the following example, which will print the address of the variables defined −

package main

import "fmt"

func main() {
   var a int = 10   
   fmt.Printf("Address of a variable: %x\n", &a  )
}

When the above code is compiled and executed, it produces the following result −

Address of a variable: 10328000

So you understood what is memory address and how to access it. Now let us see what pointers are.

What Are Pointers?

A pointer is a variable whose value is the address of another variable, i.e., direct address of the memory location. Like any variable or constant, you must declare a pointer before you can use it to store any variable address. The general form of a pointer variable declaration is −

var var_name *var-type

Here, type is the pointer's base type; it must be a valid C data type and var-name is the name of the pointer variable. The asterisk * you used to declare a pointer is the same asterisk that you use for multiplication. However, in this statement the asterisk is being used to designate a variable as a pointer. Following are the valid pointer declaration −

var ip *int        /* pointer to an integer */
var fp *float32    /* pointer to a float */

The actual data type of the value of all pointers, whether integer, float, or otherwise, is the same, a long hexadecimal number that represents a memory address. The only difference between pointers of different data types is the data type of the variable or constant that the pointer points to.

How to Use Pointers?

There are a few important operations, which we frequently perform with pointers: (a) we define pointer variables, (b) assign the address of a variable to a pointer, and (c) access the value at the address stored in the pointer variable.

All these operations are carried out using the unary operator * that returns the value of the variable located at the address specified by its operand. The following example demonstrates how to perform these operations −

package main
import "fmt"
func main() {
   var a int = 20   /* actual variable declaration */
   var ip *int      /* pointer variable declaration */

   ip = &a  /* store address of a in pointer variable*/
   fmt.Printf("Address of a variable: %x\n", &a  )
   /* address stored in pointer variable */
   fmt.Printf("Address stored in ip variable: %x\n", ip )
   /* access the value using the pointer */
   fmt.Printf("Value of *ip variable: %d\n", *ip )
}

When the above code is compiled and executed, it produces the following result −

Address of var variable: 10328000
Address stored in ip variable: 10328000
Value of *ip variable: 20

Nil Pointers in Go

Go compiler assign a Nil value to a pointer variable in case you do not have exact address to be assigned. This is done at the time of variable declaration. A pointer that is assigned nil is called a nil pointer.

The nil pointer is a constant with a value of zero defined in several standard libraries. Consider the following program −

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("The value of ptr is : %x\n", ptr  )
}

When the above code is compiled and executed, it produces the following result −

The value of ptr is 0

On most of the operating systems, programs are not permitted to access memory at address 0 because that memory is reserved by the operating system. However, the memory address 0 has special significance; it signals that the pointer is not intended to point to an accessible memory location. But by convention, if a pointer contains the nil (zero) value, it is assumed to point to nothing.

if(ptr != nil)     /* succeeds if p is not nil */
if(ptr == nil)    /* succeeds if p is null */

Dereference Pointer in Golang

In Golang, the dereference operator is used to access and manipulate the value stored in the variable pointed to by the pointer. The dereference or indirection operator (*) acts as a unary operator, and it needs a pointer variable as its operand.

The Pointers themselves do not have parameters or return values, but functions that use pointers can have parameters and return values involving pointers.

Syntax

Below is the syntax to dereference a pointer −

*pointer_variable;

Using the above syntax, we can get and update the value of any variable that is being pointed to by the pointer.

How to Dereference a Pointer?

To dereference a pointer, we need to follow the below-given steps:

Step 1: Create a variable and declare a pointer variable.

var x int
var ptr *int

Step 2: Initialize the pointer by assigning the address of the variable.

x = 10
ptr = &x

Step 3: Now, we can dereference the pointer to get or update the value of the variable.

*ptr = 20
fmt.Println(x)
value := *ptr
fmt.Println(value)

Example

In this example, we are demonstrating these three steps to deference a pointer −

package main

import "fmt"

func main() {
   x := 10
   var ptr *int
   
   ptr = &x
   *ptr = 20
   fmt.Printf("Value of x = %d\n", x)
   value := *ptr
   fmt.Printf("Value at the address pointed to by ptr = %d\n", value)
}

Output

Run the code and check its output −

Value of x = 20
Value at the address pointed to by ptr = 20

What is Dereferencing?

The term "dereferencing" refers to accessing the value that is stored in the memory address referred by the pointer. The dereference operator fetches the value of the target variable.

Example

In this example, we use pointers to store the addresses and values of variables and dereferencing pointers to access their values.

package main
import "fmt"

func main() {
   x := 10
   p1 := &x
   y := 10.5
   p2 := &y

   fmt.Printf("Address of 'x': %p, Value of 'x': %d\n", p1, *p1)
   fmt.Printf("Address of 'y': %p, Value of 'y': %f\n", p2, *p2)
}

Output

Run the code and check its output −

Address of 'x': 0xc000110010, Value of 'x': 10
Address of 'y': 0xc000110018, Value of 'y': 10.500000

Manipulating Value by Dereferencing Pointer

The dereference operator allows indirect manipulation of the value of a variable that refers to a pointer.

Example

In this example, we declare an integer variable x and a pointer p that stores the memory address of x. By dereferencing the pointer p, we can access the value of x. So, we can modify the value of x by changing the value stored at the memory address pointed to by p.

package main
import "fmt"

func main() {
   var x int = 64   
   var p *int        
   p = &x          

   fmt.Println("Value of x=", x)
   fmt.Println("Address of x=", &x)
   fmt.Println("Value of p=", p)
   fmt.Println("Dereferenced value of p=", *p)
   *p = 21 
   fmt.Println("New value of x=", x)
}

Output

Following is the output of the above program

Value of x= 64
Address of x= 0xc000124010
Value of p= 0xc000124010
Dereferenced value of p= 64
New value of x= 21

Dereferencing Structure Pointer

In programming, a struct (short for "structure") is a user-defined data type that allows you to group related data together. It is a composite data type that means it can hold multiple values of different data types.

We can define a struct using the type keyword, followed by the name of the struct and the struct keyword.

In Golang, we use the * operator to dereference a pointer to access the struct's fields, or we can use the shorthand notation with the dot operator (.). Unlike C/C++ ,there is no arrow symbol (->) in Go.

Let's have a clear idea how to access struct fields in Golang −

Using the dereference operator −

(*ptr).Name = "Indu"

Using the shorthand notation −

ptr.Name = "Indu"

Example

In this example, we create a pointer to a 'Student' struct instance and prints the student's name and age using both direct pointer access and dereferencing.

package main
import "fmt"

type Student struct {
   name string
   age  int
}

func main() {
   p := &Student{"Indu", 18}
   fmt.Println("Name=", p.name)
   fmt.Println("Age=", (*p).age)
}

Output

Following is the output of the above program

Name= Indu
Age= 18

Dereferencing Pointers in Functions

Dereferencing pointers in functions involves accessing and modifying the value stored at the memory address pointing to a pointer.

When you pass a pointer to a function, the function can dereference the pointer to access and manipulate the actual value stored at that memory address. This allows the function to modify the original variable's value.

Declaring a pointer

var FuncPtr func(parameterType) returnType

Referencing a pointer

FuncPtr = functionName

Calling and dereferencing a pointer

x := FuncPtr(parameter)

Example

package main
import "fmt"

func add(a int, b int) int {
   return a + b
}

func main() {
   var FuncPtr func(int, int) int
   FuncPtr = add
   result := FuncPtr(46, 64)
   fmt.Println("Result=", result)
}

Output

Following is the output of the above program

Result= 110

Go Pointers in Detail

Pointers have many but easy concepts and they are very important to Go programming. The following concepts of pointers should be clear to a Go programmer −