自定義智能指針代碼issue- couldnt智能指針最終在堆上？

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

什麼會然後管理共享指針的內存？

用戶選擇分配新的智能指針。他們有可用的工具來避免手動內存管理（如智能指針）。他們選擇不使用它們，那不是你的問題。

不應該動態內存分配的自定義智能指針本身 被阻止？

不，絕對不是。例如，如果用戶想要一個智能指針來保存智能指針，那該怎麼辦？或者其他任何可能的情況。再說一次，這絕對不是你的問題，如果有人想以這種方式使用你的班級，那麼你的業務就不存在。

Answer 2

這個代碼/我的問題的問題是，肯定有人可以使用new（）運算符實例化這個智能指針類的對象，在堆上有智能指針，因此會管理內存共享指針？

是的，他們可以，然後他們必須自己管理共享指針或者擁有共享指針來管理共享指針！

但這不是問題本身;人們根本就不這樣做。