Question

以下是我正在阅读的C ++书中的一些代码，展示了如何创建自己的智能指针：

template <typename T>
class SuperSmartPointer
{
    public:
        explicit SuperSmartPointer(T* inPtr);
        virtual ~SuperSmartPointer();
        SuperSmartPointer(const SuperSmartPointer<T>& src);
        SuperSmartPointer<T>& operator=(const SuperSmartPointer<T>& rhs);
        const T& operator*() const;
        const T* operator->() const;
        T& operator*();
        T* operator->();
        operator void*() const { return mPtr; }
    protected:
        T* mPtr;
        static std::map<T*, int> sRefCountMap;
        void finalizePointer();
        void initPointer(T* inPtr);
};

template <typename T>
std::map<T*, int> SuperSmartPointer<T>::sRefCountMap;

template <typename T>
SuperSmartPointer<T>::SuperSmartPointer(T* inPtr)
{
    initPointer(inPtr);
}

template <typename T> SuperSmartPointer<T>::SuperSmartPointer(const SuperSmartPointer<T>& src)
{
    initPointer(src.mPtr);
}

template <typename T>
SuperSmartPointer<T>& SuperSmartPointer<T>::operator=(const SuperSmartPointer<T>& rhs)
{
    if (this == &rhs) {
        return *this;
    }
    finalizePointer();
    initPointer(rhs.mPtr);
    return *this;
}

template <typename T>
SuperSmartPointer<T>::~SuperSmartPointer()
{
    finalizePointer();
}

template<typename T>
void SuperSmartPointer<T>::initPointer(T* inPtr)
{
    mPtr = inPtr;
    if (sRefCountMap.find(mPtr) == sRefCountMap.end()) {
        sRefCountMap[mPtr] = 1;
    } else {
        sRefCountMap[mPtr]++;
    }
}

template<typename T>
void SuperSmartPointer<T>::finalizePointer()
{
    if (sRefCountMap.find(mPtr) == sRefCountMap.end()) {
        throw std::runtime_error(“ERROR: Missing entry in map!”);
    }
    sRefCountMap[mPtr]--;
    if (sRefCountMap[mPtr] == 0) {
        // No more references to this object--delete it and remove from map
        sRefCountMap.erase(mPtr);
        delete mPtr;
        mPtr = nullptr;
    }
}

template <typename T>
const T* SuperSmartPointer<T>::operator->() const
{
    return mPtr;
}

template <typename T>
const T& SuperSmartPointer<T>::operator*() const
{
    return *mPtr;
}

template <typename T>
T* SuperSmartPointer<T>::operator->()
{
    return mPtr;
}

template <typename T>
T& SuperSmartPointer<T>::operator*()
{
    return *mPtr;
}

我对这个代码/我的问题的问题是，肯定有人可以使用new()运算符实例化这个智能指针类的对象，在堆上有智能指针，因此然后管理内存共享指针？要使new()运算符过载/阻止，使其成为正确的共享指针？

编辑：是否应该阻止自定义智能指针本身的动态内存分配？

Answer 1

然后管理共享指针的内存是什么？

用户选择使用new分配智能指针。他们有可用的工具来避免手动内存管理（例如智能指针）。他们选择不使用它们，这不是你的问题。

不应该自定义智能指针本身的动态内存分配被阻止？

不，绝对没有。例如，如果用户想要一个智能指针拿着智能指针怎么办？或任何其他可能的场景。同样，这绝对不是你的问题，如果有人想以这种方式使用你的课程，那么你的业务就没有了。

Answer 2

我对这个代码的问题/我的问题是肯定有人可以使用new（）运算符实例化这个智能指针类的对象，在堆上有智能指针，因此然后管理共享指针的内存??

是的，他们可以，然后他们必须自己管理共享指针或者有一个管理共享指针的共享指针！

但这不是问题本身;人们根本就不这样做。

自定义智能指针代码问题 - 无法智能指针最终在堆上？

2 个答案: