Go - Call by reference

The call by reference method of passing arguments to a function copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. This means that changes made to the parameter affect the passed argument.

To pass the value by reference, argument pointers are passed to the functions just like any other value. Accordingly you need to declare the function parameters as pointer types as in the following function swap(), which exchanges the values of the two integer variables pointed to by its arguments.

Syntax

The function definition for the call by reference argument passing is as follows:

/* function definition to swap the values */
func swap(x *int, y *int) {
   var temp int
   temp = *x    /* save the value at address x */
   *x = *y      /* put y into x */
   *y = temp    /* put temp into y */
}

To learn more about pointers in Go programming, please go through Go - Pointers.

Call by Reference Example

For now, let us call the function swap() by passing values by reference as in the following example −

package main

import "fmt"

func main() {
   /* local variable definition */
   var a int = 100
   var b int = 200

   fmt.Printf("Before swap, value of a : %d\n", a )
   fmt.Printf("Before swap, value of b : %d\n", b )

   /* calling a function to swap the values.
   * &a indicates pointer to a ie. address of variable a and 
   * &b indicates pointer to b ie. address of variable b.
   */
   swap(&a, &b)

   fmt.Printf("After swap, value of a : %d\n", a )
   fmt.Printf("After swap, value of b : %d\n", b )
}
func swap(x *int, y *int) {
   var temp int
   temp = *x    /* save the value at address x */
   *x = *y    /* put y into x */
   *y = temp    /* put temp into y */
}

Put the above code in a single Go file, and then compile and execute it. It produces the following result −

Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :200
After swap, value of b :100

It shows that the change has reflected outside the function as well, unlike call by value where the changes do not reflect outside the function.

Example: Call by Reference with Structs

In this example, we are demonstrating how you can use the call by reference with structs:

package main

import "fmt"

// Struct for student data
type Student struct {
    name  string
    age   int
    grade string
}

// Function to change the student data using a pointer
func changeStudentData(s *Student) {
    s.name = "Prakash Joshi"
    s.age = 21
    s.grade = "B"
    fmt.Println("Student Data Inside changeStudentData():\n", *s)
}

func main() {
    student := Student{name: "Reese Witherspoon", age: 23, grade: "A"}
    fmt.Println("Student data before function call:\n", student)

    // Call by reference
    changeStudentData(&student)

    fmt.Println("Student data after function call:\n", student)
}

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

Student data before function call:
 {Reese Witherspoon 23 A}
Student Data Inside changeStudentData():
 {Prakash Joshi 21 B}
Student data after function call:
 {Prakash Joshi 21 B}

As you can see in the output, that student data is changed after the function call because we are calling the function by reference.