Pointer declaration in Go - Mini Project: Build & Apply

Pointer declaration

📖 Scenario: Imagine you are working with a simple program that needs to keep track of a number and also use a pointer to that number. Pointers are like notes that tell you where the number is stored in memory.

🎯 Goal: You will create a variable holding a number, declare a pointer to that number, and then print the pointer's value (the memory address) and the value it points to.

📋 What You'll Learn

Create an integer variable named num with the value 42.

Declare a pointer variable named ptr that points to num.

Print the value of ptr (the memory address).

Print the value stored at the address ptr points to (the value of num).

💡 Why This Matters

🌍 Real World

Pointers are used in Go to efficiently manage memory and to allow functions to modify variables outside their own scope.

💼 Career

Understanding pointers is important for Go developers working on performance-critical applications, system programming, or when interfacing with low-level code.

1

Create an integer variable

Create an integer variable called num and set it to 42.

Go

package main

func main() {
    // Create an integer variable called num and set it to 42
    // Your code here
}

Hint

Use num := 42 to create the variable.

2

Declare a pointer to the variable

Declare a pointer variable called ptr that points to the variable num using the address operator &.

Go

package main

func main() {
    num := 42
    // Declare a pointer variable ptr that points to num
    // Your code here
}

Hint

Use ptr := &num to get the address of num.

3

Print the pointer value (address)

Use fmt.Println to print the value of the pointer variable ptr (the memory address). Remember to import the fmt package.

Go

package main

import "fmt"

func main() {
    num := 42
    ptr := &num
    // Print the value of ptr (the address)
    // Your code here
}

Hint

Use fmt.Println(ptr) to print the pointer's address.

4

Print the value pointed to by the pointer

Use fmt.Println to print the value stored at the address ptr points to by dereferencing ptr with *ptr.

Go

package main

import "fmt"

func main() {
    num := 42
    ptr := &num
    fmt.Println(ptr)
    // Print the value pointed to by ptr
    // Your code here
}

Hint

Use fmt.Println(*ptr) to print the value at the pointer.

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