C++ C++；有人对这种指针了解得更多吗？

我有一个世界级和一个实体级。 世界级创建新的实体并保留指向它的指针。 如果我使用该指针，我永远无法确定该指针是否仍然指向有效的实体，但我也不想使用共享的ptr，因为在所有共享的ptr被释放之前，该实体不会被删除。过了一段时间，我找到了这个指针：

#include <iostream>
#include <unordered_map>

template<class T>
class Pointer
{
public:

    Pointer() :m_ptr(nullptr){}
    Pointer(T*p) :m_ptr(p) { m_ptr->addPtr(this); }

    ~Pointer() { if(valid()) m_ptr->removePtr(this); }

    Pointer(const Pointer &other) :m_ptr(other.m_ptr) 
    {
        if(valid())
            m_ptr->addPtr(this);
    }

    Pointer& operator=(const Pointer& other)
    {
        if (valid())
            m_ptr->removePtr(this);

        m_ptr = other.m_pObj;

        if (valid())
            m_ptr->addPtr(this);

        return *this;
    }

    T* operator->() { return m_ptr; }
    T* operator*() { return *m_ptr; }

    T* get() { return m_ptr; }
    bool valid() { return m_ptr != nullptr; }

private:

    template<typename T>
    friend class PointerCollector;

    T * m_ptr;

};

template <class T>
class PointerCollector
{
public:

    PointerCollector() = default;
    virtual ~PointerCollector()
    {
        for (auto &x : m_ptrList)
        {
            (x.second)->m_ptr = nullptr;
        }
    }

private:

    void addPtr(Pointer<T> *ptr)
    {
        m_ptrList[ptr] = ptr;
    }
    void removePtr(Pointer<T> *ptr)
    {
        m_ptrList.erase(ptr);
    }

    template<typename T>
    friend class Pointer;

    std::unordered_map<Pointer<T>*, Pointer<T>*> m_ptrList;
};


class Test : public PointerCollector<Test>
{
public:
    Test() {}
    ~Test() = default;

    int getVal() { return m_val; }

private:

    int m_val = 100;
};



void func(Pointer<Test> ptr)
{
    if (ptr.valid())
    {
        std::cout << ptr->getVal();
    }
    else
    {
        std::cout << "Invalid!\n";
    }

}

int main()
{
    Test* myTest = new Test();

    Pointer<Test> myPtr(myTest);
    Pointer<Test> myPtr2(myPtr);

    delete myTest;

    func(myPtr2);


    getchar();
    return 0;
}

#包括
#包括
模板
类指针
{
公众：
指针（）：m_ptr（nullptr）{}
指针（T*p）：m_ptr（p）{m_ptr->addPtr（this）；}
~Pointer（）{if（valid（））m_ptr->removePtr（this）；}
指针（常量指针和其他）：m_ptr（其他.m_ptr）
{
if（valid（））
m_ptr->addPtr（本）；
}
指针和运算符=（常量指针和其他）
{
if（valid（））
m_ptr->removePtr（本）；
m_ptr=其他m_pObj；
if（valid（））
m_ptr->addPtr（本）；
归还*这个；
}
T*运算符->（）{return m_ptr；}
T*运算符*（）{return*m_ptr；}
T*get（）{return m_ptr；}
bool valid（）{return m_ptr！=nullptr；}
私人：
模板
朋友类指针收集器；
T*m_ptr；
};
模板
类指针收集器
{
公众：
PointerCollector（）=默认值；
虚拟~PointerCollector（）
{
用于（自动和x:m_ptrList）
{
（x.second）->m_ptr=nullptr；
}
}
私人：
void addPtr（指针*ptr）
{
m_ptrList[ptr]=ptr；
}
void removePtr（指针*ptr）
{
m_ptrList.erase（ptr）；
}
模板
朋友类指针；
std：：无序地图m_ptrList；
};
类测试：公共PointerCollector
{
公众：
Test（）{}
~Test（）=默认值；
int getVal（）{return m_val；}
私人：
int m_val=100；
};
无效函数（指针ptr）
{
if（ptr.valid（））
{
std:：coutgetval（）；
}
其他的
{
std：：cout答案是肯定的，这个模式以前已经被很多人使用过。你只是创建了一个糟糕的（而且是坏的，因为至少有一个完全错误和一些次优的东西）您应该考虑使用它。
您在开头段落中描述的用例将返回一个<代码> SydDypTr>代码>，世界持有一个<代码>弱小PTR <代码>代码中的“代码>世界> /代码>和<代码>实体< /代码>，您所发布的代码不编译，这对P有帮助。您实际编译和测试的ost代码；并且还提供了代码应该是什么的说明docodereview.stackexchange.com对于这个问题将是一个更好的地方
指针
需要一个从
指针收集器
中移除自身的析构函数。如前所述，
指针收集器
可能最终会挂起引用并且，您可以使用
unordered\u set
来代替
unordered\u map
——此时，该值始终与键相同，并且是冗余的。