Address and dereference operators in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to get the address of variable num.

Go

num := 10
ptr := [1]num
fmt.Println(ptr)

Drag options to blanks, or click blank then click option'

A*

B&

C#

D$

Attempts:

3 left

💡 Hint

Common Mistakes

Using the dereference operator * instead of the address operator &.

Using symbols like # or $ which are not valid operators.

The address operator in Go is &. It returns the memory address of the variable.

2fill in blank

medium

Complete the code to access the value stored at the pointer ptr.

Go

num := 20
ptr := &num
value := [1]ptr
fmt.Println(value)

Drag options to blanks, or click blank then click option'

A*

B&

C^

D%

Attempts:

3 left

💡 Hint

Common Mistakes

Using the address operator & instead of dereference *.

Using invalid operators like ^ or %.

The dereference operator * is used to access the value stored at the memory address a pointer holds.

3fill in blank

hard

Fix the error in the code to correctly update the value via pointer.

Go

num := 5
ptr := &num
[1]ptr = 10
fmt.Println(num)

Drag options to blanks, or click blank then click option'

Aptr*

Bptr

C*

D&

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning directly to the pointer variable instead of dereferencing it.

Using invalid syntax like ptr* or &ptr.

To update the value that a pointer points to, use the dereference operator * before the pointer variable.

4fill in blank

hard

Fill both blanks to create a pointer to val and then get its value.

Go

val := 15
ptr := [1]val
result := [2]ptr
fmt.Println(result)

Drag options to blanks, or click blank then click option'

A&

B*

C#

D$

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping the operators in the blanks.

Using invalid operators like # or $.

First, use & to get the address of val. Then use * to dereference the pointer and get the value.

5fill in blank

hard

Fill all three blanks to create a pointer, update the value via pointer, and print the updated value.

Go

num := 8
ptr := [1]num
[2]ptr = 20
fmt.Println([3]ptr)

Drag options to blanks, or click blank then click option'

A&

B*

Cptr

Dnum

Attempts:

3 left

💡 Hint

Common Mistakes

Using the pointer variable ptr directly instead of dereferencing.

Mixing up the address and dereference operators.

Use & to get the address of num. Use *ptr to update and access the value via 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