Address and dereference operators in Go - Mini Project: Build & Apply

Address and Dereference Operators

📖 Scenario: Imagine you are managing a simple inventory system where you need to update the quantity of an item using pointers. This helps you understand how to use address and dereference operators in Go.

🎯 Goal: You will create a variable for an item quantity, use a pointer to access its address, update the quantity through the pointer, and then print the updated quantity.

📋 What You'll Learn

Create an integer variable called quantity with the value 10.

Create a pointer variable called ptr that stores the address of quantity.

Use the dereference operator to update the value of quantity to 25 through the pointer ptr.

Print the updated value of quantity.

💡 Why This Matters

🌍 Real World

Pointers are used in real programs to efficiently update data without copying it, such as modifying inventory counts or managing resources.

💼 Career

Understanding pointers is important for system programming, performance optimization, and working with low-level data structures in Go.

1

Create the initial variable

Create an integer variable called quantity and set it to 10.

Go

// Create an integer variable called quantity and set it to 10
// Your code here

Hint

Use := to declare and assign the variable in one line.

2

Create a pointer to the variable

Create a pointer variable called ptr that stores the address of quantity using the address operator &.

Go

package main

func main() {
    quantity := 10
    // Create a pointer variable ptr that stores the address of quantity
    // Your code here
}

Hint

Use &quantity to get the address of quantity.

3

Update the variable using the pointer

Use the dereference operator * on ptr to update the value of quantity to 25.

Go

package main

func main() {
    quantity := 10
    ptr := &quantity
    // Update the value of quantity to 25 using the pointer ptr
    // Your code here
}

Hint

Use *ptr = 25 to change the value at the address stored in ptr.

4

Print the updated value

Use fmt.Println to print the updated value of quantity.

Go

package main

import "fmt"

func main() {
    quantity := 10
    ptr := &quantity
    *ptr = 25
    // Print the updated value of quantity
    // Your code here
}

Hint

Remember to import fmt and use fmt.Println(quantity) to display the value.

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