Struct pointers in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a struct pointer in Go?

A struct pointer in Go is a variable that holds the memory address of a struct. It allows you to access and modify the struct's fields directly through the pointer.

beginner

How do you declare a pointer to a struct in Go?

You declare a pointer to a struct by using the * symbol before the struct type. For example: var p *Person declares a pointer to a Person struct.

beginner

How do you access struct fields using a pointer in Go?

You can access struct fields using the pointer with the dot operator directly, like p.Name. Go automatically dereferences the pointer for you.

intermediate

What is the difference between a struct value and a struct pointer when passing to a function?

Passing a struct value copies the entire struct, so changes inside the function don't affect the original. Passing a struct pointer passes the address, so changes inside the function modify the original struct.

intermediate

How do you create a new struct pointer with initialized values?

You can use the new keyword or take the address of a struct literal. For example: p := new(Person) or p := &Person{Name: "Alice"}.

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

A *

B &

C #

D $

The asterisk (*) is used to declare a pointer type in Go, including pointers to structs.

How do you access a field 'Name' of a struct through a pointer 'p' in Go?

A (*p).Name

B p->Name

C p.Name

D p*Name

In Go, you can access struct fields through a pointer using the dot operator directly, like p.Name. The language automatically dereferences the pointer.

What happens when you pass a struct pointer to a function?

A The function gets a copy of the struct

B The function cannot access the struct fields

C The struct is converted to a string

D The function can modify the original struct

Passing a struct pointer allows the function to modify the original struct because it receives the address.

Which of these creates a new struct pointer with initialized values?

A p := Person{Name: "Bob"}

B p := &Person{Name: "Bob"}

C p := *Person{Name: "Bob"}

D p := new(Person{Name: "Bob"})

Using &Person{...} creates a pointer to a new struct initialized with the given values.

What does the 'new' keyword do when used with a struct type?

A Creates a pointer to a zero-valued struct

B Deletes the struct

C Creates a struct value

D Copies the struct

The 'new' keyword allocates memory for a zero-valued struct and returns its pointer.

Explain how struct pointers work in Go and how you can use them to modify struct data.

Think about how pointers let you work directly with the original data.

Describe two ways to create a struct pointer with initial values in Go.

One way uses 'new', the other uses & with curly braces.

Practice

1. What does a struct pointer in Go hold?
type Person struct { Name string }

easy

A. Only the struct's first field value

B. A copy of the struct data

C. The memory address of a struct instance

D. A string representation of the struct

Solution

1. Step 1: Understand what a pointer stores

   A pointer stores the memory address of a variable, not the variable's value itself.

2. Step 2: Apply to struct pointers

   A struct pointer holds the address of the struct instance, allowing access or modification of the original struct.

3. Final Answer:

   The memory address of a struct instance -> Option C

4. Quick Check:

   Struct pointer = memory address [OK]

Hint: Pointers hold addresses, not copies. Remember & for address [OK]

Common Mistakes:

• Thinking pointer holds a copy of the struct
• Confusing pointer with struct value
• Assuming pointer holds only first field

2. Which of the following is the correct way to declare a pointer to a struct Person in Go?

easy

A. var *p Person

B. var p Person*

C. var p &Person

D. var p *Person

Solution

1. Step 1: Recall Go pointer syntax

   In Go, a pointer type is declared by placing * before the type name, e.g., *Person.

2. Step 2: Match correct declaration

   var p *Person uses var p *Person, which is the correct syntax for a pointer variable.

3. Final Answer:

   var p *Person -> Option D

4. Quick Check:

   Pointer declaration = *Type [OK]

Hint: Pointer type syntax: *TypeName, not after variable [OK]

Common Mistakes:

• Placing * after variable name
• Using & in declaration instead of *
• Incorrect order of * and type

3. What is the output of this Go program?

package main
import "fmt"
type Point struct { X, Y int }
func main() {
 p := Point{1, 2}
 ptr := &p
 ptr.X = 10
 fmt.Println(p.X)
}

medium

A. 1

B. 10

C. 0

D. Compilation error

Solution

1. Step 1: Understand pointer modification

   ptr points to p. Changing ptr.X modifies p.X because ptr references p's memory.

2. Step 2: Check printed value

   After setting ptr.X = 10, p.X becomes 10. So, printing p.X outputs 10.

3. Final Answer:

   10 -> Option B

4. Quick Check:

   Pointer changes original struct field [OK]

Hint: Changing pointer field changes original struct field [OK]

Common Mistakes:

• Thinking ptr.X is separate copy
• Expecting original p.X to remain 1
• Confusing pointer dereference syntax

4. Identify the error in this Go code snippet:

package main
import "fmt"
type User struct { Name string }
func updateName(u User) {
 u.Name = "Alice"
}
func main() {
 user := User{"Bob"}
 updateName(&user)
 fmt.Println(user.Name)
}

medium

A. Passing pointer to function expecting value

B. Missing import for fmt package

C. Cannot assign string to Name field

D. Function parameter should be a pointer to User

Solution

1. Step 1: Check function parameter type

   Function updateName expects a User value, but main passes &user (a *User pointer).

2. Step 2: Identify the type mismatch

   This causes a compilation error because the argument type (*User) does not match the parameter type (User).

3. Final Answer:

   Passing pointer to function expecting value -> Option A

4. Quick Check:

   Function param must match argument type [OK]

Hint: Match function param type with argument (& for pointer) [OK]

Common Mistakes:

• Passing pointer to value parameter without pointer receiver
• Ignoring need to modify original struct
• Assuming string assignment causes error

5. Given this struct and function:

package main
import "fmt"
type Counter struct { Count int }
func increment(c *Counter) {
 c.Count++
}
func main() {
 c := Counter{Count: 5}
 increment(&c)
 increment(c)
 fmt.Println(c.Count)
}

What will happen when running this program?

hard

A. Compilation error at increment(c)

B. Output is 7

C. Output is 6

D. Runtime panic due to invalid pointer

Solution

1. Step 1: Analyze function calls

   increment expects a *Counter pointer. The first call increment(&c) is correct.

2. Step 2: Check second call increment(c)

   Passing c (a value) instead of *Counter causes a compilation error because types don't match.

3. Final Answer:

   Compilation error at increment(c) -> Option A

4. Quick Check:

   Pointer param requires pointer argument [OK]

Hint: Pointer params need pointer args; value won't auto-convert [OK]

Common Mistakes:

• Assuming Go auto-converts value to pointer
• Expecting output 7 without error
• Ignoring type mismatch in function call