08. Pointers in Go

What we will learn in this post?

• 👉 Understanding Pointers
• 👉 Pointers vs Values
• 👉 Pointer to Structs
• 👉 Pointers as Function Arguments
• 👉 Pointer Safety in Go
• 👉 Conclusion!

Understanding Pointers in Go 📍

Go pointers are like signposts ➡️ that hold the memory address of a variable, not the actual value. Think of it this way: your house has an address; the pointer is the address, while your house is the variable’s value.

Address-Of and Dereference 🔍

• The & (address-of) operator gives you the memory address of a variable.

  num := 42
  ptr := &num // ptr now holds the memory address of num
  

• The * (dereference) operator lets you access the value stored at the address a pointer holds.

  fmt.Println(*ptr) // Prints 42 - the value at the address ptr points to
  

Declaring and Using Pointers 📝

Pointers are declared using * followed by the variable’s type. Here’s a simple example:

package main

import "fmt"

func main() {
    num := 10
    var ptr *int // Declare a pointer to an integer
    ptr = &num   // Assign the address of num to ptr

    fmt.Println("Value of num:", num)       // Output: Value of num: 10
    fmt.Println("Address of num:", &num)    // Output: Address of num: 0x...
    fmt.Println("Value of ptr:", ptr)        // Output: Value of ptr: 0x... (same as address of num)
    fmt.Println("Value at ptr:", *ptr)      // Output: Value at ptr: 10 (dereferencing)

    *ptr = 20 // Change the value at the address ptr points to

    fmt.Println("New value of num:", num)   // Output: New value of num: 20 (num is changed!)
}

By changing the value through the pointer *ptr = 20, you’re directly modifying the original variable num.

For further exploration on pointers, you can refer to the Go documentation on pointers and Effective Go.

Pointers vs. Values in Go: A Friendly Guide 📍

When deciding between pointers and values in Go, think about these factors:

Performance: Avoiding Copying Big Stuff 🏋️‍♀️

• Using a value copies the data. For large structs, this copy can be slow. Pointers are just addresses; they’re much faster to pass around.

Mutability: Changing Things 🛠️

• Values create immutable snapshots. Changing a value inside a function won’t affect the original.
• Pointers allow you to directly modify the original data.

Nil Pointers: Watch Out! ⚠️

• A pointer can be nil, meaning it doesn’t point to anything. Trying to use a nil pointer will cause a panic!

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func modifyValue(p Person) {
    p.Age = 30 // This won't affect the original person
}

func modifyPointer(p *Person) {
    p.Age = 30 // This *will* affect the original person
}

func main() {
    person1 := Person{Name: "Alice", Age: 25}
    modifyValue(person1)
    fmt.Println(person1) // Output: {Alice 25}

    person2 := Person{Name: "Bob", Age: 20}
    modifyPointer(&person2)
    fmt.Println(person2) // Output: {Bob 30}

    var person3 *Person
    //fmt.Println(person3.Name) // This would panic! (Nil pointer dereference)
  if person3 != nil{
   fmt.Println(person3.Name)
  }
}

Example: person1’s age didn’t change with modifyValue. person2’s age did change with modifyPointer.

• Use pointers when you want to modify the original data, or when dealing with large structs for performance. Otherwise, values are often simpler and safer.

Resource Links:

• Go Pointers Tutorial
• Effective Go - Pointers vs Values

Pointers to Structs in Go 🚀

Let’s explore how to use pointers with structs in Go!

Understanding Struct Pointers

A pointer to a struct holds the memory address of a struct variable. This is useful for efficiently modifying the original struct and avoiding unnecessary copying.

• To get a pointer to a struct, use the & operator: p := &myStruct.
• To dereference a pointer, use the * operator. However, Go provides automatic dereferencing for struct fields, making it easier.

Automatic Dereferencing ✨

Go simplifies working with struct pointers. Instead of (*p).field, you can directly use p.field to access a field of the struct pointed to by p. Go automatically dereferences the pointer.

type Person struct {
    Name string
    Age  int
}

func main() {
    person := Person{Name: "Alice", Age: 30}
    ptr := &person

    // Both access the Name field
    println(ptr.Name)   // Easier
    println((*ptr).Name) // Equivalent, but less readable
}

new() for Memory Allocation 🧠

The new() function allocates zeroed memory for a new value of a given type and returns a pointer to that value. It’s useful for creating empty structs.

personPtr := new(Person) // Returns *Person with all fields zeroed
personPtr.Name = "Bob"
personPtr.Age = 25

println(personPtr.Name)

Common Struct Pointer Patterns 🎨

• Modifying Structs: Passing a struct pointer to a function allows the function to modify the original struct.

func updateAge(p *Person, newAge int) {
    p.Age = newAge // Modifies the original Person struct
}

• Large Structs: Using pointers can be more efficient when dealing with large structs, as you avoid copying the entire struct.

• Methods on Structs: Methods that need to modify the struct’s state should use pointer receivers. More Info about method receivers

func (p *Person) CelebrateBirthday() {
    p.Age++ // Increment the original struct's Age
}

graph LR
    S_DECL["Create Struct Instance"]:::javaStyle --> S_PTR["Get Pointer using &"]:::jdbcStyle
    S_PTR --> S_ACCESS["Use Pointer to Access Fields"]:::driverStyle
    S_ACCESS --> S_DEREF["Automatic Dereferencing (p.field)"]:::useStyle
    S_PTR --> S_NEW["Use new() to Allocate Zeroed Memory"]:::driverStyle
    S_NEW --> S_ACCESS

    classDef javaStyle fill:#ff4f81,stroke:#c43e3e,color:#fff,font-size:16px,stroke-width:3px,rx:14,shadow:6px;
    classDef jdbcStyle fill:#6b5bff,stroke:#4a3f6b,color:#fff,font-size:16px,stroke-width:3px,rx:14,shadow:6px;
    classDef driverStyle fill:#ffd700,stroke:#d99120,color:#222,font-size:16px,stroke-width:3px,rx:14,shadow:6px;
    classDef useStyle fill:#ff9800,stroke:#f57c00,color:#fff,font-size:16px,stroke-width:3px,rx:14,shadow:6px;

    class S_DECL javaStyle;
    class S_PTR jdbcStyle;
    class S_ACCESS driverStyle;
    class S_DEREF useStyle;
    class S_NEW driverStyle;

    linkStyle default stroke:#e67e22,stroke-width:3px;

Passing Pointers to Functions ➡️ 🛠️

Passing pointers is a smart way for functions to change data outside their own scope and to avoid making copies of large data structures (like structs). Let’s break it down:

Value vs. Pointer Parameters 🤔

• Value Parameters: The function receives a copy of the data. Any changes inside the function won’t affect the original data in the calling code.
• Pointer Parameters: The function receives the memory address (pointer) of the data. Using pointers, the function can directly modify the original data.

Modifying Caller’s Data with Pointers 📝

Here’s an example in (pseudo-code):

struct Person {
  string name;
  int age;
};

void incrementAge(Person* p) { // Takes a pointer to a Person
  p->age = p->age + 1;       // Directly modifies the age of the original Person!
}

int main() {
  Person myPerson = {"Alice", 30};
  incrementAge(&myPerson);  // Pass the *address* of myPerson
  // myPerson.age is now 31!
}

Using * (dereference operator) we can get the value in the memory address that p is pointing to.

Advantages:

• Saves memory (no copying).
• Enables functions to directly alter data owned by the caller.

Go’s Safety Net for Pointers 🛡️

Go helps prevent nasty pointer problems in a few clever ways.

No Pointer Arithmetic ➕➖

Unlike C/C++, Go doesn’t allow you to add or subtract from pointer addresses. This stops you from accidentally wandering around memory and messing things up. Go encourages using slices instead.

Dangling Pointer Prevention 🔗✂️

Go’s garbage collector (GC) automatically manages memory. When a piece of memory is no longer being used by your program, the GC swoops in and cleans it up. This avoids dangling pointers, which are pointers that point to memory that has already been freed.

graph LR
    GC_MEM["Program Memory"]:::javaStyle --> GC_OBJ["Object in Use?"]:::jdbcStyle
    GC_OBJ -- Yes --> GC_KEEP["Keep Object"]:::driverStyle
    GC_OBJ -- No --> GC_FREE["Garbage Collector Frees Memory"]:::useStyle
    GC_PTR["Pointer to Freed Memory"]:::driverStyle --> GC_FREE
    GC_FREE --> GC_DANGLING["Dangling Pointer Eliminated"]:::javaStyle

    classDef javaStyle fill:#ff4f81,stroke:#c43e3e,color:#fff,font-size:16px,stroke-width:3px,rx:14,shadow:6px;
    classDef jdbcStyle fill:#6b5bff,stroke:#4a3f6b,color:#fff,font-size:16px,stroke-width:3px,rx:14,shadow:6px;
    classDef driverStyle fill:#ffd700,stroke:#d99120,color:#222,font-size:16px,stroke-width:3px,rx:14,shadow:6px;
    classDef useStyle fill:#ff9800,stroke:#f57c00,color:#fff,font-size:16px,stroke-width:3px,rx:14,shadow:6px;

    class GC_MEM javaStyle;
    class GC_OBJ jdbcStyle;
    class GC_KEEP driverStyle;
    class GC_FREE useStyle;
    class GC_PTR driverStyle;
    class GC_DANGLING javaStyle;

    linkStyle default stroke:#e67e22,stroke-width:3px;

Nil Pointer Checks 🤔

Go requires you to check if a pointer is nil before you use it. nil means the pointer isn’t pointing to anything.

Dereferencing Nil Pointer 💥

If you try to access the value of a nil pointer (dereferencing), your program will panic. A panic is Go’s way of saying “Uh oh, something went terribly wrong!”. This prevents you from unknowingly working with invalid data.

var ptr *int
*ptr = 10 // This will cause a panic!

Here’s a visual to showcase the panic flow:

graph LR
    NIL_PTR["Pointer is Nil"]:::javaStyle --> NIL_ATTEMPT["Dereference Attempted?"]:::jdbcStyle
    NIL_ATTEMPT -- Yes --> NIL_PANIC["Panic!"]:::driverStyle
    NIL_PANIC --> NIL_CRASH["Program Crashes (or recovers using `recover` function)"]:::useStyle
    NIL_ATTEMPT -- No --> NIL_SAFE["Continue Execution Safely"]:::driverStyle

    classDef javaStyle fill:#ff4f81,stroke:#c43e3e,color:#fff,font-size:16px,stroke-width:3px,rx:14,shadow:6px;
    classDef jdbcStyle fill:#6b5bff,stroke:#4a3f6b,color:#fff,font-size:16px,stroke-width:3px,rx:14,shadow:6px;
    classDef driverStyle fill:#ffd700,stroke:#d99120,color:#222,font-size:16px,stroke-width:3px,rx:14,shadow:6px;
    classDef useStyle fill:#ff9800,stroke:#f57c00,color:#fff,font-size:16px,stroke-width:3px,rx:14,shadow:6px;

    class NIL_PTR javaStyle;
    class NIL_ATTEMPT jdbcStyle;
    class NIL_PANIC driverStyle;
    class NIL_CRASH useStyle;
    class NIL_SAFE driverStyle;

    linkStyle default stroke:#e67e22,stroke-width:3px;

These features make Go a much safer language to use when dealing with pointers, reducing the risk of common memory-related bugs. Resources to find out more:

• Go Pointers
• Garbage Collection in Go

Conclusion

So, what do you think? 🤔 Did anything in this post spark an idea or question for you? I’d love to hear your thoughts! Leave a comment below and let’s chat! 👇 Your feedback helps me make this blog even better! 😊