Common pointer use cases in Go

Introduction

Pointers let you work with the exact place where data is stored. This helps you change data directly and use memory smartly.

When you want to change a variable inside a function and keep the change outside.

When you want to save memory by not copying large data structures.

When you want to share data between parts of your program safely.

When you need to work with linked data like linked lists or trees.

When you want to check if a variable has a value or is empty (nil).

Syntax

Go

var p *int       // p is a pointer to an int
p = &x           // p gets the address of x
fmt.Println(*p)   // prints the value at the address p points to

The * before a type means 'pointer to that type'.

The & operator gets the address of a variable.

Examples

Here, p points to x. Using *p gets the value of x.

Go

var x int = 10
var p *int = &x
fmt.Println(*p)  // prints 10

Passing a pointer to a function lets the function change the original variable.

Go

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

func main() {
    x := 10
    changeValue(&x)
    fmt.Println(x)  // prints 20
}

You can check if a pointer is nil to see if it points to something or not.

Go

var p *int
if p == nil {
    fmt.Println("p is nil")
}

Sample Program

This program shows how passing a pointer to a function lets it change the original variable.

Go

package main

import "fmt"

func updateNumber(num *int) {
    *num = *num + 5
}

func main() {
    number := 10
    fmt.Println("Before:", number)
    updateNumber(&number)
    fmt.Println("After:", number)
}

Important Notes

Always be careful when using pointers to avoid changing data by mistake.

Using pointers can make your program faster by avoiding copying big data.

Nil pointers mean 'no value' or 'no address' and should be checked before use.

Summary

Pointers hold the address of variables, letting you access or change the original data.

Use pointers to modify variables inside functions or to save memory.

Always check for nil pointers to avoid errors.

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