Pointers in Go

# CHAPTER 13

Pointers in Go #

1. Introduction #

2. Learning Objectives #

• Understand memory addresses.

• Use the & (Address of) operator.

• Use the * (Dereference) operator.

• Understand Pass-by-Value vs Pass-by-Reference.

• Avoid common pointer mistakes.

3. Memory Addresses and the & Operator #

package main
import "fmt"

func main() {
    age := 25
    
    fmt.Println("Value of age:", age) // Prints 25
    fmt.Println("Memory address of age:", &age) // Prints 0xc000018030
}

4. What is a Pointer? #

func main() {
    age := 25
    
    // ptr is a pointer to an integer
    var ptr *int = &age 
    
    fmt.Println("Pointer stores:", ptr) // Prints 0xc000018030
}

5. Dereferencing (The * Operator) #

func main() {
    age := 25
    ptr := &age 
    
    // Read the value at the address
    fmt.Println("Value at ptr:", *ptr) // Prints 25
    
    // Change the value at the address!
    *ptr = 99 
    
    // age was changed directly!
    fmt.Println("New age:", age) // Prints 99
}

6. Pass by Value vs Pass by Reference #

If you want the function to modify the original variable, you must pass a Pointer (Pass by Reference).

Pass by Value (Does not change original):

func doubleValue(num int) {
    num = num * 2 // Only changes the local copy
}

func main() {
    x := 10
    doubleValue(x)
    fmt.Println(x) // Still prints 10!
}

Pass by Reference (Changes original):

// Expects a memory address (*int)
func doublePointer(num *int) {
    *num = *num * 2 // Modifies the data at the address
}

func main() {
    x := 10
    doublePointer(&x) // Give it the address!
    fmt.Println(x) // Prints 20!
}

7. Pointers with Slices and Maps #

8. Common Mistakes #

• Nil Pointers: If you declare var ptr *int but do not assign it an address, it is nil. If you try to dereference a nil pointer (*ptr = 5), the program will instantly crash (Panic).

• Pointer Arithmetic: In C/C++, you can do ptr++ to jump to the next memory slot. Go strictly forbids pointer arithmetic to prevent massive security vulnerabilities and memory corruption.

9. Best Practices #

• Use pointers when you need a function to modify the original data.

• Use pointers when passing massive Structs (which we will learn next) to prevent the CPU from slowly copying huge amounts of data.

• Do NOT use pointers for basic types (int, bool) unless absolutely necessary. Passing copies of small variables is actually faster than managing pointers.

10. Exercises #

1. 1. Write a function swap(a *int, b *int) that swaps the values of the two variables.

1. 2. In main(), create x := 1 and y := 2. Print them, call swap(&x, &y), and print them again.

11. MCQs with Answers & Explanations #

Q5. How do you pass a variable by reference so the function can modify the original? a) Pass the variable normally b) Pass the memory address using & and accept it as a pointer *type Answer: b) Pass the memory address using & and accept it as a pointer.

Q6. Does Go allow Pointer Arithmetic (e.g., ptr++)? a) Yes b) No Answer: b) No. *Explanation: This prevents memory corruption and keeps Go safe.*

12. Interview Preparation #

1. 1. What is the difference between & and * in Go?

1. 2. Why does Go support pointers but forbid pointer arithmetic? (Answer: To achieve C-like performance without the notorious memory safety vulnerabilities of C/C++).

13. Summary #

14. Next Chapter Recommendation #