Understanding Pointers vs Values in Go Struct

In Go, structs are a common data type used to represent complex data structures. When working with structs, it’s important to understand the difference between struct pointers and struct values.

Struct Values

A struct value is an instance of a struct type that stores its data directly. When you create a struct value, it allocates memory on the stack to store its fields. Here’s an example:

1
2
3
4
5
6

type Person struct {
    name string
    age  int
}

p := Person{name: "John", age: 30}

In this example, p is a struct value that stores its data directly in the memory allocated on the stack.

Struct Pointers

A struct pointer, on the other hand, is a pointer to a struct instance. It stores the memory address of the struct instance rather than the instance itself. Here’s an example:

1
2
3
4
5
6

type Person struct {
    name string
    age  int
}

p := &Person{name: "John", age: 30}

In this example, p is a struct pointer that stores the memory address of the Person instance.

Key Differences

Here are the key differences between struct pointers and values:

Memory Allocation

• Struct values allocate memory on the stack.
• Struct pointers allocate memory on the heap.

Data Storage

• Struct values store data directly in the allocated memory.
• Struct pointers store a memory address that points to the struct instance.

Modification

• Changes to a struct value affect only the local copy.
• Changes to a struct pointer affect the original instance.

Use Cases

Here are some scenarios where you might choose to use struct pointers or values:

Use Struct Values

• When working with small, immutable data structures.
• When performance is critical, and you want to avoid dynamic memory allocation.
• When you need to create a copy of the struct instance.

Use Struct Pointers

• When working with large, mutable data structures.
• When you need to modify the original instance from multiple locations.
• When you want to use the nil value to indicate an empty or uninitialized struct instance.

Best Practices

Here are some best practices to keep in mind:

Use Struct Pointers for Mutable Data

If your struct has mutable fields, consider using a struct pointer to ensure that changes propagate correctly.

Use Struct Values for Immutable Data

If your struct is immutable, use a struct value to avoid unnecessary dynamic memory allocation.

Avoid Unnecessary Pointer Derefences

Minimize the number of pointer dereferences in your code to improve performance and readability.

Define methods on values or pointers?

1
2

func (s *MyStruct) pointerMethod() { } // method on pointer
func (s MyStruct)  valueMethod()   { } // method on value

When defining a method on a type, the receiver (s in the above examples) behaves exactly as if it were an argument to the method. Whether to define the receiver as a value or as a pointer is the same question, then, as whether a function argument should be a value or a pointer. There are several considerations.

First, and most important, does the method need to modify the receiver? If it does, the receiver must be a pointer. (Slices and maps act as references, so their story is a little more subtle, but for instance to change the length of a slice in a method the receiver must still be a pointer.) In the examples above, if pointerMethod modifies the fields of s, the caller will see those changes, but valueMethod is called with a copy of the caller’s argument (that’s the definition of passing a value), so changes it makes will be invisible to the caller.

Second is the consideration of efficiency. If the receiver is large, a big struct for instance, it may be cheaper to use a pointer receiver.

Next is consistency. If some of the methods of the type must have pointer receivers, the rest should too, so the method set is consistent regardless of how the type is used.

For types such as basic types, slices, and small structs, a value receiver is very cheap so unless the semantics of the method requires a pointer, a value receiver is efficient and clear.

Conclusion

Understanding the difference between Golang struct pointers and values is crucial for writing efficient, effective, and scalable Go programs. By choosing the right approach based on your use case, you can ensure that your structs behave as expected and optimize your code for performance.