# 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.

## Definition

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
zeroval(i)
fmt.Println("zeroval:", i)
zeroPtr(&i)
fmt.Println("zeroPtr:", i)

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

### Output:

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

### Explanation:

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.