Автономная реализация shared_ptr <T>?

Question

Кто-нибудь знает об автономной реализации TR1 shared_ptr (и, возможно, других интеллектуальных указателей) с открытым исходным кодом, которую я могу использовать в своих программах?* «Автономная реализация shared_ptr» означает shared_ptr Сам должен быть автономным.
Не только включающийбиблиотека.

Так что, пожалуйста, без ускорения !

Answer 1

Вы можете довольно легко взломать заголовок sharedptr.h в wxWidgets, чтобы удалить несколько макрос-зависимостей (assert, ключевое слово "manifest" и т. Д.).Затем вам нужно заменить или удалить атомарный inc / dec внутренней переменной подсчета ссылок.Переименуйте шаблон и вставьте его в пространство имен.Тогда у вас будет отдельная версия файла shared_ptr в отдельном файле.

Преимущество этого в том, что изменяемый вами источник широко используется и проверен коллегами.

Answer 2

Реализация надстройки shared_ptr полностью предназначена только для заголовков, поэтому для ее установки достаточно просто загрузить boost и добавить его в пути поиска заголовков вашего компилятора.Это не сложнее с boost, чем с любой другой автономной реализацией.Если вы хотите извлечь только компонент shared_ptr для создания отдельного дистрибутива, вы можете использовать Boost BCP .

Answer 3

Вы можете использовать Boost BCP для извлечения компонентов из Boost.

Answer 4

Я сам искал такую ​​вещь - как и у вас, у меня есть проект, в котором использование огромных пачек Boost совершенно неприемлемо.

Я нашел это:

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

Я не имею представления о качестве кода, так как это GPL2, что означает, что я не могу использовать его в своем проприетарном коде, но, похоже, у него нет никаких зависимостей. Но, похоже, это ответ на ваш вопрос.

Answer 5

Да, я думаю, что то, что я сделал сам, может быть даже лучше, чем 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, ИМХО.

Есть ли у него какие-либо подводные камни, которые я пропустил (кроме очевидной небезопасности потока)?

Любая (конструктивная) критика приветствуется.