C++ 在没有其他智能指针的情况下创建弱\u ptr

设a类和B类。a类的每个实例拥有0到N个B类实例。当删除a的实例时，B的实例也会被删除

例如：

class parent
{
private:

    vector< unique_ptr< child > > m_children;

public:

    weak_ptr< child > create_child()
    {
        m_children.push_back( move( make_unique< child >( ??? ) ) );
        return m_children.back();
    }
};

class child
{
private:

    weak_ptr< parent > m_parent;

public:

    child( weak_ptr< parent > parent ) : m_parent( parent ) { }
};

类父类
{
私人：
向量>m_child；
公众：
弱\u ptrcreate\u child（）
{
m_children.向后推（移动（使_独特（？））；
返回m_children.back（）；
}
};
班童
{
私人：
弱ptrm_-parent；
公众：
子级（弱父级）{}
};

你可以，让一个

共享的\u ptr

使用该指针手动创建一个

子

。但是，在类

parent

的范围内，我们所拥有的只是

this

，而不是

shared\u ptr

到

this

，因为我们不知道存储了

parent

实例，因此我们无法从这个

shared\u ptr

中创建一个我们没有的

弱ptr

---

因此，我的问题是：如何在

子类

范围内检查

父类

实例在使用前是否未被释放？创建

子项时如何返回“安全”指针？谢谢。
在您的代码中，父对象拥有所有子对象，并将在调用父对象的析构函数后销毁它们。因此，如果在父线程被销毁后（可能在另一个线程中），子实例仍然在执行，那么子实例已经无效，您无法安全地检测这种情况

为了避免父对象“过早死亡”，可以向子类引入互斥来同步线程，如下所示：

class child
{
private:
  std::mutex m_mutex;
  bool m_stopflag = false;
public:
  void execute() {
    std::unique_lock<std::mutex> lock (m_mutex);
    while (!m_stopflag) {
       //doing something        
    }
  }

  ~child() {
    m_stopflag = true;
    m_mutex.lock();
    m_mutex.unlock();
  }
}

类子类
{
私人：
std:：mutex m_mutex；
bool m_stopflag=false；
公众：
void execute（）{
std：：唯一的_锁（m_互斥）；
而（！m_stopflag）{
//做某事
}
}
~child（）{
m_stopflag=真；
m_mutex.lock（）；
m_mutex.unlock（）；
}
}

但是，如果我对您的问题的猜测是错误的，并且您的问题实际上不是关于停止线程，而是关于实现一些保护，以防止已销毁的“child”对象的方法调用，那么，可能没有什么可以提出的——C++运行时不能这样做。< < /> P>不能从<代码> UnQuyPPTR <代码>获得<代码>弱小PTR <代码>，仅从<代码> SyddypTr> /Cord>中。您可能正在寻找。为什么<代码> CueLeIdSue<代码>需要返回弱指针？为什么不能返回一个普通指针？你说你想要一个安全的指针，但是为什么简单的指针在你的情况下不安全呢？智能指针并不是一种将所有责任委托给运行时的便捷方式：你应该理解你试图解决的问题，并且只有当一个问题不能以确定的方式解决时（例如：需要多个线程的生存期），然后，您需要智能引用计数和
弱ptr
，因为
子级
在
父级
中存储为
唯一的\u ptr
，所以在
子级
类范围内检查
父级
已被释放是没有意义的，因为当
父级
被释放时它已经被破坏。我假设您的意思是在使用指向它的指针之前自动检查
子实例的存在性。如果我是正确的，那么对于返回
shared\u ptr
的父级，您需要的不仅仅是一个工厂。还是说
唯一的\u ptr
只是对这个问题的真正代码的过度简化？