自定义智能指针代码issue- couldnt智能指针最终在堆上？

这里是从C一些代码++的书，我一直在阅读展示了如何创建自己的智能指针：自定义智能指针代码issue- couldnt智能指针最终在堆上？

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()运算符被过载/阻止，要使其成为正确的共享指针？

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

来源

2013-12-12 user997112

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

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

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

不，绝对不是。例如，如果用户想要一个智能指针来保存智能指针，那该怎么办？或者其他任何可能的情况。再说一次，这绝对不是你的问题，如果有人想以这种方式使用你的班级，那么你的业务就不存在。

来源

2013-12-12 17:26:54

好的 - 我明白了你的观点。谢谢 – user997112

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

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

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

来源

2013-12-12 17:29:50

自定义智能指针代码issue- couldnt智能指针最终在堆上？

回答

相关问题