std::tr1::shared_ptr 是如何实现的？

Question

我一直在考虑使用共享指针，我知道如何自己实现一个--不想这样做，所以我正在尝试std::tr1::shared_ptr，我有几个问题...

引用计数是如何实现的？它使用双向链表吗？ （顺便说一句，我已经用谷歌搜索了，但我找不到任何可靠的东西。）

使用std::tr1::shared_ptr有什么陷阱吗？

Answer 1

shared_ptr 类通常包含两个成员：T*（由operator-> 返回并在operator* 中取消引用）和aux*，其中aux 是一个内部抽象类，包含：

• 一个计数器（在复制分配/销毁时增加/减少）
• 使增量/减量原子化所需的一切（如果特定平台原子 INC/DEC 可用，则不需要）
• 摘要virtual destroy()=0;
• 一个虚拟析构函数。

这样的aux 类（实际名称取决于实现）是由一系列模板化类派生的（根据显式构造函数给出的类型进行参数化，比如从T 派生的U），添加：

• 指向对象的指针（与T* 相同，但具有实际类型：这是正确管理T 的所有情况所必需的，因为U 在派生中有多个T层次结构）
• deletor 对象的副本作为删除策略提供给显式构造函数（或默认的 deletor 只是执行删除 p，其中 p 是上面的 U*）
• destroy 方法的覆盖，调用删除器函子。

一个简化的草图可以是这个：

template<class T>
class shared_ptr
{
    struct aux
    {
        unsigned count;

        aux() :count(1) {}
        virtual void destroy()=0;
        virtual ~aux() {} //must be polymorphic
    };

    template<class U, class Deleter>
    struct auximpl: public aux
    {
        U* p;
        Deleter d;

        auximpl(U* pu, Deleter x) :p(pu), d(x) {}
        virtual void destroy() { d(p); } 
    };

    template<class U>
    struct default_deleter
    {
        void operator()(U* p) const { delete p; }
    };

    aux* pa;
    T* pt;

    void inc() { if(pa) interlocked_inc(pa->count); }

    void dec() 
    { 
        if(pa && !interlocked_dec(pa->count)) 
        {  pa->destroy(); delete pa; }
    }

public:

    shared_ptr() :pa(), pt() {}

    template<class U, class Deleter>
    shared_ptr(U* pu, Deleter d) :pa(new auximpl<U,Deleter>(pu,d)), pt(pu) {}

    template<class U>
    explicit shared_ptr(U* pu) :pa(new auximpl<U,default_deleter<U> >(pu,default_deleter<U>())), pt(pu) {}

    shared_ptr(const shared_ptr& s) :pa(s.pa), pt(s.pt) { inc(); }

    template<class U>
    shared_ptr(const shared_ptr<U>& s) :pa(s.pa), pt(s.pt) { inc(); }

    ~shared_ptr() { dec(); }

    shared_ptr& operator=(const shared_ptr& s)
    {
        if(this!=&s)
        {
            dec();
            pa = s.pa; pt=s.pt;
            inc();
        }        
        return *this;
    }

    T* operator->() const { return pt; }
    T& operator*() const { return *pt; }
};

如果需要weak_ptr 互操作性，aux 中需要第二个计数器 (weak_count)（将按 weak_ptr 递增/递减），并且 delete pa 必须仅在两个计数器都达到零时发生。

Answer 2

引用计数是如何实现的？

可以使用policy-based class design¹将智能指针实现解构为：

• 存储策略

• 所有权政策

• 转化政策

• 检查政策

作为模板参数包含在内。 流行的所有权策略包括：深度复制、引用计数、引用链接和破坏性复制。

引用计数跟踪指向（拥有²）同一对象的智能指针的数量。当数字变为零时，指针对象被删除³。实际的计数器可能是：

1. 在智能指针对象之间共享，其中每个智能指针都保存一个指向引用计数器的指针：

1. 仅包含在为指针对象添加额外间接级别的附加结构中。在这里，在每个智能指针中保存一个计数器的空间开销与访问速度较慢进行了交换：

1. 包含在指针对象本身中：侵入式引用计数。缺点是必须先验地构造对象，并提供计数功能：

2. 最后，您问题中的方法，使用双向链表的引用计数称为引用链接，它：

...[1]依赖于您实际上并不需要指向一个指针对象的智能指针对象的实际计数的观察；您只需要检测该计数何时降至零。这导致了保留“所有权列表”的想法：

引用链接相对于引用计数的优势在于前者不使用额外的空闲存储，这使得它更加可靠：创建引用链接的智能指针不会失败。缺点是 该引用链接需要更多内存来记账（三个指针而不是一个指针加一个整数）。此外，引用计数应该更快一些——当你复制智能指针时，只需要一个间接和一个增量。列表管理稍微复杂一些。综上所述， 仅当免费商店稀缺时才应使用参考链接。否则，更喜欢引用计数。

关于你的第二个问题：

它 (std::shared_ptr) 是否使用双向链表？

我能在 C++ 标准中找到的只有：

20.7.2.2.6 shared_ptr 创建
...
7. [注意：这些函数通常会分配比sizeof(T)更多的内存，以允许内部簿记结构，例如引用计数。 ——尾注]

在我看来，这不包括双向链表，因为它们不包含实际计数。

你的第三个问题：

使用std::shared_ptr有什么陷阱吗？

引用管理无论是计数还是链接都是被称为循环引用的资源泄漏的受害者。让我们有一个对象 A 持有指向对象 B 的智能指针。此外，对象 B 持有指向 A 的智能指针。这两个对象形成循环引用；即使您不再使用它们中的任何一个，它们也会相互使用。引用管理策略无法检测到这样的循环引用，两个对象永远保持分配状态。

因为shared_ptr 的实现使用引用计数，循环引用可能是个问题。可以通过更改代码来破坏循环的shared_ptr 链，以便引用之一是weak_ptr。这是通过在共享指针和弱指针之间分配值来完成的，但是弱指针不会影响引用计数。如果指向对象的唯一指针是弱指针，则该对象被销毁。

---

^{1.如果制定为策略，则每个设计功能都具有多种实现。}

^{2。智能指针与指向以new 分配的对象的指针类似，不仅指向该对象，还负责其销毁和释放其占用的内存。}

^{3。没有其他问题，如果没有使用其他原始指针和/或指向它。}

[1] 现代 C++ 设计：应用通用编程和设计模式。安德烈亚历山德雷斯库，2001 年 2 月 1 日

Answer 3

如果您想查看所有血腥细节，可以查看 boost shared_ptr 实现：

https://github.com/boostorg/smart_ptr

引用计数似乎通常使用计数器和特定于平台的原子递增/递减指令或使用互斥锁的显式锁定来实现（参见detail namespace 中的atomic_count_*.hpp 文件）。

Answer 4

使用std::tr1::shared_ptr有什么陷阱吗？

是的，如果您在共享内存指针中创建循环，那么当最后一个指针超出范围时，智能指针管理的内存将不会被回收，因为仍然存在对指针的引用（即循环导致引用计数不会下降到零）。

例如：

struct A
{
    std::shared_ptr<A> ptr;
};

std::shared_ptr<A> shrd_ptr_1 = std::make_shared(A());
std::shared_ptr<B> shrd_ptr_2 = std::make_shared(A());
shrd_ptr_1->ptr = shrd_ptr_2;
shrd_ptr_2->ptr = shrd_ptr_1;

现在，即使shrd_ptr_1 和shrd_ptr_2 超出范围，它们管理的内存也不会被回收，因为它们的ptr 成员都指向彼此。虽然这是这种内存循环的一个非常幼稚的示例，但如果您在没有任何纪律的情况下使用这些类型的指针，它可能会以更加邪恶和难以跟踪的方式发生。例如，我可以看到在哪里尝试实现一个循环链表，其中每个next 指针都是一个std::shared_ptr，如果你不太小心的话，可能会导致问题。