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

# Decrypt Go:  empty struct
- URL: https://huizhou92.com/decrypt-go-empty-struct/
- Published: 2024-06-17T15:05:42.000Z
- Updated: 2026-09-06T11:39:56.000Z
- Description: Decrypt Go: empty struct. 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 i。
- Author: huizhou92
- Tags: tech, golang, #lang-en

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](https://medium.huizhou92.com/?ref=huizhou92.com). Thank you very much.

```go
type Test struct {
    A int
    B string
}

func main() {
    fmt.Println(unsafe.Sizeof(new(Test)))
    fmt.Println(unsafe.Sizeof(struct{}{}))
}

/*
8
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 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`.

[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 special 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 next 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**. 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{}`

```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, 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

1. An empty struct is still a struct, just 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)