Pointer declaration in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a pointer in Go?

A pointer in Go is a variable that stores the memory address of another variable. It allows you to directly access and modify the value stored at that address.

beginner

How do you declare a pointer to an int variable in Go?

You declare a pointer to an int using the syntax: var p *int. Here, p is a pointer that can hold the address of an int variable.

beginner

What does the * operator do when used with a pointer variable?

The * operator is used to dereference a pointer, which means accessing or modifying the value stored at the memory address the pointer holds.

beginner

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

You use the & operator before a variable name to get its memory address. For example, p = &x assigns the address of x to pointer p.

intermediate

Why use pointers in Go?

Pointers let you share and modify data efficiently without copying it. They are useful for changing variables inside functions and managing memory directly.

Which symbol is used to declare a pointer type in Go?

A &

B #

C *

D $

The * symbol is used to declare a pointer type, for example, *int means a pointer to an int.

What does the & operator do in Go?

A Declares a pointer

B Dereferences a pointer

C Assigns a value

D Gets the address of a variable

The & operator returns the memory address of a variable.

How do you access the value stored at the address a pointer holds?

A Using the * operator

B Using the & operator

C Using the -> operator

D Using the . operator

The * operator dereferences the pointer to access the value at its address.

What is the type of variable p after this declaration: var p *int?

A Integer

B Pointer to int

C Pointer to string

D String

p is declared as a pointer to an int type.

Why might you use pointers in Go?

A To modify variables inside functions without copying

B To create new variables

C To convert types

D To print values

Pointers allow functions to modify variables directly by passing their addresses.

Explain how to declare a pointer to an int and assign it the address of an int variable in Go.

Think about how you declare a pointer and how you get the address of a variable.

Describe what happens when you dereference a pointer in Go and why it is useful.

Consider what * does when used with a pointer variable.

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