Address and dereference operators in Go - Step-by-Step Execution

Concept Flow - Address and dereference operators

Declare variable x

↓

Use & operator to get address of x

↓

Store address in pointer p

↓

Use * operator to dereference p

↓

Access or modify value at address

↓

End

This flow shows how a variable's address is taken with & and accessed or changed using * to dereference the pointer.

Execution Sample

Go

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

This code shows how to get the address of x, print its value via pointer p, change it through p, and print x again.

Execution Table

Step	Action	Variable	Value	Pointer Value	Output
1	Declare x	x	10	nil
2	Get address of x with &	x	10	address_of_x
3	Assign address to p	p	nil	address_of_x
4	Print *p (dereference p)	x	10	address_of_x	10
5	Set *p = 20 (change value at address)	x	20	address_of_x
6	Print x after change	x	20	address_of_x	20

💡 Program ends after printing updated value of x

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
x	undefined	10	10	20	20
p	nil	nil	address_of_x	address_of_x	address_of_x

Key Moments - 3 Insights

Why does changing *p also change x?

Because p holds the address of x, dereferencing *p accesses the same memory as x, so changing *p changes x (see steps 5 and 6).

What does the & operator do exactly?

The & operator gets the memory address of a variable, shown in step 2 where p gets the address of x.

Why do we use *p to print the value instead of just p?

p is a pointer holding an address; *p accesses the value at that address, so printing *p shows x's value (step 4).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of x after step 5?

A 20

B 10

C address_of_x

D nil

💡 Hint

Check the 'Value' column for x at step 5 in the execution_table.

At which step is the pointer p assigned the address of x?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Action' column describing pointer assignment in the execution_table.

If we print p instead of *p at step 4, what would be the output?

A 10

B 20

C address_of_x

D nil

💡 Hint

p holds the address; see the 'Pointer Value' column in the execution_table.

Concept Snapshot

Address and dereference operators in Go:
- & gets the address of a variable
- * dereferences a pointer to access or change the value
- Changing *p changes the original variable
- Use pointers to work with memory addresses directly

Full Transcript

This example shows how to use the address operator & to get a variable's memory address and store it in a pointer variable p. Then, using the dereference operator *, we access or modify the value at that address. Initially, x is 10. We assign p = &x, so p points to x's address. Printing *p shows 10. Changing *p to 20 updates x to 20. Printing x confirms the change. This demonstrates how pointers let us work directly with memory locations in Go.

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