C++ 指向已销毁类无效的指针

我有一个很多指针指向的对象。他们经常试图访问数据。然而，在某个时刻，这个物体可能会被摧毁。如何在销毁对象后立即有效地更新这些指针，使它们不会指向未分配的内存并导致未定义的行为？

我的想法是列出需要更新到

nullptr

的指针。这将在对象的析构函数中调用。丑陋的混乱和大量的工作，为每一件事，可能被处置

也许这些智能指针在这些情况下有一些用处（从未使用过它们）。C++程序员如何处理这样的事情？

你只需要使用./p>

shared\u ptr

非常聪明，你不需要删除它们，当没有人再引用它们时，它们会被删除。然后，与此

共享的

相关的任何

弱的

都会被通知，并且不会有访问未分配内存的风险

需要时，

弱\u ptr

将尝试

锁定（）

并创建本地

共享\u ptr

。如果原始的

shared\u ptr

被删除，

lock（）

将无法创建本地

shared\u ptr

，您将安全地知道原始指针已被删除

// Example program
#include <iostream>
#include <assert.h>
#include <memory>

int main()
{
    std::shared_ptr<int> pI( new int(3) );
    std::weak_ptr<int> wI( pI );

    {
        // check if weak_ptr still "points" to some valid data:
        std::shared_ptr<int> pICopy = wI.lock();
        assert( pICopy != NULL );
        std::cout << "pI still valid " << *pICopy << std::endl;
    }

    pI.reset(); // this is equivalent to regular delete with shared_ptr

    {
        // check if weak_ptr does not "point" to any valid data:
        std::shared_ptr<int> pICopy = wI.lock();
        assert( pICopy == NULL );
        std::cout << "pI not valid anyore" << std::endl;
    }
}

//示例程序
#包括
#包括
#包括
int main（）
{
std:：shared_ptr pI（新int（3））；
标准：弱ptr wI（pI）；
{
//检查弱ptr是否仍然“指向”某些有效数据：
std:：shared_ptr pICopy=wI.lock（）；
断言（pICopy！=NULL）；
std：：cout您只需使用和

shared_ptr
非常智能，您不需要删除它们，当没有人再引用它们时，它们会被删除。然后，与此
shared_ptr
相关的任何
弱_ptr
都会被通知，并且不会有访问未分配内存的风险

需要时，
弱\u ptr
将尝试
锁定（）
并创建本地
共享\u ptr
。如果原始
共享\u ptr
被删除，
锁定（）
将无法创建本地
共享\u ptr
，您将安全地知道原始指针已被删除

// Example program
#include <iostream>
#include <assert.h>
#include <memory>

int main()
{
    std::shared_ptr<int> pI( new int(3) );
    std::weak_ptr<int> wI( pI );

    {
        // check if weak_ptr still "points" to some valid data:
        std::shared_ptr<int> pICopy = wI.lock();
        assert( pICopy != NULL );
        std::cout << "pI still valid " << *pICopy << std::endl;
    }

    pI.reset(); // this is equivalent to regular delete with shared_ptr

    {
        // check if weak_ptr does not "point" to any valid data:
        std::shared_ptr<int> pICopy = wI.lock();
        assert( pICopy == NULL );
        std::cout << "pI not valid anyore" << std::endl;
    }
}

//示例程序
#包括
#包括
#包括
int main（）
{
std:：shared_ptr pI（新int（3））；
标准：弱ptr wI（pI）；
{
//检查弱ptr是否仍然“指向”某些有效数据：
std:：shared_ptr pICopy=wI.lock（）；
断言（pICopy！=NULL）；
标准：：cout
丑陋的混乱和大量的工作，为每一件事，可能被处置

好吧，不要在析构函数中进行清理。创建一个单独的函数并在析构函数中调用它。您可以从其他对象的析构函数中调用此公共清理函数

丑陋的混乱和大量的工作，为每一件事，可能被处置

好的，不要在析构函数中进行清理。创建一个单独的函数并在析构函数中调用它。您可以从其他对象的析构函数中调用此公共清理函数。
，更具体地说，引用计数如何？更具体地说，引用计数如何？这正是我想要的。猜猜该学习了一个新的指针系统…这正是我想要的。我想是时候学习一个新的指针系统了。。。