Pointer behavior in functions in Go - Mini Project: Build & Apply

Pointer behavior in functions

📖 Scenario: Imagine you have a number and you want to change its value inside a function. In Go, you can use pointers to do this. Pointers let you share the address of a variable so the function can change the original value.

🎯 Goal: You will create a Go program that shows how passing a pointer to a function allows the function to change the original variable's value.

📋 What You'll Learn

Create an integer variable called num with the value 10.

Create a function called changeValue that takes a pointer to an integer.

Inside changeValue, change the value pointed to by the pointer to 20.

Call changeValue passing the address of num.

Print the value of num after calling the function.

💡 Why This Matters

🌍 Real World

Pointers are used in Go to efficiently change data without copying it. This is common in programs that manage memory or work with large data.

💼 Career

Understanding pointers is important for Go developers, especially when working on performance-critical applications or systems programming.

1

Create the initial variable

Create an integer variable called num and set it to 10.

Go

package main

import "fmt"

func main() {
    // Create the variable num with value 10
    // Your code here
}

Hint

Use num := 10 to create the variable.

2

Create the function with a pointer parameter

Create a function called changeValue that takes a pointer to an integer named p. Inside the function, set the value pointed to by p to 20.

Go

package main

import "fmt"

func changeValue(p *int) {
    // Change the value pointed to by p to 20
    // Your code here
}

func main() {
    num := 10
}

Hint

Use *p = 20 to change the value at the pointer.

3

Call the function with the pointer

Inside main, call the function changeValue passing the address of num using &num.

Go

package main

import "fmt"

func changeValue(p *int) {
    *p = 20
}

func main() {
    num := 10
    // Call changeValue passing the address of num
    // Your code here
}

Hint

Use changeValue(&num) to pass the pointer.

4

Print the changed value

Add a fmt.Println statement to print the value of num after calling changeValue.

Go

package main

import "fmt"

func changeValue(p *int) {
    *p = 20
}

func main() {
    num := 10
    changeValue(&num)
    // Print the value of num
    // Your code here
}

Hint

Use fmt.Println(num) to print the value.

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