Pointer behavior in functions in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a pointer in Go?

A pointer in Go is a variable that stores the memory address of another variable. It allows functions to access and modify the original variable's value directly.

beginner

How does passing a pointer to a function differ from passing a value?

Passing a pointer sends the memory address, so the function can change the original variable. Passing a value sends a copy, so changes inside the function do not affect the original variable.

beginner

What does the * operator do when used with a pointer inside a function?

The * operator dereferences the pointer, meaning it accesses or modifies the value stored at the memory address the pointer holds.

intermediate

Why might you use a pointer parameter in a function?

You use a pointer parameter to allow the function to modify the original variable's value or to avoid copying large data structures for efficiency.

intermediate

What happens if you try to modify a pointer parameter without dereferencing it?

Modifying the pointer itself changes the address it points to, not the value at that address. To change the original value, you must dereference the pointer.

What does passing a pointer to a function allow you to do?

A Create a copy of the variable

B Modify the original variable's value

C Only read the original variable's value

D Prevent any changes to the variable

Passing a pointer allows the function to access and modify the original variable's value directly.

In Go, what does the * operator do when used with a pointer inside a function?

A Deletes the pointer

B Declares a new pointer

C Creates a copy of the pointer

D Dereferences the pointer to access the value

The * operator dereferences the pointer, letting you access or change the value it points to.

If you pass a variable by value to a function, what happens when you modify it inside the function?

A The original variable changes

B The variable becomes a pointer

C Only the copy inside the function changes

D The program crashes

Passing by value sends a copy, so changes inside the function do not affect the original variable.

What is a common reason to use pointers in function parameters?

A To avoid copying large data and allow modification

B To make the code slower

C To hide the variable's value

D To prevent the function from running

Pointers help avoid copying big data and let functions modify the original variable.

What happens if you assign a new value to a pointer parameter without dereferencing it?

A You change the pointer's address it holds

B You change the value the pointer points to

C You change the original variable's value

D You cause a syntax error

Assigning to the pointer itself changes the address it holds, not the value at that address.

Explain how pointers behave when passed to functions in Go and why this is useful.

Think about how memory addresses let functions change variables outside their scope.

Describe the role of the * operator when working with pointers inside functions.

Consider how you get from an address to the actual 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