Pointers are one of the most important concepts to understand in Go because they allow you to work directly with the memory address of a value.

At first, pointers can look confusing because they use symbols such as & and *. But once you understand what these symbols mean, pointers become much easier.

In simple terms:

• A normal variable stores a value.
• A pointer stores the memory address of another variable.

For example:

age := 24

Here, age stores the value 24.

Now:

ptr := &age

ptr stores the memory address of age.

In this guide, you will learn what pointers are in Go, how to create them, how & and * work, how to modify values through pointers, how pointers behave with functions and structs, and when you should use them.

---

What Is a Pointer in Go?

A pointer is a variable that stores the memory address of another variable.

Consider this code:

age := 24

The variable age contains the value:

24

But internally, Go stores this value somewhere in memory.

That memory location has an address.

You can get that address using the & operator:

fmt.Println(&age)

The output may look something like:

0xc000014098

The exact address can be different every time your program runs.

A pointer can store this address:

ptr := &age

Now:

fmt.Println(ptr)

prints the address stored in ptr.

---

Why Are Pointers Used in Go?

Pointers are mainly useful when you want to work with the original value instead of a copy.

They are commonly used for:

• Modifying variables inside functions
• Working with structs
• Avoiding unnecessary copying of large values
• Sharing access to the same data
• Representing optional values with nil
• Building efficient programs

The most common beginner use case is modifying the original value inside a function.

---

The & Operator in Go

The & symbol is called the address-of operator.

It gives you the memory address of a variable.

Example:

package main

import "fmt"

func main() {
    age := 24

    fmt.Println(age)
    fmt.Println(&age)
}

Possible output:

24
0xc000012120

The first line is the value.

The second line is the memory address.

You can store that address:

ptr := &age

---

The * Operator in Go

The * symbol is used in two important ways.

First, it can define a pointer type.

var ptr *int

This means:

ptr is a pointer to an int

Second, * can be used to access the value stored at a memory address.

This is called dereferencing.

Example:

package main

import "fmt"

func main() {
    age := 24
    ptr := &age

    fmt.Println(age)
    fmt.Println(ptr)
    fmt.Println(*ptr)
}

Possible output:

24
0xc000012120
24

Here:

*ptr

means:

Give me the value stored at the memory address inside ptr.

Since ptr points to age, *ptr returns 24.

---

Simple Pointer Example

Let’s look at the complete flow.

package main

import "fmt"

func main() {
    number := 100

    pointer := &number

    fmt.Println("Value:", number)
    fmt.Println("Address:", pointer)
    fmt.Println("Value through pointer:", *pointer)
}

Possible output:

Value: 100
Address: 0xc000012120
Value through pointer: 100

The important relationship is:

number       → stores 100
&number      → address of number
pointer      → stores address of number
*pointer     → gives value at that address

---

Modifying a Value Using a Pointer

Pointers can be used to change the original value.

Example:

package main

import "fmt"

func main() {
    number := 10

    ptr := &number

    *ptr = 50

    fmt.Println(number)
}

Output:

50

Why did number change?

Because:

*ptr = 50

changes the value stored at the address where ptr points.

Since ptr points to number, the original variable changes.

---

Pointers and Functions

Pointers become especially useful when working with functions.

By default, Go passes arguments by value.

That means a function receives a copy.

Example:

package main

import "fmt"

func update(number int) {
    number = 100
}

func main() {
    number := 10

    update(number)

    fmt.Println(number)
}

Output:

10

The original value does not change.

Why?

Because the update() function changes only its local copy.

---

Modifying Original Values with Pointer Parameters

To modify the original value, pass its address.

Example:

package main

import "fmt"

func update(number *int) {
    *number = 100
}

func main() {
    number := 10

    update(&number)

    fmt.Println(number)
}

Output:

100

Here:

func update(number *int)

means the function accepts a pointer to an integer.

And:

update(&number)

passes the address of number.

Inside the function:

*number = 100

changes the original value.

---

Pointer vs Normal Function Parameter

Without a pointer:

func updateAge(age int) {
    age = 30
}

The original value does not change.

With a pointer:

func updateAge(age *int) {
    *age = 30
}

The original value changes.

This is one of the easiest ways to understand why pointers are useful.

---

Declaring Pointer Variables

You can declare a pointer explicitly.

Example:

var ptr *int

This means ptr can store the address of an integer.

Example:

package main

import "fmt"

func main() {
    var ptr *int

    number := 50

    ptr = &number

    fmt.Println(*ptr)
}

Output:

50

---

Zero Value of a Pointer

The zero value of a pointer is:

nil

Example:

package main

import "fmt"

func main() {
    var ptr *int

    fmt.Println(ptr)
}

Output:

<nil>

A nil pointer does not point to a valid value.

---

Checking for nil Pointers

Before dereferencing a pointer that may be nil, check it.

Example:

package main

import "fmt"

func main() {
    var ptr *int

    if ptr == nil {
        fmt.Println("Pointer is nil")
    }
}

Output:

Pointer is nil

---

Dereferencing a nil Pointer

This is unsafe:

var ptr *int

fmt.Println(*ptr)

Because ptr does not point to a valid value.

Trying to dereference a nil pointer causes a runtime panic.

So if a pointer may be nil, always check it first.

---

Creating Pointers with new()

Go also provides the built-in new() function.

Example:

ptr := new(int)

This creates an integer value initialized to its zero value and returns a pointer to it.

Example:

package main

import "fmt"

func main() {
    ptr := new(int)

    fmt.Println(*ptr)

    *ptr = 25

    fmt.Println(*ptr)
}

Output:

0
25

Since the zero value of int is 0, *ptr initially returns 0.

For beginners, using &variable is usually easier to understand than new().

---

Pointers with Strings

Pointers can point to strings too.

Example:

package main

import "fmt"

func main() {
    name := "Go"

    ptr := &name

    fmt.Println(*ptr)

    *ptr = "Golang"

    fmt.Println(name)
}

Output:

Go
Golang

---

Pointers with Booleans

Example:

package main

import "fmt"

func main() {
    active := false

    ptr := &active

    *ptr = true

    fmt.Println(active)
}

Output:

true

Pointers can point to many different Go types.

---

Pointers and Structs

Pointers are very commonly used with structs.

Suppose you have:

type User struct {
    Name string
    Age  int
}

Create a struct:

user := User{
    Name: "Ankit",
    Age:  24,
}

Now create a pointer:

ptr := &user

You can access struct fields through the pointer.

fmt.Println(ptr.Name)

Go automatically handles the dereferencing for struct fields.

You do not normally need to write:

(*ptr).Name

Both represent the same field access, but:

ptr.Name

is cleaner.

---

Modifying Struct Fields Through a Pointer

Example:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func main() {
    user := User{
        Name: "Ankit",
        Age:  24,
    }

    ptr := &user

    ptr.Age = 30

    fmt.Println(user.Age)
}

Output:

30

The original struct changes because the pointer refers to it.

---

Passing Struct Pointers to Functions

A common Go pattern is passing structs by pointer.

Example:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func updateUser(user *User) {
    user.Age = 30
}

func main() {
    user := User{
        Name: "Ankit",
        Age:  24,
    }

    updateUser(&user)

    fmt.Println(user.Age)
}

Output:

30

This is very common when a function needs to modify a struct.

---

Pointer Receivers in Methods

Pointers are also commonly used with struct methods.

Example:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func (u *User) updateAge(age int) {
    u.Age = age
}

func main() {
    user := User{
        Name: "Ankit",
        Age:  24,
    }

    user.updateAge(30)

    fmt.Println(user.Age)
}

Output:

30

The method uses:

func (u *User) updateAge(age int)

This is called a pointer receiver.

It allows the method to modify the original User.

---

Value Receiver vs Pointer Receiver

A value receiver receives a copy:

func (u User) updateAge(age int) {
    u.Age = age
}

The original struct will not be changed.

A pointer receiver:

func (u *User) updateAge(age int) {
    u.Age = age
}

can modify the original struct.

Use a pointer receiver when the method needs to change the receiver.

---

Pointers and Arrays

Pointers can also point to arrays.

Example:

package main

import "fmt"

func main() {
    numbers := [3]int{10, 20, 30}

    ptr := &numbers

    ptr[0] = 100

    fmt.Println(numbers)
}

Output:

[100 20 30]

The array changes because ptr points to the original array.

---

Do You Need Pointers for Slices?

Slices already behave differently from basic values.

For example:

package main

import "fmt"

func update(numbers []int) {
    numbers[0] = 100
}

func main() {
    numbers := []int{10, 20, 30}

    update(numbers)

    fmt.Println(numbers)
}

Output:

[100 20 30]

You usually do not need to pass a pointer to a slice just to modify its existing elements.

This is because a slice contains information that refers to underlying array data.

However, there are cases where a pointer to a slice may be used, such as when a function must replace the slice itself.

For beginners, it is enough to remember that slices usually do not need pointer parameters for normal element updates.

---

Do You Need Pointers for Maps?

Maps also refer to underlying data.

Example:

package main

import "fmt"

func update(data map[string]int) {
    data["Go"] = 100
}

func main() {
    data := map[string]int{
        "Go": 50,
    }

    update(data)

    fmt.Println(data["Go"])
}

Output:

100

You generally do not need *map[...]... just to update entries in a map.

---

Pointer to Pointer

A pointer can also point to another pointer.

Example:

package main

import "fmt"

func main() {
    number := 100

    ptr := &number

    ptr2 := &ptr

    fmt.Println(number)
    fmt.Println(*ptr)
    fmt.Println(**ptr2)
}

Output:

100
100
100

Here:

number → value
ptr    → address of number
ptr2   → address of ptr

And:

**ptr2

eventually accesses the original value.

Pointer-to-pointer patterns are less common for beginners, so you do not need to use them frequently when starting with Go.

---

Comparing Pointers

Pointers can be compared using ==.

Example:

package main

import "fmt"

func main() {
    number := 10

    ptr1 := &number
    ptr2 := &number

    fmt.Println(ptr1 == ptr2)
}

Output:

true

Both pointers contain the same address.

Now:

a := 10
b := 10

ptr1 := &a
ptr2 := &b

fmt.Println(ptr1 == ptr2)

will typically output:

false

Even though a and b contain equal values, they are different variables with different addresses.

---

Pointer Value vs Pointer Address

This is an important difference.

Suppose:

number := 50
ptr := &number

Then:

fmt.Println(ptr)

prints the memory address.

While:

fmt.Println(*ptr)

prints the value.

So:

ptr  → address
*ptr → value at that address

---

Practical Example: Swap Two Values

Pointers are useful when a function needs to modify multiple original values.

Example:

package main

import "fmt"

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

func main() {
    x := 10
    y := 20

    swap(&x, &y)

    fmt.Println("x:", x)
    fmt.Println("y:", y)
}

Output:

x: 20
y: 10

Without pointers, the function would only modify copies of x and y.

---

Practical Example: Updating a Product

package main

import "fmt"

type Product struct {
    Name  string
    Price float64
}

func updatePrice(product *Product, price float64) {
    product.Price = price
}

func main() {
    product := Product{
        Name:  "Laptop",
        Price: 65000,
    }

    updatePrice(&product, 70000)

    fmt.Println(product.Name)
    fmt.Println(product.Price)
}

Output:

Laptop
70000

The function modifies the original product.

---

Practical Example: Counter

Pointers can also be useful for simple shared counters.

package main

import "fmt"

func increment(counter *int) {
    *counter++
}

func main() {
    count := 0

    increment(&count)
    increment(&count)
    increment(&count)

    fmt.Println(count)
}

Output:

3

In Go, (*counter)++ is also a clear way to understand this operation:

(*counter)++

It means increment the value that counter points to.

---

Pointer vs Value in Go

A normal variable stores the actual value.

Example:

number := 10

A pointer stores the address:

ptr := &number

The difference can be summarized like this:

Feature	Value	Pointer
Stores	Actual data	Memory address
Example type	int	*int
Modify original through function	No	Yes
Zero value	Depends on type	nil
Access value	Directly	Use *

---

Common Mistakes with Go Pointers

1. Confusing & and *

Remember:

&value

means:

address of value

And:

*ptr

means:

value stored at the address

---

2. Dereferencing a nil Pointer

This is unsafe:

var ptr *int

fmt.Println(*ptr)

Check first:

if ptr != nil {
    fmt.Println(*ptr)
}

---

3. Forgetting to Pass an Address

Suppose your function accepts:

func update(number *int)

You must normally pass:

update(&number)

not:

update(number)

---

4. Expecting a Value Parameter to Modify the Original

This does not change the original:

func update(number int) {
    number = 100
}

Use:

func update(number *int) {
    *number = 100
}

when the original must change.

---

5. Using Pointers Everywhere

Pointers are useful, but they are not required for every variable.

For small values such as:

int
bool
float64

passing by value is often simple and perfectly fine when you do not need to modify the original.

Use pointers when they provide a clear benefit.

---

When Should You Use Pointers in Go?

Pointers are a good choice when:

You Need to Modify the Original Value

func update(value *int) {
    *value = 100
}

You Need to Modify a Struct

func updateUser(user *User) {
    user.Name = "Updated"
}

You Want a Pointer Receiver

func (u *User) Update() {
}

You Want to Represent No Value

A pointer can be:

nil

which can be useful when a value is optional.

You Want to Avoid Copying a Large Struct

Passing a pointer can avoid copying the entire struct value on a function call.

---

Best Practices for Go Pointers

When working with pointers, keep these practices in mind:

1. Use pointers when you need to modify the original value.
2. Check pointers for nil when they may not contain a valid address.
3. Avoid using pointers unnecessarily.
4. Use pointer receivers when methods modify struct values.
5. Remember that & gets an address and * accesses the value at an address.
6. Prefer clear code over using pointers only for the sake of optimization.
7. Do not use pointers to maps or slices unless you specifically need to replace the map or slice variable itself.
8. Keep pointer usage simple while learning Go.

---

Frequently Asked Questions

What is a pointer in Go?

A pointer is a variable that stores the memory address of another variable.

Example:

number := 10

ptr := &number

---

What does & mean in Go?

The & operator returns the address of a variable.

Example:

ptr := &number

---

What does * mean in Go?

When used with a pointer, * accesses the value stored at the address.

Example:

fmt.Println(*ptr)

It is also used when declaring pointer types:

var ptr *int

---

What is a nil pointer?

A nil pointer is a pointer that does not point to a valid value.

Example:

var ptr *int

Its default value is nil.

---

How do you change a variable using a pointer?

Example:

number := 10

ptr := &number

*ptr = 50

Now number becomes:

50

---

Why are pointers used with functions?

Go passes arguments by value.

If a function needs to change the original variable, you can pass its address.

Example:

func update(number *int) {
    *number = 100
}

Call it with:

update(&number)

---

Do Go pointers support pointer arithmetic?

No.

Go does not allow normal pointer arithmetic such as:

ptr + 1

like you may see in languages such as C.

This helps keep ordinary pointer usage safer and simpler.

---

Do slices need pointers?

Usually no.

Slices already refer to underlying data, so a function can normally modify slice elements without receiving *[]T.

---

Do maps need pointers?

Usually no.

Maps already allow functions to modify entries without passing *map[K]V.

---

What is a pointer receiver?

A pointer receiver is a method receiver that uses a pointer to a type.

Example:

func (u *User) Update() {
    u.Name = "Updated"
}

This allows the method to modify the original struct.

---

Conclusion

Pointers in Go allow you to work with the memory address of a value instead of only working with a copy.

The most important pointer concepts are:

number := 10

ptr := &number

Here:

number → stores the value
&number → gets its address
ptr → stores the address
*ptr → accesses the value

You can modify the original value using:

*ptr = 100

Pointers are especially useful with functions:

func update(number *int) {
    *number = 100
}

and structs:

func updateUser(user *User) {
    user.Age = 30
}

For beginners, the easiest rule to remember is:

Use & to get an address and * to access the value stored at that address.

Once this becomes clear, working with pointers in Go becomes much easier.