Go Example: Pointers

1. Introduction

Pointers are a fundamental concept in many programming languages, including Go. They allow you to reference and manipulate the memory address of a variable. This blog post will explain how to use pointers in Go with clear examples.


A pointer in Go is a variable that stores the memory address of another variable. Pointers are used to access and change the values of variables indirectly.

2. Program Steps

1. Declare an integer variable and a pointer to an integer.

2. Assign the memory address of the integer variable to the pointer.

3. Change the value of the integer variable using the pointer.

4. Pass a pointer to a function to allow the function to modify the value of the variable.

3. Code Program

package main

import "fmt"

// zeroval doesn't change the i in main, but zeroPtr does because it has a reference to the memory address for that variable.
func zeroval(ival int) {
	ival = 0

func zeroPtr(iptr *int) {
	*iptr = 0

func main() {
	i := 1
	fmt.Println("initial:", i)

	// Step 1 & 2: Assign the memory address of i to a pointer
	ptr := &i
	fmt.Println("pointer:", ptr)
	fmt.Println("pointer value:", *ptr)

	// Step 3: Change i using the pointer
	*ptr = 3
	fmt.Println("ptr:", *ptr)
	fmt.Println("i:", i)

	// Step 4: Pass the pointer to a function
	fmt.Println("zeroval:", i)
	fmt.Println("zeroPtr:", i)

	// Print the pointer's memory address
	fmt.Println("pointer:", ptr)


initial: 1
pointer: 0xc0000120b8
pointer value: 1
ptr: 3
i: 3
zeroval: 3
zeroPtr: 0
pointer: 0xc0000120b8


1. package main - The package declaration for the Go program.

2. import "fmt" - Imports the Format package for formatted output.

3. The integer i is initialized to 1.

4. ptr is declared as a pointer to an int and is assigned the memory address of i using the & operator.

5. *ptr dereferences the pointer, allowing access to the value at the memory address ptr is pointing to.

6. zeroval is a function that takes an int parameter and sets it to 0. It does not affect i because it's working with a copy.

7. zeroPtr, on the other hand, takes a pointer to an int, dereferences it, and sets the underlying value to 0. This affects i because it changes the value at the memory address that ptr points to.

8. The output shows the initial value of i, how its value is accessed and changed via a pointer, and the effects of passing i to zeroval and &i to zeroPtr.