嵌入何时使用指针

Question

当我想在另一个结构中嵌入一个结构时，我应该使用指针还是值？

例如

type Job struct {
    Command string
    *log.Logger
}

或

type Job struct {
    Command string
    log.Logger
}

Answer 1

您可以使用其中之一：对于 struct type，规范提到：

A field declared with a type but no explicit field name is an anonymous field, also called an embedded field or an embedding of the type in the struct.

An embedded type must be specified as a type name T or as a pointer to a non-interface type name *T, and T itself may not be a pointer type.

由于log.Logger不是接口，您可以使用类型或指向匿名字段类型的指针Logger。

文章“Embedding in Go " fro Eric Urban (hydrogen18) 调用嵌入指针“通过指针嵌入”：

The first advantage to this is that you can rely on functions that use the NewX idiom returning a struct by-pointer to do initialization.

The second advantage is that you can embed all the functionality of a type without needing to know when it is instantiated.
The embedded pointer to a Bitmap is no different than any other pointer in Go, so it can be assigned multiple times.
By doing this you can change what instance you are extending dynamically at run time.

例如，与：

type Bitmap struct{
    data [4][5]bool
}

type Renderer struct{
    *Bitmap //Embed by pointer
    on uint8
    off uint8
}

Renderer 类型嵌入了一个 Bitmap by-pointer。

A single instance of Bitmap can act as the embedded instance of many Renderer instances:

var renderA,renderB Renderer
renderA.on = 'X'
renderA.off = 'O'
renderB.on = '@'
renderB.off = '.'

var pic Bitmap
pic.data[0][6] = true
pic.data[0][7] = true
pic.data[1][8] = true
pic.data[2][9] = true
pic.data[3][10] = true

renderA.Bitmap = &pic
renderB.Bitmap = &pic

renderA.render()
renderB.render()

This shares the same Bitmap instance to two different renderers.
Each renderer has its own set of characters, allowing two representations of the bitmap to be printed.
This is what the output looks like:

OXXO
OXOO
OXOO
OXOO
.@@.
.@..
.@..
.@..

This example demonstrates the Flyweight Pattern.
Although inconsequential to memory consumption in this example, having many thousands of instances sharing a single underlying data structure can be very significant in reducing the memory consumption of systems.

如this thread所述：

The reason why you can't have pointer to pointer and pointer to interface anonymous fields is that these types don't have methods.
The whole point of anonymous fields is that methods get promoted.

I already explained why interfaces don't have methods: a lot of people were using pointers to interfaces incorrectly and unnecessarily, and there weren't any known valid uses, so the language was changed to actively discourage this usage by making pointers to interfaces have no methods.

嵌入何时使用指针

Embedding when to use pointer

go

embedding