10.5 Enums and Memory Layout

Even though an enum can have variants requiring different amounts of memory, all instances of that enum type occupy the same amount of space.

10.5.1 Memory Size Considerations

Internally, a Rust enum uses enough space to store its largest variant plus a small discriminant that identifies the active variant. If one variant is significantly larger than the others, the entire enum may be large as well:

#![allow(unused)]
fn main() {
enum LargeEnum {
    Variant1(i32),
    Variant2([u8; 1024]),
}
}

Even if Variant1 is used most of the time, every LargeEnum instance requires space for the largest variant.

10.5.2 Reducing Memory Usage

You can use heap allocation to make the type itself smaller when you have a large variant:

#![allow(unused)]
fn main() {
enum LargeEnum {
    Variant1(i32),
    Variant2(Box<[u8; 1024]>),
}
}
  • Box: Stores the data on the heap, so the enum holds only a pointer plus its discriminant.

We’ll discuss the box type in more detail in Chapter 19 when we introduce Rust’s smart pointer types.

  • How it Works: By storing the large variant’s data on the heap, each instance of LargeEnum only needs space for a pointer (to the heap data) plus the discriminant. This is especially beneficial if you keep many enum instances (e.g., in a vector) and use the large variant infrequently.
  • Trade-Off: Heap allocation adds overhead, including extra runtime cost and potential fragmentation. Whether this is worthwhile depends on your application’s memory-access patterns and performance requirements.