Go Slice与Map的内存分配方式：静态还是动态？

Great question—let’s break this down clearly for both slices and maps in Go, since you’re curious about their memory allocation behavior relative to compile-time static vs runtime dynamic allocation.

First, a quick recap: every Go slice is a small struct (3 fields on 64-bit systems: a pointer to the underlying array, length, and capacity). Now, to answer your core question:

• The slice struct itself might be allocated on the stack (if Go’s escape analysis determines it doesn’t need to live beyond the current function), but the underlying array that the slice points to is almost always allocated dynamically at runtime.

Compile-time static allocation (where memory is reserved in the program’s data segment at build time) doesn’t make sense for slices because their size is often only known when the program runs. For example:

• If you create a slice with make([]int, n) where n is a variable determined at runtime, the compiler can’t possibly know how much memory to reserve ahead of time.
• Even for slice literals like s := []int{1, 2, 3}, the underlying array is allocated at runtime (though the compiler might optimize small cases to stack allocation, this is still runtime, not static).
• When you append to a slice and it needs to grow (i.e., when the length exceeds capacity), the Go runtime automatically allocates a new, larger underlying array, copies the old data over, and updates the slice’s pointer—this is all handled dynamically at runtime.

The only static part here is the size of the slice struct itself (24 bytes on 64-bit), but that’s just the metadata, not the actual data storage.

Maps in Go follow a similar dynamic allocation pattern, with even less room for static allocation due to their complex internal structure.

• A map variable is actually a pointer to an hmap struct (the internal implementation of Go’s hash table). This struct and the associated bucket arrays (where key-value pairs are stored) are always allocated dynamically at runtime.

Why no static allocation? Maps are inherently dynamic:

• You can’t know the number of key-value pairs at compile time in most real-world use cases.
• Go’s map implementation automatically resizes (rehashes) its bucket array when the load factor gets too high, which requires runtime memory allocation.
• Even when you initialize a map with a hint like make(map[string]int, 100), the runtime uses that hint to allocate an initial bucket array, but this still happens when the program runs, not at compile time.

Just like slices, the map variable itself (the pointer to hmap) might live on the stack if escape analysis allows, but the actual hash table data is always dynamically allocated.

内容的提问来源于stack exchange，提问作者Himanshu