Pointer declaration in Go - Deep Dive

Overview - Pointer declaration

What is it?

A pointer declaration in Go is a way to create a variable that stores the memory address of another variable. Instead of holding a direct value, a pointer holds the location where the value is stored. This allows programs to access and modify data efficiently by referring to its address. Pointers are declared using the * symbol before the type.

Why it matters

Pointers exist to let programs work with data without copying it, saving memory and time. Without pointers, every time you pass data around, the program would make full copies, which can be slow and wasteful. Pointers also enable powerful programming techniques like sharing data between functions and building complex data structures like linked lists.

Where it fits

Before learning pointer declaration, you should understand basic variables and types in Go. After mastering pointers, you can learn about pointer arithmetic, references, and advanced data structures that rely on pointers.

Mental Model

Core Idea

A pointer is a variable that holds the address of another variable, letting you access or change that variable indirectly.

Think of it like...

Think of a pointer like a house address written on a piece of paper. The paper itself doesn't hold the furniture or people inside the house, but it tells you exactly where to find them.

Variable x stores value 42
Pointer p stores address of x

  +-------+       +-------+
  |   x   |       |   p   |
  |  42   |       | 0x123 |
  +-------+       +-------+
      ^               |
      |               v
    memory          points to
    0x123           x's location

Build-Up - 7 Steps

1

Foundation

Understanding basic variables

Concept: Learn what variables are and how they store values in memory.

In Go, a variable is a named storage that holds a value of a specific type. For example, var x int = 10 creates an integer variable x holding the value 10. Variables have memory addresses where their values are stored.

Result

You can store and retrieve values using variables.

Knowing variables and their memory storage is essential before understanding pointers, which deal with these memory addresses.

2

Foundation

Memory addresses and the & operator

Concept: Learn how to find the address of a variable using the & operator.

The & operator in Go returns the memory address of a variable. For example, &x gives the address where x is stored. This address is a unique location in the computer's memory.

Result

You can get the address of any variable using &.

Understanding how to get a variable's address is the first step to working with pointers.

3

Intermediate

Declaring a pointer variable

🤔Before reading on: do you think a pointer variable holds a value or an address? Commit to your answer.

Concept: Learn how to declare a pointer variable that stores the address of another variable.

In Go, you declare a pointer by placing * before the type. For example, var p *int declares p as a pointer to an int. You can assign it the address of an int variable like p = &x.

Result

Pointer p holds the memory address of x, not the value 10 itself.

Knowing how to declare pointers lets you create variables that refer to other variables indirectly.

4

Intermediate

Dereferencing pointers with * operator

🤔Before reading on: do you think *p gives the address stored in p or the value at that address? Commit to your answer.

Concept: Learn how to access or change the value a pointer points to by dereferencing it.

Using * before a pointer variable accesses the value at the stored address. For example, *p gives the value of x if p points to x. You can also assign *p = 20 to change x's value through p.

Result

Dereferencing lets you read or modify the original variable via its pointer.

Understanding dereferencing is key to using pointers effectively to manipulate data indirectly.

5

Intermediate

Pointer zero value and nil

Concept: Learn about the default value of pointers and the nil pointer.

A pointer that is not assigned an address has the zero value nil, meaning it points to nothing. Using a nil pointer causes runtime errors if dereferenced. Always check if a pointer is nil before using it.

Result

You avoid crashes by handling nil pointers safely.

Knowing about nil pointers helps prevent common bugs and crashes in programs.

6

Advanced

Pointers and function parameters

🤔Before reading on: do you think passing a pointer to a function copies the data or shares the original? Commit to your answer.

Concept: Learn how pointers allow functions to modify variables outside their scope.

When you pass a pointer to a function, the function receives the address, not a copy of the value. This means the function can change the original variable by dereferencing the pointer.

Result

Functions can modify variables directly, enabling efficient data updates.

Understanding this prevents confusion about why some function calls change variables and others don't.

7

Expert

Pointer internals and memory safety

🤔Before reading on: do you think Go allows pointer arithmetic like C? Commit to your answer.

Concept: Learn how Go manages pointers internally and enforces safety by disallowing pointer arithmetic.

Go pointers store memory addresses but do not support arithmetic (like adding numbers to pointers). This design prevents unsafe memory access and bugs common in languages like C. The Go runtime also tracks pointers for garbage collection.

Result

Go programs are safer and less prone to memory errors while still using pointers.

Knowing Go's pointer safety design helps write robust programs and understand language tradeoffs.

Under the Hood

Pointers in Go are variables that store memory addresses. When you declare a pointer, the program allocates space to hold an address. The & operator fetches the address of a variable, and the * operator accesses the value at that address. Internally, Go uses these addresses to read or write memory directly. The runtime tracks pointers to manage memory safely and perform garbage collection.

Why designed this way?

Go was designed to be safe and simple. Allowing pointers without arithmetic avoids many bugs common in lower-level languages. The design balances performance and safety by enabling direct memory access while preventing unsafe operations. This helps developers write efficient code without risking memory corruption.

 +-----------------+       +-----------------+
 |   Variable x    |       |   Pointer p     |
 |  Value: 42      |       |  Value: 0x123   |
 +-----------------+       +-----------------+
          ^                         |
          |                         v
      Memory address 0x123  ---->  Points to x's value

Operations:
 &x  -> get address 0x123
 *p  -> get value 42 at address 0x123

Myth Busters - 4 Common Misconceptions

Quick: Does declaring a pointer variable allocate memory for the value it points to? Commit yes or no.

Common Belief: Declaring a pointer variable creates space for the actual value it will point to.

Reality: Declaring a pointer only allocates space for the address, not the value itself. The value must exist separately.

Why it matters: Assuming the value exists can cause runtime errors when dereferencing uninitialized pointers.

Quick: Can you perform arithmetic like adding 1 to a pointer in Go? Commit yes or no.

Common Belief: You can do pointer arithmetic in Go just like in C or C++.

Reality: Go does not allow pointer arithmetic to keep memory access safe and predictable.

Why it matters: Trying pointer arithmetic leads to compile errors and misunderstanding Go's safety model.

Quick: Does passing a pointer to a function copy the data it points to? Commit yes or no.

Common Belief: Passing a pointer to a function copies the data the pointer points to.

Reality: Passing a pointer copies only the address, so the function accesses the original data.

Why it matters: Misunderstanding this causes confusion about why changes inside functions affect original variables.

Quick: Is a nil pointer safe to dereference? Commit yes or no.

Common Belief: A nil pointer can be dereferenced safely and just returns zero values.

Reality: Dereferencing a nil pointer causes a runtime panic (crash).

Why it matters: Ignoring nil checks leads to program crashes and unstable behavior.

Expert Zone

1

Pointers in Go are strongly typed, meaning a *int pointer cannot point to a string variable, preventing type errors.

2

The Go runtime uses pointers to track live objects for garbage collection, so pointers influence memory management.

3

Using pointers to structs allows efficient updates without copying large data, but requires careful handling to avoid nil dereferences.

When NOT to use

Avoid pointers when you only need to read data without modification, as copying small values is simpler and safer. For complex shared state, consider channels or sync primitives instead of raw pointers to avoid race conditions.

Production Patterns

In real-world Go code, pointers are used to modify structs in functions, implement linked data structures, and optimize performance by avoiding copies. They are also common in interfaces and methods to allow mutation of receiver objects.

Connections

References in C++

Pointers in Go and references in C++ both allow indirect access to variables but differ in syntax and safety.

Understanding Go pointers helps grasp how C++ references work and why Go chooses explicit pointer syntax for clarity.

Memory addresses in computer architecture

Pointers directly represent memory addresses, linking programming concepts to hardware memory layout.

Knowing how pointers map to physical memory deepens understanding of how programs interact with hardware.

Human navigation with maps

Pointers are like map coordinates that guide you to a location without carrying the location's contents.

This connection shows how indirect references simplify complex navigation, similar to how pointers simplify data access.

Common Pitfalls

#1 Dereferencing a nil pointer causing a crash.

Wrong approach:

var p *int
fmt.Println(*p) // dereferencing nil pointer

Correct approach:

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

Root cause:

Not checking if a pointer is nil before dereferencing leads to runtime panics.

#2 Confusing pointer declaration with value declaration.

Wrong approach:

var p int = &x // wrong: assigning address to int variable

Correct approach:

var p *int = &x // correct: p is pointer to int

Root cause:

Misunderstanding that pointers require * before the type to hold addresses.

#3 Expecting pointer arithmetic to work in Go.

Wrong approach:

p = p + 1 // invalid: Go does not support pointer arithmetic

Correct approach:

// Instead, use slices or arrays for indexed access

Root cause:

Assuming Go pointers behave like C pointers causes compile errors and confusion.

Key Takeaways

Pointers store memory addresses, not the actual data values.

The & operator gets a variable's address; the * operator accesses the value at that address.

Dereferencing nil pointers causes runtime errors, so always check for nil before use.

Go disallows pointer arithmetic to keep programs safe and predictable.

Passing pointers to functions allows modifying original variables efficiently.