Address and dereference operators in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the address operator (&) do in Go?

The address operator (&) gives the memory address of a variable. It lets you find where the variable is stored in memory.

beginner

What does the dereference operator (*) do in Go?

The dereference operator (*) lets you access or change the value stored at a memory address (pointer). It "follows" the pointer to the actual data.

beginner

Given: var x int = 10; p := &x; What is *p?

*p is 10, the value stored at the memory address p points to (which is x's value).

intermediate

How do you change the value of a variable using a pointer in Go?

Use the dereference operator (*) on the pointer to assign a new value. For example, *p = 20 changes the value at the address p points to.

intermediate

Why are address and dereference operators useful in Go?

They let you work directly with memory addresses, which helps with efficient data handling, sharing data without copying, and building complex data structures like linked lists.

What does the & operator do in Go?

A Returns the memory address of a variable

B Accesses the value at a pointer

C Declares a new variable

D Performs addition

The & operator returns the memory address of a variable.

What does *p mean if p is a pointer in Go?

A The value stored at the address p points to

B Creates a new pointer

C Declares a pointer variable

D The memory address stored in p

*p accesses the value stored at the memory address that p points to.

How do you get the address of variable x in Go?

A address(x)

B *x

C x&

D &x

Use &x to get the memory address of variable x.

If p := &x, what does *p = 5 do?

A Changes p to 5

B Changes x to 5

C Creates a new variable 5

D Causes an error

*p = 5 changes the value of x to 5 because p points to x.

Why use pointers in Go?

A To declare variables

B To copy data faster

C To access memory addresses directly

D To avoid using variables

Pointers let you access and manipulate memory addresses directly, which can improve efficiency.

Explain how the address (&) and dereference (*) operators work together in Go.

Think about how you find a house address and then enter the house to see what's inside.

Describe a simple example in Go where you use a pointer to change a variable's value.

Start with a number, get its address, then change the number through the pointer.

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