自定义引用计数指针在创建后立即调用析构函数

如何解决自定义引用计数指针在创建后立即调用析构函数

我目前正在阅读 David H. Eberly 所著的“3D 游戏引擎架构”一书，并决定实现我自己的小引用计数智能指针。我主要遵循他的实施，但我的实施遇到了问题。

我创建了一个名为“CreateRef”的函数，它返回一个指针。当我在与我创建的对象相同的范围内使用这个函数时，一切都很好，但是当我将对象放入全局范围时，它会在创建后立即销毁对象。

class Object
{
public:
    void IncrementReferences()
    {
        ++m_References;
    }
    void DecrementReferences()
    {
        if(--m_References == 0) delete this;
    }
    int GetReferenceCount() const { return m_References; }

private:
    int m_References = 0;
};

template<class T>
class Pointer
{
public:
    //costr and destr
    Pointer(T* pObject = nullptr)
    {
        m_pObject = pObject;
        if (m_pObject)
            m_pObject->IncrementReferences();
    }

    Pointer(const Pointer& rPointer)
    {
        m_pObject = rPointer.m_pObject;
        if (m_pObject)
            m_pObject->IncrementReferences();
    }

    ~Pointer()
    {
        if (m_pObject)
            m_pObject->DecrementReferences();
    }

    // implicit conversions
    operator T* () const
    {
        return m_pObject;
    }
    T& operator* () const
    {
        return *m_pObject;
    }
    T* operator-> () const
    {
        return m_pObject;
    }

    // Assignment
    Pointer& operator= (T* pObject)
    {
        if (m_pObject != pObject)
        {
            if (pObject)
                pObject->IncrementReferences();

            if (m_pObject)
                m_pObject->DecrementReferences();

            m_pObject = pObject;
        }
        return *this;
    }
    Pointer& operator= (const T* rReference)
    {
        if (m_pObject != rReference)
        {
            if (rReference)
                rReference->IncrementReferences();

            if (m_pObject)
                m_pObject->DecrementReferences();

            m_pObject = rReference;
        }
        return *this;
    }

    // Comparisons
    bool operator== (T* pObject) const { return m_pObject == pObject; }
    bool operator!= (T* pObject) const { return m_pObject != pObject; }
    bool operator== (const Pointer& rReference) const { return m_pObject == rReference.m_pObject; }
    bool operator!= (const Pointer& rReference) const { return m_pObject != rReference.m_pObject; }

protected:
    // The shared object
    T* m_pObject;
};

template<typename T>
using Ref = Pointer<T>;

template<typename T,typename ...Args>
constexpr Ref<T> CreateRef(Args&&... args)
{
    return Ref<T>(new T(args...));
}

主要

static Ref<Person> person = nullptr; // Doesn't work like this

static void DoSomething()
{
    person = CreateRef<Person>("Name");
    std::cout << "References " << person->GetReferenceCount() << std::endl;

    Ref<Person> newPerson = person;
    std::cout << "References " << newPerson->GetReferenceCount() << std::endl;
}

int main()
{
    DoSomething();

    std::cout << person->GetReferenceCount();
}

我感觉我在“指针”类中做错了什么，但我不太明白我错过了什么。

解决方法

感谢您的帮助。我找到了两种解决问题的方法。

第一个解决方案是在 Pointer 类中添加一个复制赋值运算符。

Pointer& operator= (Pointer& rPointer)
    {
        if (m_pObject != rPointer.m_pObject)
        {
            if (rPointer)
                rPointer.m_pObject->IncrementReferences();

            if (m_pObject)
                m_pObject->DecrementReferences();

            m_pObject = rPointer.m_pObject;
        }
        return *this;
    }

另一个解决方案（尽管不是我想要的）是将 CreateRef() 函数的返回类型更改为 T*

template<typename T,typename ...Args>
constexpr T* CreateRef(Args&&... args)
{
    return new T(args...);
}