与原始指针兼容的（shared_ptr + weak_ptr）设计

Question

前言

在C ++ 11中，有std::shared_ptr + std::weak_ptr组合。 尽管它非常有用，但是它有一个令人讨厌的问题：您不能轻易地从原始指针构造shared_ptr 。 由于此缺陷，此类智能指针通常变得“病毒式”：人们开始完全避免使用原始指针和引用，并在整个代码中仅使用shared_ptr和weak_ptr智能指针。 因为无法将原始引用传递给需要智能指针的函数。

另一方面，存在boost::intrusive_ptr 。 它等效于std::shared_ptr并且可以很容易地从原始指针构造，因为引用计数器包含在对象中。 不幸的是，它没有弱伴侣，因此没有办法拥有非所有者引用，您可以检查它们是否无效。 实际上，有些人认为intrusive_ptr的弱伴侣是不可能的 。

现在，有std::enable_shared_from_this ，它直接将weak_ptr嵌入到您的类中，以便您可以从指向对象的指针构造shared_ptr。 但是有一个小的限制（至少必须存在一个shared_ptr），并且它仍然不允许明显的语法： std::shared_ptr(pObject) 。

另外，还有一个std::make_shared ，它在单个内存块中分配引用计数器和用户对象 。 这与intrusive_ptr的概念非常接近，但是可以独立于引用计数块来销毁用户的对象。 同样，此概念有一个不可避免的缺点：只有在所有weak_ptr-s都消失了时，才会释放整个内存块（可能很大）。

题

主要问题是：如何创建一对shared_ptr / weak_ptr，这对std::shared_ptr / std::weak_ptr和boost::intrusive_ptr都有好处？

尤其是：

1. shared_ptr对对象的共享所有权进行建模，即，当指向该对象的最后一个shared_ptr被销毁时，该对象将被销毁。
2. weak_ptr不会对对象的所有权建模，它可用于解决循环依赖问题。
3. 可以检查weak_ptr是否有效：当存在指向该对象的shared_ptr时有效。
4. 可以从有效的weak_ptr构造shared_ptr。
5. 可以从指向对象的有效原始指针构造weak_ptr。 如果存在至少一个弱指针仍指向该对象，则原始指针有效。 从无效的指针构造weak_ptr会导致未定义的行为。
6. 像上面提到的现有系统一样，整个智能指针系统应该是易于投射的。

可以进行侵入，即要求用户从给定的基类继承一次。 也可以在对象已被销毁时保留其内存。 拥有线程安全性非常好（除非效率太低），但是没有它的解决方案也很有趣。 每个对象分配几个内存块是可以的，尽管每个对象最好有一个内存块。

Answer 1

• 1-4和6点已经由shared_ptr / weak_ptr建模。

• 第5点毫无意义。 如果寿命是共享的，再有就是如果没有有效的对象weak_ptr存在，但一个shared_ptr没有。 任何原始指针将是无效的指针。 对象的生命周期已经结束。 该对象不再存在。

weak_ptr不会使对象保持活动状态，而是使控制块保持活动状态。 shared_ptr使控制块和受控对象都保持活动状态。

如果您不想通过组合控制块和受控对象来“浪费”内存，请不要调用make_shared 。

如果您不希望将shared_ptr<X>通过病毒传递给函数，请不要传递它。 将引用或const引用传递给X 如果您打算在函数中管理生命周期，则只需在参数列表中提及shared_ptr 。 如果只想对shared_ptr指向的内容执行操作，则传递*p或*p.get()并接受[const]引用。

Answer 2

在对象上覆盖new以在对象实例之前分配一个控制块。

这是伪入侵。 由于已知的偏移量，因此可以从原始指针转换为原始指针。 可以毫无问题地销毁该对象。

引用计数块具有强计数和弱计数，以及用于销毁该对象的功能对象。

缺点：它在多态方面不能很好地工作。

想象一下，我们有：

struct A {int x;};
struct B {int y;};
struct C:B,A {int z;};

然后我们以这种方式分配C

C* c = new C{};

并将其存储在A* ：

A* a = c;

然后，我们将其传递给A的智能指针。 它期望控制块紧接在a指向的地址之前，但是由于B在C的继承图中存在于A之前，因此那里有B的实例。

这似乎不理想。

---

所以我们作弊。 我们再次替换new 。 但是它改为在某处通过注册表注册指针值和大小。 我们在那里存储弱指针/强指针计数（等）。

我们依靠线性地址空间和类布局。 当我们有一个指针p ，我们只是寻找它在谁的地址范围内。然后我们知道了强/弱计数。

通常，这具有可怕的性能，尤其是多线程，并且依赖于未定义的行为（对于未指向同一对象的指针进行指针比较，或者在这种情况下，指针指向的顺序less ）。

Answer 3

从理论上讲，可以实现shared_ptr和weak_ptr侵入版本，但是由于C ++语言的限制，这可能是不安全的。

两个引用计数器（强和弱）存储在托管对象的基类RefCounters中。 任何智能指针（共享的或弱的）都包含指向托管对象的单个指针。 共享指针拥有对象本身，而共享+弱指针共同拥有对象的内存块。 因此，当最后一个共享指针消失时，对象将被销毁，但是只要有至少一个指向它的弱指针，它的内存块就会保持活动状态。 鉴于所有涉及的类型仍然从RefCounted类继承，因此转换指针可以按预期工作。

不幸的是，在C ++中，通常禁止在对象被销毁后与对象成员一起工作，尽管大多数实现应允许这样做而不会出现问题。 有关此方法的易读性的更多详细信息，可以在此问题中找到。

这是智能指针工作所需的基类：

struct RefCounters {
    size_t strong_cnt;
    size_t weak_cnt;
};
struct RefCounted : public RefCounters {
    virtual ~RefCounted() {}
};

这是共享指针定义的一部分（显示如何销毁对象以及如何释放内存块）：

template<class T> class SharedPtr {
    static_assert(std::is_base_of<RefCounted, T>::value);
    T *ptr;

    RefCounters *Counter() const {
        RefCounters *base = ptr;
        return base;
    }
    void DestroyObject() {
        ptr->~T();
    }
    void DeallocateMemory() {
        RefCounted *base = ptr;
        operator delete(base);
    }

public:
    ~SharedPtr() {
        if (ptr) {
            if (--Counter()->strong_cnt == 0) {
                DestroyObject();
                if (Counter()->weak_cnt == 0)
                    DeallocateMemory();
            }
        }
    }
    ...
};

带有示例的完整代码在此处 。