Pointer declaration in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of pointer declaration and dereference

What is the output of this Go program?

Go

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

A 0

B Memory address of x

C 10

D Compilation error

💡 Hint

Remember that *p gives the value stored at the address p points to.

The pointer p holds the address of x. Using *p accesses the value at that address, which is 10.

❓ Predict Output

intermediate

Pointer declaration with nil value

What will this Go program print?

Go

package main
import "fmt"
func main() {
    var p *int
    if p == nil {
        fmt.Println("Pointer is nil")
    } else {
        fmt.Println("Pointer is not nil")
    }
}

A Runtime panic

B Pointer is not nil

C Compilation error

D Pointer is nil

💡 Hint

Uninitialized pointers have the zero value nil.

The pointer p is declared but not assigned, so it defaults to nil. The if condition detects this and prints accordingly.

❓ Predict Output

advanced

Pointer modification effect

What is the output of this Go program?

Go

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

A 20

B 5

C Compilation error

D Runtime panic

💡 Hint

Changing the value via pointer changes the original variable.

The pointer p points to x. Assigning *p = 20 changes x to 20. So printing x outputs 20.

❓ Predict Output

advanced

Pointer declaration syntax error

Which option will cause a compilation error in Go?

A var p *int = nil

B var p *int = 10

C

var p *int
p = new(int)

D

var x int = 5
var p *int = &x

💡 Hint

A pointer must hold an address or nil, not a direct value.

Option B tries to assign an int value directly to a pointer variable, which is invalid. The others are valid pointer declarations or assignments.

🧠 Conceptual

expert

Pointer zero value and usage

Which statement about pointer declaration in Go is TRUE?

A The zero value of a pointer variable is nil, meaning it points to no valid memory.

B Dereferencing a nil pointer returns zero without error.

C You can assign an integer value directly to a pointer variable.

D A pointer variable declared without initialization points to a random memory location.

💡 Hint

Think about what happens when you declare a pointer but don't assign it.

In Go, uninitialized pointers have the zero value nil, which means they don't point to any valid memory. Dereferencing nil causes a runtime panic.

Practice

1. What does a pointer in Go store?

easy

A. The actual value of a variable

B. The memory address of a variable

C. The type of a variable

D. The size of a variable

Solution

1. Step 1: Understand what a pointer represents

   A pointer does not hold the value itself but the location where the value is stored in memory.

2. Step 2: Recall pointer definition in Go

   In Go, a pointer stores the address of a variable, not the variable's value directly.

3. Final Answer:

   The memory address of a variable -> Option B

4. Quick Check:

   Pointer = memory address [OK]

Hint: Pointers always hold addresses, not values [OK]

Common Mistakes:

• Thinking pointers store the actual value
• Confusing pointer with variable type
• Assuming pointer stores variable size

2. Which of the following is the correct way to declare a pointer to an int variable named num in Go?

easy

A. var p int = &num

B. var p *int = num

C. var p *int = &num

D. var p int = *num

Solution

1. Step 1: Understand pointer declaration syntax

   In Go, to declare a pointer to an int, use *int as the type.

2. Step 2: Assign the address of num to the pointer

   The address operator & gets the memory address of num, which can be assigned to the pointer.

3. Final Answer:

   var p *int = &num -> Option C

4. Quick Check:

   Pointer declaration uses *type and &variable [OK]

Hint: Pointer type uses * before type, assign with &variable [OK]

Common Mistakes:

• Forgetting the * in pointer type
• Assigning variable value instead of address
• Using *num instead of &num for assignment

3. What will be the output of this Go program?

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

medium

A. 20

B. 10

C. Memory address of x

D. Compilation error

Solution

1. Step 1: Understand pointer assignment and dereferencing

   Variable p stores the address of x. Using *p = 20 changes the value at that address.

2. Step 2: Check the effect on x

   Since p points to x, changing *p changes x to 20.

3. Final Answer:

   20 -> Option A

4. Quick Check:

   Dereferencing pointer changes original variable [OK]

Hint: Changing *p changes the original variable [OK]

Common Mistakes:

• Thinking *p creates a new variable
• Expecting output to be address instead of value
• Confusing pointer declaration with dereferencing

4. Identify the error in this Go code snippet:

var a int = 5
var p *int = a
fmt.Println(*p)

medium

A. Cannot assign int to *int without & operator

B. Cannot print pointer value with * operator

C. Variable a must be a pointer

D. Missing import fmt

Solution

1. Step 1: Check pointer assignment rules

   Pointer variables must be assigned the address of a variable, not the variable's value.

2. Step 2: Identify missing & operator

   Assigning a directly to p is invalid; it should be p = &a.

3. Final Answer:

   Cannot assign int to *int without & operator -> Option A

4. Quick Check:

   Pointer assignment needs &variable [OK]

Hint: Use & to assign address to pointer variables [OK]

Common Mistakes:

• Assigning value instead of address to pointer
• Forgetting to import fmt for Println
• Thinking *p prints address instead of value

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. 10

B. Compilation error

C. Memory address of val

D. 15

Solution

1. Step 1: Understand function parameter as pointer

   The function updateValue takes a pointer to an int and modifies the value at that address.

2. Step 2: Trace the function call and modification

   Passing &val sends the address of val. Inside the function, *p = *p + 5 increases val by 5.

3. Step 3: Check final print output

   After the function call, val is updated to 15, so fmt.Println(val) prints 15.

4. Final Answer:

   15 -> Option D

5. Quick Check:

   Pointer parameter modifies original variable [OK]

Hint: Passing &variable lets function change original value [OK]

Common Mistakes:

• Passing value instead of address to function
• Expecting original variable unchanged
• Confusing pointer dereference syntax