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) } Output
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 } Output
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.