Common pointer use cases 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 you to directly access and modify the value stored at that address.

beginner

Why use pointers to modify function arguments in Go?

Using pointers as function arguments allows the function to modify the original variable's value, not just a copy. This is useful for changing data outside the function's scope.

intermediate

How do pointers help with performance in Go?

Pointers avoid copying large data structures by passing their memory address instead. This reduces memory use and speeds up the program.

intermediate

What is the use of pointers with structs in Go?

Pointers to structs let you modify the struct fields directly and efficiently pass large structs without copying all their data.

beginner

How do you declare and use a pointer in Go?

Declare a pointer with * before the type, e.g., var p *int. Use & to get the address of a variable, e.g., p = &x. Use *p to access or change the value at that address.

What does the * operator do when used with a pointer variable in Go?

A Accesses the value stored at the pointer's address

B Declares a new pointer variable

C Gets the address of a variable

D Creates a copy of the variable

The * operator dereferences the pointer, giving access to the value stored at the memory address.

Why might you pass a pointer to a function instead of a value in Go?

A To allow the function to modify the original variable

B To make a copy of the variable

C To prevent the function from changing the variable

D To increase the size of the variable

Passing a pointer lets the function change the original variable by accessing its memory address.

Which of these is a benefit of using pointers with large structs?

A Automatically initializes all fields to zero

B Avoids copying the entire struct, improving performance

C Makes the struct immutable

D Prevents access to struct fields

Pointers let you pass the address of the struct, avoiding expensive copying of large data.

How do you get the memory address of a variable x in Go?

A *x

B x*

C x&

D &x

The & operator returns the memory address of the variable.

What happens if you try to dereference a nil pointer in Go?

A It creates a new variable

B It returns zero value

C The program panics (runtime error)

D It compiles but does nothing

Dereferencing a nil pointer causes a runtime panic because there is no valid memory address.

Explain three common use cases for pointers in Go and why they are useful.

Think about how pointers let you change data and save memory.

Describe how to declare, assign, and use a pointer variable in Go with an example.

Use a simple int variable example.

Practice

1. What does a pointer in Go store?

easy

A. The memory address of a variable

B. The value of a variable

C. The type of a variable

D. The size of a variable

Solution

1. Step 1: Understand what a pointer represents

   A pointer holds the location in memory where a variable is stored, not the value itself.

2. Step 2: Differentiate pointer from value

   The value is stored at the address the pointer points to, not inside the pointer variable.

3. Final Answer:

   The memory address of a variable -> Option A

4. Quick Check:

   Pointers store addresses = B [OK]

Hint: Pointers hold addresses, not values directly [OK]

Common Mistakes:

• Confusing pointer with the actual value
• Thinking pointer stores variable type
• Assuming pointer stores variable size

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

easy

A. var p int*

B. var p &int

C. var p *int

D. var *p int

Solution

1. Step 1: Recall Go pointer syntax

   In Go, a pointer type is written as *Type, so a pointer to int is *int.

2. Step 2: Check variable declaration format

   The variable name comes after var, then the type. So correct is var p *int.

3. Final Answer:

   var p *int -> Option C

4. Quick Check:

   Pointer syntax is var name *Type = D [OK]

Hint: Pointer type uses * before type, not after variable [OK]

Common Mistakes:

• Placing * after variable name
• Using & instead of * for pointer type
• Incorrect order of * and variable name

3. What is the output of this Go code?

func main() {
    x := 10
    p := &x
    *p = 20
    fmt.Println(x)
}

medium

A. 10

B. Memory address of x

C. Compilation error

D. 20

Solution

1. Step 1: Understand pointer assignment

   p points to x's address. Changing *p changes the value at x's address.

2. Step 2: Trace value change

   *p = 20 sets x to 20. So printing x outputs 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   Pointer changes original value = 20 [OK]

Hint: Changing *p changes original variable value [OK]

Common Mistakes:

• Thinking x remains 10 after *p = 20
• Printing pointer address instead of value
• Assuming compilation error due to pointer

4. Identify the error in this Go code snippet:

func updateValue(p *int) {
    *p = 100
}

func main() {
    var p *int
    updateValue(p)
}

medium

A. Syntax error in function declaration

B. p is nil and dereferenced causing runtime panic

C. updateValue should return an int

D. No error, code runs fine

Solution

1. Step 1: Check pointer initialization

   p is declared but not assigned an address, so it is nil.

2. Step 2: Analyze dereferencing nil pointer

   updateValue dereferences *p, causing a runtime panic because p is nil.

3. Final Answer:

   p is nil and dereferenced causing runtime panic -> Option B

4. Quick Check:

   Dereferencing nil pointer causes panic = A [OK]

Hint: Never dereference nil pointers without initialization [OK]

Common Mistakes:

• Assuming nil pointer is safe to dereference
• Thinking function must return a value
• Ignoring runtime panic possibility

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

func swap(a, b *int) {
    *a, *b = *b, *a
}

func main() {
    x, y := 5, 10
    swap(&x, &y)
    fmt.Println(x, y)
}

hard

A. 10 5

B. 5 10

C. Memory addresses of x and y

D. Compilation error due to swap syntax

Solution

1. Step 1: Understand swap function with pointers

   swap receives pointers to x and y, then swaps the values they point to.

2. Step 2: Trace swap effect on variables

   After swap, x becomes 10 and y becomes 5.

3. Final Answer:

   10 5 -> Option A

4. Quick Check:

   Pointer swap changes original values = 10 5 [OK]

Hint: Swap values by swapping *a and *b via pointers [OK]

Common Mistakes:

• Expecting original values unchanged
• Printing pointer addresses instead of values
• Thinking swap function syntax is invalid