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

Question

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

我创建了一个名为'centereref'的函数，返回指针。当我在与我创建的对象相同的范围内使用此函数时，一切都很好，但是当我将对象置于全局范围内时，它会在创建后立即销毁该对象。

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();
}

我感觉我对“指针”类做错了，但我不太明白我缺少什么。

Answer 1

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

第一个解决方案是在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...);
}