c++ - 自定义智能指针代码问题 - 智能指针不能在堆上结束吗？

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

what would then manage the memory of the shared pointer?

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

Shouldnt dynamic memory allocation of the custom smart pointer itself be prevented?

不，绝对不是。例如，如果用户想要一个持有智能指针的智能指针怎么办？或任何其他可能的场景。同样，这绝对不是您的问题，如果有人想以这种方式使用您的类(class)，则与您无关。