为何shared_ptr优先采用堆分配引用计数而非静态类变量实现？

Great question—this cuts right to the core of how smart pointers manage ownership, and your initial hunch is totally correct! Let’s break this down in plain terms:

The Problem with Static Class Variables #

Static class variables are shared across every instance of a class. That means no matter how many shared_ptr objects you create, there would only be one single reference count value for the entire shared_ptr class. This is a total dealbreaker because:

• If you have two completely separate objects (say, a User instance and a Product instance) being managed by shared_ptrs, all those pointers would increment/decrement the same static count. You’d have no way to track how many pointers are pointing to the User vs the Product.
• When the count hit zero, you wouldn’t even know which object to destroy—since the count isn’t tied to a specific managed instance.

Static variables make sense when you need a value shared by all instances of a class, but shared_ptr needs the exact opposite: a unique count per managed object, not per smart pointer class.

Why Heap-Allocated Reference Counts Work #

Heap-allocated reference counts solve this problem perfectly:

• Every time you create a shared_ptr that owns a new object, a separate reference count block is allocated on the heap. This block is directly linked to the specific object being managed.
• All subsequent shared_ptrs that point to the same object (like when you copy a shared_ptr) will share this same heap-allocated count. They increment/decrement this specific count, not a global one.
• When the count drops to zero, the shared_ptr knows exactly which object to destroy (the one tied to the count block), and then it cleans up the count block itself.

As an extra perk, this approach is super flexible: it works with any type of object, even if the object’s class doesn’t have built-in support for reference counting (like objects from third-party libraries you can’t modify). You don’t need to add a count member variable to every class you want to manage with shared_ptr—the heap block handles it externally.

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