Why Address and dereference operators in Go? - Purpose & Use Cases

The Big Idea

What if you could change data instantly everywhere without making copies?

The Scenario

Imagine you have a list of friends' phone numbers written on paper. To update one number, you have to find the exact paper, erase the old number, and write the new one. If you copy the list to share, changing a number in your copy won't update the original list.

The Problem

Manually copying and updating values is slow and error-prone. You might update a copy but forget to update the original, causing confusion. Also, passing large data around wastes memory and time.

The Solution

Address and dereference operators let you work directly with the location of data, not just copies. This means you can update the original data easily and efficiently, like having a direct phone line instead of a paper copy.

Before vs After

✗ Before

var x int = 10
var y int = x
 y = 20 // x stays 10

✓ After

var x int = 10
var p *int = &x
*p = 20 // x is now 20

What It Enables

It enables efficient data updates and sharing by working directly with memory addresses, avoiding unnecessary copies.

Real Life Example

When building a game, you can pass a pointer to a player's health so multiple parts of the game can update it instantly without copying the health value everywhere.

Key Takeaways

Manual copying causes slow and error-prone updates.

Address operators get the location of data.

Dereference operators let you change the original data directly.

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