独立的shared_ptr;执行？

Question

有谁知道我可以在程序中使用 TR1 shared_ptr （也许还有其他智能指针）的开源独立实现？

---

注意：

“shared_ptr 的独立实现”表示shared_ptr本身需要是独立的。
不仅仅是包含库。

所以请不要提升！

Answer 1

shared_ptr 的 boost 实现完全是头文件，因此安装 boost 来使用它就像下载 boost 并将其添加到编译器的头文件搜索路径一样简单。使用 boost 实现这一点并不比任何其他独立实现更难。如果您只想提取 shared_ptr 组件来进行单独的分发，那么您可以使用 增强 BCP。

Answer 2

你可以很容易地修改 wxWidgets 中的sharedptr.h 头来删除一些宏依赖项（assert、“explicit”关键字等）。然后，您需要替换或删除内部引用计数变量的原子递增/递减。重命名模板并将其粘贴到命名空间中。然后您将拥有一个单文件独立版本的shared_ptr。

这样做的优点是您正在修改的源代码已经得到了广泛的使用和同行评审。

Answer 3

您可以使用 Boost BCP 从 Boost 中提取组件。

Answer 4

呵呵，我想我自己做的东西可能比 shared_ptr 更好：

template<typename T>
class auto_
{
    T *pValue;
    mutable const auto_<T> *pPrev, *pNext;

public:
    auto_()           : pValue(new T()),  pPrev(NULL), pNext(NULL) { }
    auto_(T *pValue)  : pValue(pValue),   pPrev(NULL), pNext(NULL) { }
    auto_(const T &v) : pValue(new T(v)), pPrev(NULL), pNext(NULL) { }

    auto_(const auto_<T> &o) : pValue(o.pValue), pPrev(&o), pNext(NULL)
    { o.pNext = this; }

    virtual ~auto_()
    {
        const auto_<T> *const pPrev = this->pPrev, *const pNext = this->pNext;
        if (pPrev != NULL) { pPrev->pNext = pNext; }
        if (pNext != NULL) { pNext->pPrev = pPrev; }
        if (pPrev == NULL && pNext == NULL) { delete this->pValue; }
        this->pPrev = this->pNext = NULL;
        this->pValue = NULL;
    }

    auto_<T>& operator=(const auto_<T>& other)
    {
        if (this != &other)
        {
            this->~auto_();
            this->pValue = other.pValue;
            this->pPrev = &other;
            this->pNext = other.pNext;
            if (other.pNext != NULL) { other.pNext->pPrev = this; }
            other.pNext = this;
        }
        return *this;
    }

    operator   T&() { return *this->pValue; }
    operator   T*() { return  this->pValue; }
    T* operator->() { return  this->pValue; }
    T& operator *() { return *this->pValue; }

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

};

示例用法：

template<typename T>
T recurse(T value, int depth)
{
    if (depth > 0) { T result = recurse(value, depth - 1); return result; }
    else { return value; }
}

auto_<int> test()
{
    printf("Value: %d\n", *recurse(auto_<int>(10), 3));
    auto_<int> p1 = recurse<auto_<int> >(5, 3);
    printf("Value: %d\n", *p1);
    auto_<int> p2 = 3;
    p1 = p2;
    p2 = p1;
    return p2;
}

它看起来比 shared_ptr 更容易使用，恕我直言。

它是否有任何我错过的陷阱（除了明显的线程不安全之外）？

任何（建设性的）批评表示赞赏。

Answer 5

我自己一直在寻找这样的东西——像你一样，我有一个项目，其中包含大量的 Boost 是完全不可接受的。

我发现了这个：

http://www. lri.fr/~marc/EO/eo/doc/html/shared__ptr_8h-source.html

我不知道代码质量，因为它是 GPL2，这意味着我不能在我的专有代码中使用它，但它似乎没有依赖性。但这似乎确实是你问题的答案。