Go - Call by value

The call by value method of passing arguments to a function copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument.

By default, Go programming language uses call by value method to pass arguments. In general, this means that code within a function cannot alter the arguments used to call the function. Consider the function swap() definition as follows.

Syntax

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

/* function definition to swap the values */
func swap(int x, int y) int {
   var temp int

   temp = x /* save the value of x */
   x = y    /* put y into x */
   y = temp /* put temp into y */

   return temp;
}

Call by Value Example

Now, let us call the function swap() by passing actual values 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 */
   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, y int) int {
   var temp int

   temp = x /* save the value of x */
   x = y    /* put y into x */
   y = temp /* put temp into y */

   return temp;
}

Put the above code in a single go file, and then compile and execute it. It will produce the following result −

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

It shows that there is no change in the values though they had been changed inside the function.

Example: Call by Value with Structs

In this example, we are demonstrating how you can use the call by value 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
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 value
    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:
 {Reese Witherspoon 23 A}

As you can see in the output, that student data is not changed after the function call because we are calling the function by value. If you want to update the data on a function call, you must use the call by reference technique; you can read it in detail in the next chapter (Call by reference in Go language).