> ## Content Index
> Fetch the complete content index at: https://huizhou92.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Golang High-Performance Programming EP1: Empty Struct
- URL: https://huizhou92.com/decrypt-go-empty-struct-2/
- Published: 2024-06-18T20:01:02.000Z
- Updated: 2026-09-08T02:31:41.000Z
- Description: Golang High-Performance Programming EP1: Empty Struct. The Mystery of the Empty Struct in Go: Understanding its Usage and Optimization In Go, a regular str。
- Author: huizhou92
- Tags: #Migrated-1788833207488, #Import 2026-09-08 02:07

### The Mystery of the Empty Struct in Go: Understanding its Usage and Optimization

In Go, a regular struct typically occupies a block of memory. However, there’s a particular case: if it’s an empty struct, its size is zero. How is this possible, and what is the use of an empty struct?

```csharp
type Test struct { 
     A int 
     B string 
 } 
 ​ 
 func main() { 
     fmt.Println(unsafe.Sizeof(Test{})) 
     fmt.Println(unsafe.Sizeof(struct{}{})) 
 } 
 ​ 
 /* 
 24 
 0 
 */
```

### 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 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`.

[Example](https://go.dev/play/p/WNxfXviET%5Fi?ref=huizhou92.com)

```go
package main 
 ​ 
 import "fmt" 
 ​ 
 type emptyStruct struct {} 
 ​ 
 func main() { 
     a := struct{}{} 
     b := struct{}{} 
     c := emptyStruct{} 
 ​ 
     fmt.Printf("%p\n", &a) 
     fmt.Printf("%p\n", &b) 
     fmt.Printf("%p\n", &c) 
 } 
 ​ 
 // 0x58e360 
 // 0x58e360 
 // 0x58e360
```

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](https://go.googlesource.com/go/blob/fe36ce669c1a452d2b0e81108a7e07674b50692a/src/runtime/malloc.go?ref=huizhou92.com#L983) function:

```go
//go:linkname mallocgc   
 func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {   
     ... 
     if size == 0 {   
        return unsafe.Pointer(&zerobase)   
     } 
     ...
```

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 particular case when the empty struct is the last field; it triggers memory alignment.

[Example](https://go.dev/play/p/HcxlywljovS?ref=huizhou92.com)

```go
type A struct { 
     x int 
     y string 
     z struct{} 
 } 
 type B struct { 
     x int 
     z struct{} 
     y string 
 } 
 ​ 
 func main() { 
     println(unsafe.Alignof(A{})) 
     println(unsafe.Alignof(B{})) 
     println(unsafe.Sizeof(A{})) 
     println(unsafe.Sizeof(B{})) 
 } 
 ​ 
 /** 
 8 
 8 
 32 
 24 
 **/
```

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 following variable.

```go
type A struct {   
     x int   
     y string   
     z struct{}   
 }   
 type B struct {   
     x int   
     z struct{}   
     y string   
 }   
    
 func main() {   
     a := A{}   
     b := B{}   
     fmt.Printf("%p\n", &a.y)   
     fmt.Printf("%p\n", &a.z)   
     fmt.Printf("%p\n", &b.y)   
     fmt.Printf("%p\n", &b.z)   
 } 
 ​ 
 /** 
 0x1400012c008 
 0x1400012c018 
 0x1400012e008 
 0x1400012e008 
 **/
```

### Use Cases of the Empty Struct

The core reason for the existence of the empty struct `struct{}` is to **save memory**. Consider using an empty struct when you need a struct but don't care about its contents. Go's core composite structures, such as `map`, `chan`, and `slice` can all use `struct{}`.

#### `map` & `struct{}`

```go
// Create map 
 m := make(map[int]struct{}) 
 // Assign value 
 m[1] = struct{}{} 
 // Check if key exists 
 _, ok := m[1]
```

#### `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.

```go
// Create a signal channel 
 waitc := make(chan struct{}) 
 ​ 
 // ... 
 goroutine 1: 
     // Send signal: push element 
     waitc <- struct{}{} 
     // Send signal: close 
     close(waitc) 
 ​ 
 goroutine 2: 
     select { 
     // Receive signal and perform corresponding actions 
     case <-waitc: 
     }
```

In this scenario, it is `struct{}` 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

1. An empty struct is still a struct with a size of 0.
2. All empty structs share the same address: the address of `zerobase`.
3. We can leverage the empty struct’s non-memory-occupying feature to optimize code, such as using maps to implement sets and channels.

### References

1. [The empty struct, Dave Cheney](https://dave.cheney.net/2014/03/25/the-empty-struct?ref=huizhou92.com)
2. [Go 最细节篇 — struct{} 空结构体究竟是啥？](https://www.qiyacloud.cn/2020/12/2020-12-21/?ref=huizhou92.com)

[文章索引](/article-index/)