Go Pointers and Functions

Go pointers store the memory addresses of variables. And just like regular variables, we can also pass pointers to functions.

Before you learn how to use pointers with functions, make sure to know about

Pointer as Function Argument in Golang

In Go, we can pass pointers as arguments to a function. For example,

// Program to pass pointer as a function argument

package main
import "fmt"
// function definition with a pointer argument func update(num *int) {
// dereference the pointer *num = 30 } func main() { var number = 55
// function call update(&number)
fmt.Println("The number is", number) }


The number is 30

In the above example, we have passed the address of number to the update() function. The pointer num accepts this argument in the function definition.

func update(num *int) {

When we change *num to 30 inside the update() function, the value of number inside the main() function is also changed.

This is because num and number are referring to the same address in the memory. So, updating one updates the other as well.

Return Pointers From Function

Just like regular variables, we can also return pointers from a function. For example,

// Program to return a pointer from a function

package main
import "fmt"
func main() {

  // function call
  result := display() 
  fmt.Println("Welcome to", *result)


func display() *string { message := "Programiz" // returns the address of message return &message }


Welcome to Programiz

In the above example, we have created a function named display() that returns a pointer.

func display() *string

Here, *string indicates that the function returns a pointer of string type.

Notice the return &message statement in the display() function:

func display() *string {
  return &message

This indicates that the function returns the address of the message variable to the main() function.

The returned address is assigned to the result pointer. To get the value stored in the memory address, we have used the code *result.

Call By Reference

While passing pointers to a function, we are actually passing a reference (address) of the variable. Instead of working with the actual value, we are working with references like

  • accessing value using reference
  • changing value using reference

That's why this process of calling a function with pointers is called call by reference in Go.

Let's see an example.

// Program to illustrate call by reference

package main
import "fmt"

// call by value
func callByValue(num int) {

  num = 30
  fmt.Println( num) // 30


// call by reference
func callByReference(num *int) {
  *num = 10
  fmt.Println(*num) // 10


func main() {
  var number int

// passing value callByValue(number) // passing a reference (address) callByReference(&number)

Here, we have created two functions: callByValue() and callByReference().

In the callByValue() function, we are directly passing the number variable. Whereas in callByReference(), we are passing the memory address of number.

Did you find this article helpful?