Address and dereference operators in Go

Introduction

We use address and dereference operators to work with memory locations directly. This helps us change values in one place and see the change everywhere that value is used.

When you want to change a variable's value inside a function and see the change outside.

When you want to share large data without copying it, to save memory.

When you want to link data structures like lists or trees by pointing to other elements.

When you want to check or modify the actual memory location of a variable.

Syntax

Go

var p *int = &x  // & gets the address of x
var y int = *p      // * gets the value stored at address p

The & operator gives you the memory address of a variable.

The * operator lets you access or change the value at that memory address.

Examples

Here, p stores the address of x. Printing p shows where x lives in memory.

Go

x := 10
p := &x
fmt.Println(p)  // prints memory address of x

The *p gets the value stored at the address p points to, which is x's value.

Go

x := 10
p := &x
fmt.Println(*p)  // prints 10

Changing *p changes x because p points to x.

Go

x := 10
p := &x
*p = 20
fmt.Println(x)  // prints 20

Sample Program

This program shows how to get the address of a variable x using &, read its value using *, and change it through the pointer.

Go

package main

import "fmt"

func main() {
    x := 5
    p := &x
    fmt.Println("Address of x:", p)
    fmt.Println("Value of x:", *p)

    *p = 10
    fmt.Println("New value of x after change through pointer:", x)
}

Important Notes

Pointer variables store memory addresses, not the actual values.

Dereferencing a pointer (*p) lets you read or change the value at that address.

Always initialize pointers before dereferencing to avoid errors.

Summary

The & operator gets the address of a variable.

The * operator accesses or changes the value at a given address.

Using pointers helps share and modify data efficiently.

Practice

1. What does the & operator do in Go?

easy

A. It declares a new variable.

B. It returns the memory address of a variable.

C. It multiplies two numbers.

D. It dereferences a pointer to get the value.

Solution

1. Step 1: Understand the & operator

   The & operator is used to get the address of a variable in memory.

2. Step 2: Differentiate from * operator

   The * operator is used to access the value at an address, not to get the address itself.

3. Final Answer:

   It returns the memory address of a variable. -> Option B

4. Quick Check:

   & operator = address retrieval [OK]

Hint: Remember & gets address, * gets value at address [OK]

Common Mistakes:

• Confusing & with * operator
• Thinking & multiplies values
• Assuming & declares variables

2. Which of the following is the correct way to declare a pointer to an int variable num in Go?

easy

A. var p &int = num

B. var p int = *num

C. var p *int = &num

D. var p *num = &int

Solution

1. Step 1: Understand pointer declaration syntax

   In Go, a pointer to an int is declared as *int. To assign it, use the address operator & on the variable.

2. Step 2: Check each option

   var p *int = &num correctly declares p as a pointer to int and assigns the address of num. Others misuse types or operators.

3. Final Answer:

   var p *int = &num -> Option C

4. Quick Check:

   Pointer declaration = var p *int = &num [OK]

Hint: Pointer syntax: var p *Type = &variable [OK]

Common Mistakes:

• Using * on variable instead of type
• Using & with type instead of variable
• Mixing variable and type names

3. What will be the output of this Go code?

package main
import "fmt"
func main() {
  x := 10
  p := &x
  *p = 20
  fmt.Println(x)
}

medium

A. 10

B. Compilation error

C. Memory address of x

D. 20

Solution

1. Step 1: Understand pointer assignment

   Variable p stores the address of x. Using *p = 20 changes the value at that address.

2. Step 2: Check final value of x

   Since *p points to x, changing *p to 20 updates x to 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   Dereferencing pointer changes original variable [OK]

Hint: Changing *p changes x because p points to x [OK]

Common Mistakes:

• Thinking *p = 20 creates new variable
• Expecting print to show address
• Confusing & and * operators

4. Identify the error in this Go code snippet:

func main() {
  var a int = 5
  var p *int
  *p = a
  fmt.Println(*p)
}

medium

A. Pointer p is not initialized before dereferencing.

B. Variable a should be a pointer.

C. Cannot assign int to *int directly.

D. fmt.Println cannot print pointer values.

Solution

1. Step 1: Check pointer initialization

   Pointer p is declared but not assigned an address before dereferencing with *p = a.

2. Step 2: Understand consequences

   Dereferencing an uninitialized pointer causes a runtime panic (nil pointer dereference).

3. Final Answer:

   Pointer p is not initialized before dereferencing. -> Option A

4. Quick Check:

   Dereference only initialized pointers [OK]

Hint: Always assign pointer before dereferencing it [OK]

Common Mistakes:

• Dereferencing nil pointer
• Confusing pointer and value assignment
• Assuming fmt.Println can't print pointers

5. Given the code below, what will be the output?

package main
import "fmt"
func updateValue(p *int) {
  *p = *p + 5
}
func main() {
  val := 10
  updateValue(&val)
  fmt.Println(val)
}

hard

A. 15

B. 10

C. Memory address of val

D. Compilation error

Solution

1. Step 1: Understand function parameter

   The function updateValue takes a pointer to an int. Passing &val sends the address of val.

2. Step 2: Analyze pointer dereference and update

   Inside the function, *p = *p + 5 adds 5 to the value at the address, updating val to 15.

3. Final Answer:

   15 -> Option A

4. Quick Check:

   Pointer parameter updates original variable [OK]

Hint: Passing &var lets function modify original value [OK]

Common Mistakes:

• Expecting original val unchanged
• Confusing pointer with value copy
• Thinking function returns new value