In Go, a normal struct typically occupies a block of memory. However, there’s a special case: if it’s an empty struct, its size is zero. How is this possible, and what is the use of an empty struct?
This article is first published in the medium MPP plan. If you are a medium user, please follow me in medium. Thank you very much.
|
|
The Secret of the Empty Struct
Special Variable: zerobase
An empty struct is a struct with no memory size. This statement is correct, but to be more precise, it actually has a special starting point: the zerobase
variable. This is a uintptr
global variable that occupies 8 bytes. Whenever countless struct {}
variables are defined, the compiler assigns the address of this zerobase
variable. In other words, in Go, any memory allocation with a size of 0 uses the same address, &zerobase
.
|
|
The memory addresses of variables of an empty struct are all the same. This is because the compiler assigns &zerobase
during compilation when encountering this special type of memory allocation. This logic is in the mallocgc
function:
|
|
This is the secret of the Empty struct
. With this special variable, we can accomplish many functionalities.
Empty Struct and Memory Alignment
Typically, if an empty struct is part of a larger struct, it doesn’t occupy memory. However, there’s a special case when the empty struct is the last field; it triggers memory alignment.
|
|
When a pointer to a field is present, the returned address may be outside the struct, potentially leading to memory leaks if the memory is not freed when the struct is released. Therefore, when an empty struct is the last field of another struct, additional memory is allocated for safety. If the empty struct is at the beginning or middle, its address is the same as the next variable.
|
|
Use Cases of the Empty Struct
The core reason for the existence of the empty struct struct{}
is to save memory. When you need a struct but don’t care about its contents, consider using an empty struct. Go’s core composite structures such as map
, chan
, and slice
can all use struct{}
.
map
& struct{}
|
|
chan
& struct{}
A classic scenario combines channel
and struct{}
, where struct{}
is often used as a signal without caring about its content. As analyzed in previous articles, the essential data structure of a channel is a management structure plus a ring buffer. The ring buffer is zero-allocated if struct{} is used as an element.
The only use of chan
and struct{}
together is for signal transmission since the empty struct itself cannot carry any value. Generally, it’s used with no buffer channels.
|
|
In this scenario, is struct{}
absolutely necessary? Not really, and the memory saved is negligible. The key point is that the element value of chan
is not cared about, hence struct{}
is used.
Summary
- An empty struct is still a struct, just with a size of 0.
- All empty structs share the same address: the address of
zerobase
. - We can leverage the empty struct’s non-memory-occupying feature to optimize code, such as using maps to implement sets and channels.