Embedded Structs in Go: Pointer vs. Object

When dealing with pointer receivers and constructing pointer types, understanding the difference between embedding a struct as an object (B) versus a pointer (*B) becomes crucial. In this context, the zero values of these two embedded struct types differ significantly.

Direct Embedding (Object)

If a struct B with pointer receivers is embedded directly as an object within a struct A, its zero value includes an embedded object of type B, which itself has a zero value. Developers can safely access this embedded object and its methods.

type B struct {
    X int
}

func (b *B) Print() { fmt.Printf("%d\n", b.X) }

type AObj struct {
    B
}

var aObj AObj
aObj.Print() // prints 0

Pointer Embedding

In contrast, embedding a pointer to B (*B) creates a different scenario. The zero value of this embedded struct has a nil pointer value, rendering it unusable directly.

type APtr struct {
    *B
}

var aPtr APtr
aPtr.Print() // panics

Object Copying

When an AObj object is created, it obtains a copy of the embedded B object. Modifications made to the copy do not affect the original object.

aObj2 := aObj
aObj.X = 1
aObj2.Print() // prints 0

Pointer Copying

With APtr, creating a new object copies the pointer (*B) but not the underlying concrete object pointed to. Therefore, modifications to the new object affect both the original and new objects.

aPtr.B = &B{}
aPtr2 := aPtr
aPtr.X = 1
aPtr2.Print() // prints 1

It is important to consider the specific use case and requirements when determining whether to embed a struct as an object or a pointer. This decision can impact zero initialization, copying behavior, and object ownership, among other factors.