为何纯面向对象语言中最上层引用无heap overhead（堆开销）？

Great question—let’s unpack this using Stroustrup’s example and the nature of heap-only object-oriented languages.

First, let’s clarify the context: The pure OO language in Foundations of C++ is explicitly heap-only—meaning there is no stack; every object lives on the heap. Your confusion comes from shifting from assuming a was stack-allocated (hence no overhead) to knowing it’s heap-allocated, but seeing no heap overhead in its top-level reference/layout.

Why there’s no visible overhead here #

When we talk about "heap overhead," we’re usually referring to two things:

• Allocator-level metadata: Heap managers add hidden prefixes/suffixes to memory blocks (like size markers, free list pointers) to track allocations. But these are outside the object’s visible memory layout—from the language’s perspective, they don’t exist.
• Language-level object overhead: Some languages add extra fields to objects (like vptrs for polymorphism, length fields for arrays, or type tags).

In Stroustrup’s example, the array a is designed as a compact value array: its heap-allocated memory is just the contiguous sequence of complex objects ({1,2} followed by {3,4}) with no extra language-defined fields (no length, no hidden pointers). The heap allocator’s metadata is invisible to the language, so it doesn’t count as "overhead" in the object’s layout.

Is this a general case, or a special example? #

It depends entirely on the heap-only language’s design:

• It can be general: If a language prioritizes compactness for arrays (treating them as contiguous value sequences rather than full-fledged objects with extra state), then even heap-allocated arrays will have no visible top-level overhead. This is common in languages that lean into value semantics (even in heap-only contexts).
• It’s not mandatory: Many heap-only languages (like Java) treat arrays as objects with explicit overhead—for example, a Java array has a length field and a type metadata pointer. That’s a design choice, not a requirement of being heap-only.

The key takeaway: Stack allocation isn’t the only way to get compact object layouts. Heap-only languages can skip language-level overhead by designing types (like arrays) to be compact, with allocator metadata staying hidden at the implementation level.

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