Why Pointer behavior in functions in Go? - Purpose & Use Cases

The Big Idea

What if your function could change your data instantly, without messy copying or confusion?

The Scenario

Imagine you want to change a value inside a function and see that change outside the function too, like updating a shared shopping list. But if you just pass the value, the function only changes its own copy, not the original list.

The Problem

Manually copying values means every change stays local inside the function. You have to return the new value and remember to assign it back, which is slow and easy to forget. This leads to bugs where your program doesn't update data as expected.

The Solution

Using pointers lets you give the function the address of the original data. The function can then directly change the original value, like handing over the actual shopping list instead of a copy. This makes updates clear, fast, and reliable.

Before vs After

✗ Before

func updateValue(val int) {
    val = 10
}

func main() {
    x := 5
    updateValue(x)
    // x is still 5
}

✓ After

func updateValue(val *int) {
    *val = 10
}

func main() {
    x := 5
    updateValue(&x)
    // x is now 10
}

What It Enables

It enables functions to directly modify original data, making your programs more efficient and easier to manage.

Real Life Example

Think of a function that updates a user's score in a game. Using pointers, the function can change the actual score stored in memory, so the updated score is immediately available everywhere.

Key Takeaways

Passing values copies data, so changes inside functions don't affect originals.

Pointers let functions access and modify original data directly.

This avoids extra copying and keeps data consistent across your program.

Practice

1. What does passing a pointer to a function in Go allow you to do?

easy

A. Automatically convert the variable to a string

B. Create a copy of the variable that cannot be changed

C. Modify the original variable's value inside the function

D. Prevent the function from accessing the variable

Solution

1. Step 1: Understand pointer passing

   Passing a pointer sends the address of the variable, not a copy.

2. Step 2: Effect on original variable

   Inside the function, using the pointer lets you change the original variable's value.

3. Final Answer:

   Modify the original variable's value inside the function -> Option C

4. Quick Check:

   Pointer lets function change original variable [OK]

Hint: Pointers let functions change original variables directly [OK]

Common Mistakes:

• Thinking pointers create copies instead of referencing original
• Confusing pointer with value passing
• Assuming pointers prevent modification

2. Which of the following is the correct way to declare a function that takes a pointer to an int in Go?

easy

A. func updateValue(val *int) {}

B. func updateValue(val int) {}

C. func updateValue(*val int) {}

D. func updateValue(&val int) {}

Solution

1. Step 1: Recall pointer syntax in function parameters

   In Go, a pointer parameter is declared with * before the type, like *int.

2. Step 2: Check each option

   func updateValue(val *int) {} correctly uses *int as the parameter type.

3. Final Answer:

   func updateValue(val *int) {} -> Option A

4. Quick Check:

   Pointer parameter syntax = *type [OK]

Hint: Pointer parameters use * before type, not variable name [OK]

Common Mistakes:

• Placing * before variable name instead of type
• Using & in parameter declaration
• Omitting * for pointer type

3. What will be the output of this Go program?

package main
import "fmt"
func change(val *int) {
    *val = 10
}
func main() {
    x := 5
    change(&x)
    fmt.Println(x)
}

medium

A. 5

B. 10

C. 0

D. Compilation error

Solution

1. Step 1: Understand pointer usage in change function

   The function receives a pointer to x and sets the value at that address to 10.

2. Step 2: Trace main function execution

   x starts as 5, change(&x) updates x to 10, then fmt.Println prints x.

3. Final Answer:

   10 -> Option B

4. Quick Check:

   Pointer lets function update x to 10 [OK]

Hint: Pointer lets function change original variable value [OK]

Common Mistakes:

• Expecting original value 5 to print
• Confusing pointer dereference syntax
• Thinking function works without & operator

4. Identify the error in this Go code snippet:

func update(val *int) {
    val = 20
}

func main() {
    x := 5
    update(&x)
    fmt.Println(x)
}

medium

A. Cannot assign int to pointer variable directly

B. Missing & operator when calling update

C. Function update should return int

D. x is not initialized

Solution

1. Step 1: Analyze assignment inside update function

   val is a pointer to int, but val = 20 tries to assign int to pointer variable, which is invalid.

2. Step 2: Correct way to change value via pointer

   Use *val = 20 to assign 20 to the value pointed by val.

3. Final Answer:

   Cannot assign int to pointer variable directly -> Option A

4. Quick Check:

   Assign to *val, not val [OK]

Hint: Assign to *pointer, not pointer variable itself [OK]

Common Mistakes:

• Assigning value directly to pointer variable
• Forgetting to dereference pointer
• Confusing pointer and value types

5. Given this Go code, what will be the output?

package main
import "fmt"
func swap(a, b *int) {
    *a, *b = *b, *a
}
func main() {
    x, y := 1, 2
    swap(&x, &y)
    fmt.Println(x, y)
}

hard

A. Compilation error

B. 1 2

C. 0 0

D. 2 1

Solution

1. Step 1: Understand swap function behavior

   swap takes pointers to two ints and swaps their values using pointer dereferencing.

2. Step 2: Trace main function execution

   x=1, y=2 initially; swap(&x, &y) swaps values, so x becomes 2 and y becomes 1.

3. Final Answer:

   2 1 -> Option D

4. Quick Check:

   Pointer swap exchanges values correctly [OK]

Hint: Swap values by dereferencing pointers [OK]

Common Mistakes:

• Expecting original order after swap
• Confusing pointer addresses with values
• Not using * to dereference pointers