如何分离`QObject`的父子关系的问题，例如与其他所有者互操作？

Question

考虑这个用例：当QObject的生命周期在其他地方进行管理时，例如通过C ++作用域生存期（作为局部变量，或作为类成员等），或者使用共享指针，其父级不应尝试在~QObject()析构函数中删除它。有没有办法真正将对象的所有权传递给共享指针，以便父级不会尝试删除它？

如果我们不打算拥有所有权，那么设置父母的原因是什么？它们的存在是因为父子关系在Qt中被用于多种目的，并且没有内置的方法来解耦它们：

1. [GC]父对象充当子对象的垃圾收集器：如果有对象存在，直到父对象被破坏，父对象将销毁并释放它们。
2. [Thread]子级的线程关联性遵循父级的。 当QObject开始支持多线程操作并获得thread属性时，这被添加到Qt 4。
3. [WidgetTree]窗口小部件使用父子关系作为窗口小部件树中的边缘。 除非小部件具有Qt::Window标志 - 然后它是顶级小部件，并且是其自己的小部件树的根，但仍然由父级垃圾收集。

当前的目标是将[GC]与其他功能分离，并允许每个对象禁用它。扩展的目标是将所有三个功能相互分离。

Answer 1

你不能。

你要求的是相当于指向同一资源的两个std::unique_ptrs。

一个是您的C ++自定义所有者，另一个是QObject父级。

对于你的一半问题，有一个中间解决方案：使用QPointer。此类包含QObject指针，但如果指向的QObject被销毁则设置为null。拥有WeakQObjectPtr的自定义QPointer类型RAII类可能会做你想要的。但这不能处理，例如类成员或局部变量。

你在Qt世界，遵守Qt规则，或者不使用它们。但后者并不总是可行的。

Answer 2

[GC]

我们可以拦截父级的~QObject()析构函数，并在删除该列表中的子对象之前从子列表中删除该对象。幸运的是，~QObject在删除孩子之前发出destroyed信号。

因此，要将对象的父级更改为非拥有父级，我们必须仅在重要时采取操作：当父级的析构函数被调用时。因此，我们

1. 拦截父母的destroyed信号并清除对象的父母。
2. 拦截失去孩子的父母，或者，如果父母没有收到这样的事件，拦截发送给孩子的事件并将其用作钝器以检测父母是否被改变。

这可以在独立的实用程序函数和帮助程序类中实现，而无需修改所涉及的任何对象的代码。

// https://github.com/KubaO/stackoverflown/tree/master/questions/qobject-sep-concerns-55046944
#include <QtWidgets>

class ParentTracker : public QObject {
   QMetaObject::Connection connection;
   QObject *subjectParent = nullptr;
   inline QObject *subject() const { return parent(); }
   bool eventFilter(QObject *receiver, QEvent *event) override {
      qDebug() << receiver << event->type();
      if (receiver == subject()) {
         // Track parent changes on the child
         if (subject()->parent() != subjectParent) {
            detachFromParent();
            attachToParent();
         }
      } else if (event->type() == QEvent::ChildRemoved) {
         // Track child changes on the parent
         Q_ASSERT(receiver == subjectParent);
         auto *ev = static_cast<QChildEvent *>(event);
         if (ev->child() == subject()) {
            detachFromParent();
         }
      }
      return false;
   }
   void lostParent() {
      subject()->setParent(nullptr);
      detachFromParent();
   }
   void detachFromParent() {
      if (subjectParent) {
         disconnect(connection);
         connection = {};  // free the connection handle immediately
         subjectParent->removeEventFilter(this);
         subjectParent = nullptr;
      }
   }
   void attachToParent() {
      Q_ASSERT(!subjectParent);
      subjectParent = subject()->parent();
      bool snoopChild = !subjectParent;
      {
         auto *widget = qobject_cast<QWidget *>(subject());
         snoopChild = snoopChild ||
                      (widget && widget->testAttribute(Qt::WA_NoChildEventsForParent));
      }

      if (subjectParent) {
         auto *widget = qobject_cast<QWidget *>(subjectParent);
         snoopChild = snoopChild ||
                      (widget && widget->testAttribute(Qt::WA_NoChildEventsFromChildren));
         connection = connect(subjectParent, &QObject::destroyed, this,
                              &ParentTracker::lostParent);
      }
      if (snoopChild)
         subject()->installEventFilter(this);
      else {
         Q_ASSERT(subjectParent);
         subject()->removeEventFilter(this);
         subjectParent->installEventFilter(this);
      }
   }

  public:
   explicit ParentTracker(QObject *child) : QObject(child) {
      Q_ASSERT(subject());
      attachToParent();
   }
};

ParentTracker *detachQObjectOwnership(QObject *child) {
   Q_ASSERT(child && (!child->thread() || child->thread() == QThread::currentThread()));
   QObject *parent = child->parent();
   if (!parent) return nullptr;
   if (parent->thread() != child->thread()) return nullptr;
   return new ParentTracker(child);
}

template <class T> void setup(QPointer<QObject> &parent, QPointer<QObject> &child) {
   parent = new T;
   child = new T(static_cast<T*>(parent.data()));
   parent->setObjectName("parent");
   child->setObjectName("child");
   Q_ASSERT(parent && child);
}

int main(int argc, char *argv[]) {
   QApplication app(argc, argv);
   QPointer<QObject> parent, child, tracker;

   // parent-child ownership
   setup<QObject>(parent, child);
   delete parent;
   Q_ASSERT(!parent && !child);

   // parent-child without ownership
   setup<QObject>(parent, child);
   tracker = detachQObjectOwnership(child);
   delete parent;
   Q_ASSERT(!parent && child && tracker);
   delete child;
   Q_ASSERT(!parent && !child && !tracker);
}