对象树与内存管理 / QObject Trees and Memory Management

📅 创建时间：2026-07-13 🏷️ 标签：#Qt #QObject #MemoryManagement #ObjectTree #CAE #RAII 📚 前置知识：Qt Cpp Overview, Signal Slot Deep Dive

📋 本章目标

理解QObject父子所有权模型的原理和删除传播机制
掌握对象树的操作API：findChild、findChildren、setParent
理解deleteLater()的延迟删除机制及适用场景
掌握Qt智能指针（QPointer、QScopedPointer、QSharedPointer）与QObject的正确配合
理解Qt所有权 vs C++ RAII的边界，避免双重删除
能在CAE场景中管理复杂的模型层次（零件→体→特征→网格）
掌握内存泄漏的排查工具和方法

专题扩展

QObject 生命周期与线程亲和性

第1部分：QObject父子模型

1.1 为什么需要对象树

在GUI应用中，对象之间天然存在层次关系：

窗口 (QMainWindow)
├── 菜单栏 (QMenuBar)
│   ├── 文件菜单 (QMenu)
│   │   ├── 打开 (QAction)
│   │   └── 保存 (QAction)
│   └── 帮助菜单 (QMenu)
├── 工具栏 (QToolBar)
├── 中心区域 (QWidget)
│   ├── 3D视口 (QOpenGLWidget)
│   └── 属性面板 (QDockWidget)
└── 状态栏 (QStatusBar)

如果每个对象都需要手动new和delete：

cpp

// ❌ 手动管理：噩梦
auto* window   = new QMainWindow;
auto* menubar  = new QMenuBar(window);
auto* fileMenu = new QMenu("File", menubar);
auto* openAct  = new QAction("Open", fileMenu);
// ... 关闭窗口时需要手动 delete 所有对象？
// 漏一个 = 内存泄漏
// delete 顺序错了 = use-after-free

Qt的解决方案：对象树（Object Tree）

┌─────────────────────────────────────────────────────────────┐
│               QObject 对象树的所有权模型                      │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  规则1：构造时指定parent → parent拥有child的所有权           │
│         QPushButton* btn = new QPushButton("OK", parent);   │
│                                                             │
│  规则2：parent析构 → 自动delete所有children                 │
│         delete window; // 递归删除所有子对象                 │
│                                                             │
│  规则3：child可以先于parent被delete                          │
│         delete btn; // Qt自动从parent的child列表中移除       │
│                                                             │
│  规则4：一个child只能有一个parent                             │
│         btn->setParent(newParent); // 从旧parent移除，加入新 │
│                                                             │
│  删除顺序：叶子→根（后序遍历）                               │
│         QAction → QMenu → QMenuBar → QMainWindow            │
│         保证子对象先析构                                     │
│                                                             │
└─────────────────────────────────────────────────────────────┘

1.2 构造时指定parent

cpp

// ===== Qt 对象的创建模式 =====

// 模式1：栈对象（不需要parent，作用域结束自动析构）
void someFunction() {
    QFile file("data.txt");   // QFile 继承 QObject
    file.open(QIODevice::ReadOnly);
    // file 离开作用域自动析构，不需要在对象树中
}

// 模式2：堆对象 + parent（推荐，用于GUI对象）
MainWindow::MainWindow(QWidget* parent)
    : QMainWindow(parent)  // 传递parent给基类
{
    // 这些对象都不需要手动 delete
    m_viewport = new QOpenGLWidget(this);       // parent = this
    m_treePanel = new QTreeView(this);           // parent = this
    m_button = new QPushButton("Solve", this);  // parent = this
    // MainWindow析构时，这三个子对象自动被delete
}

// 模式3：堆对象 + 不指定parent（用于稍后setParent或moveToThread）
auto* worker = new SolverWorker;   // 无parent
worker->moveToThread(thread);       // 之后手动管理生命周期
// ... 完成时
worker->deleteLater();

1.3 QObject析构函数的删除传播

cpp

// QObject::~QObject() 的简化逻辑（源码在 qobject.cpp）：

QObject::~QObject()
{
    // 1. 从parent的children列表中移除自己
    if (d->parent)
        d->parent->d_func()->children.removeOne(this);

    // 2. 断开所有信号槽连接（作为发送者和接收者）
    disconnect(nullptr, nullptr, this, nullptr);
    disconnect(this, nullptr, nullptr, nullptr);

    // 3. 从后往前删除所有children（保证子对象先析构）
    //    后序遍历：先删除最深的叶子节点
    while (!d->children.isEmpty()) {
        QObject* child = d->children.last();
        delete child;  // 递归进入child的析构函数
        // child先从children列表移除（步骤1），所以不会无限循环
    }

    // 4. 释放自身的d指针
    delete d;
}

┌─────────────────────────────────────────────────────────────┐
│              delete parent 时的析构顺序                      │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  MainWindow                                                 │
│  ├── QMenuBar                                               │
│  │   └── QMenu("帮助")                                      │
│  │       └── QAction("关于")   ← 最先析构                   │
│  ├── QToolBar                                               │
│  │   └── QAction("运行")      ← 然后这个                    │
│  ├── QOpenGLWidget            ← 然后这个                    │
│  └── QStatusBar               ← 最后剩余的子对象            │
│                                                             │
│  delete window 的执行顺序：                                  │
│  1. QAction("关于") 析构                                    │
│  2. QMenu("帮助") 析构                                      │
│  3. QMenuBar 析构                                           │
│  4. QAction("运行") 析构                                    │
│  5. QToolBar 析构                                           │
│  6. QOpenGLWidget 析构                                      │
│  7. QStatusBar 析构                                         │
│  8. QMainWindow 析构                                        │
│                                                             │
│  关键：子对象保证在父对象之前被delete                        │
│       子对象的析构函数可以安全访问父对象（父对象还活着）       │
│                                                             │
└─────────────────────────────────────────────────────────────┘

1.4 setParent() 动态重挂载

cpp

// setParent() 的行为
void QObject::setParent(QObject* newParent)
{
    // 1. 从旧parent的children列表中移除
    if (d->parent)
        d->parent->d_func()->children.removeOne(this);

    // 2. 设置新parent
    d->parent = newParent;

    // 3. 加入新parent的children列表
    if (newParent)
        newParent->d_func()->children.append(this);

    // 4. 如果新旧parent在不同线程，更新线程亲缘性
    if (newParent && thread() != newParent->thread())
        moveToThread(newParent->thread());
}

// CAE中的实际用法：将视口从浮动窗口拖入主窗口
void MainWindow::dockViewport() {
    // 从浮动窗口取出视口
    m_viewport->setParent(this);  // 重新挂载到MainWindow
    m_centralLayout->addWidget(m_viewport);
}

// ⚠️ 注意：setParent(nullptr) 是合法的
// 对象成为孤儿，你必须自己管理它的生命周期
obj->setParent(nullptr);  // 从对象树移除，不再自动删除

第2部分：对象树操作API

2.1 findChild 与 findChildren

cpp

// ===== 类型安全的对象树查找 =====

// findChild<T>() — 查找单个子对象（深度优先，返回第一个匹配）
QPushButton* btn = parent->findChild<QPushButton*>("solveButton");
// 按 objectName 查找
QOpenGLWidget* viewport = findChild<QOpenGLWidget*>("mainViewport");
// 不指定名称 → 返回第一个该类型的子对象
QStatusBar* status = findChild<QStatusBar*>();

// findChildren<T>() — 查找所有匹配的子对象
QList<QDockWidget*> docks = findChildren<QDockWidget*>();
// 按名称正则匹配
QList<QAction*> fileActions =
    findChildren<QAction*>(QRegularExpression("^actionFile"));

// CAE中的实际用法
void MainWindow::updateAllViewports(Mesh* mesh) {
    // 找到所有的3D视口并更新
    auto viewports = findChildren<MeshViewport*>();
    for (auto* vp : viewports) {
        vp->setMesh(mesh);  // 不需要维护一个手动列表
    }
}

2.2 dumpObjectTree — 调试利器

cpp

// 打印完整的对象树（调试时非常有用）
void debugObjectTree(QObject* root, int depth = 0) {
    QString indent(depth * 2, ' ');
    qDebug().noquote()
        << indent
        << root->metaObject()->className()
        << (root->objectName().isEmpty() ? "" : "(" + root->objectName() + ")");

    for (auto* child : root->children()) {
        debugObjectTree(child, depth + 1);
    }
}

// Qt 内置版本
root->dumpObjectTree();
// 输出示例：
// QMainWindow::MainWindow
//     QMenuBar::
//         QMenu::menuFile
//             QAction::actionOpen
//             QAction::actionSave
//         QMenu::menuHelp
//     QOpenGLWidget::mainViewport
//     QStatusBar::statusBar

root->dumpObjectInfo();
// 输出更多细节：信号/槽、属性、连接数等

2.3 deleteLater() 详解

cpp

// ===== deleteLater() — 延迟删除 =====

// 问题场景：在信号处理中不能直接 delete 发送者
void MyWidget::onButtonClicked() {
    QPushButton* btn = qobject_cast<QPushButton*>(sender());
    // delete btn;  // ❌ CRASH! btn的clicked槽还没返回，
                     //     你在槽函数中delete了this（等同于btn）
}

// deleteLater() 做了什么：
// 向当前线程的事件队列中post一个DeferredDelete事件
// 当事件循环处理到这个事件时（当前槽返回后），才真正delete对象

void MyWidget::onButtonClicked() {
    QPushButton* btn = qobject_cast<QPushButton*>(sender());
    btn->deleteLater();  // ✅ 安全！在当前事件处理完毕后才delete
    // deleteLater() 立即返回，不执行实际的delete
}

// 典型使用场景：
// 1. 槽函数中删除自己或发送者
void SolverWorker::run() {
    QProcess process;
    process.start("ccx", args);
    process.waitForFinished(-1);
    emit finished(process.exitCode());
    // 工作完成，删除自己
    this->deleteLater();  // 安全：信号emit完毕，事件循环稍后清理
}

// 2. 关闭窗口时清理
void MainWindow::closeEvent(QCloseEvent* event) {
    m_solver->abort();
    m_solver->deleteLater();  // 让求解器在当前事件处理完后再清理
    event->accept();
}

第3部分：Qt智能指针与QObject

3.1 指针类型全景对比

┌─────────────────────────────────────────────────────────────┐
│           Qt智能指针 vs C++智能指针 + QObject               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  指针类型         所有权     null检测       适用场景         │
│  ─────────────── ───────── ────────────── ──────────────── │
│  QPointer<T>      不拥有   自动变nullptr   观察其他QObject   │
│  QScopedPointer<T>独占     reset()         局部QObject      │
│  QSharedPointer<T>共享     引用计数        共享非QObject     │
│  std::unique_ptr   独占     release()       非QObject        │
│  std::shared_ptr   共享     引用计数        非QObject        │
│  裸指针 T*         不拥有   手动nullptr     对象树中的对象   │
│                                                             │
│  关键规则：                                                 │
│  • QObject在对象树中 → 裸指针就够了（parent管理生命周期）    │
│  • QObject不在对象树中 → QPointer观察 / QScopedPointer管理  │
│  • 非QObject → std::unique_ptr / std::shared_ptr            │
│  • 绝不用 std::shared_ptr 管理已有parent的QObject           │
│                                                             │
└─────────────────────────────────────────────────────────────┘

3.2 QPointer — 受保护的观察指针

cpp

// QPointer<T> 在指向的QObject被销毁时自动变为 nullptr
// 比裸指针安全——避免了 use-after-free

class SolverManager : public QObject {
    Q_OBJECT
public:
    void startSolver() {
        m_currentSolver = new SolverWorker(this);
        m_currentSolver->start();
    }

    void checkSolver() {
        // 安全：即使solver已销毁，QPointer也不会悬空
        if (m_currentSolver) {
            qDebug() << "Solver still running...";
        } else {
            qDebug() << "Solver finished and cleaned up";
        }
    }

private:
    QPointer<SolverWorker> m_currentSolver;  // 不拥有所有权！
    // 等价写法：QPointer<SolverWorker> = Qt 的弱引用
};

// QPointer vs 裸指针
void example() {
    auto* label = new QLabel("Hello");

    QPointer<QLabel> safe = label;   // QPointer 观察
    QLabel* unsafe = label;          // 裸指针观察

    delete label;

    // safe.isNull() == true  ✅
    // safe == nullptr       ✅
    // unsafe 现在是悬空指针   ❌ 再次访问 → undefined behavior
}

3.3 双重删除陷阱

cpp

// ⚠️ Qt所有权 与 C++智能指针 不能混用！
// 以下代码会导致 double-free：

// ❌ 致命错误
{
    auto parent = std::make_unique<QWidget>();
    auto* child = new QPushButton("OK", parent.get());
    // parent析构 → delete child（Qt对象树）
    // unique_ptr析构 → delete child（C++ RAII）
    // child 被 delete 两次 → CRASH
}

// ❌ 同样致命
{
    QWidget* parent = new QWidget;
    auto child = std::make_shared<QPushButton>("OK", parent);
    // shared_ptr 持有所有权
    delete parent;
    // parent析构 → delete child → CRASH (child已被shared_ptr管理)
}

// ✅ 正确做法1：让Qt管理所有QObject（推荐）
{
    QWidget* parent = new QWidget;
    auto* child = new QPushButton("OK", parent);  // Qt管理生命周期
    delete parent;  // parent + child 一起析构，没问题
}

// ✅ 正确做法2：QObject不在对象树中 → C++智能指针管理
{
    auto worker = std::make_unique<SolverWorker>();  // 无parent
    worker->run();
    // worker离开作用域自动析构
}

// ✅ 正确做法3：QScopedPointer管理不在对象树中的QObject
{
    QScopedPointer<SolverWorker> worker(new SolverWorker);
    worker->run();
    // worker离开作用域 → delete SolverWorker
}

第4部分：CAE场景中的对象管理

4.1 模型零件树 — 复合对象层次

cpp

// ===== CAE模型的对象层次 =====

// 注意：只有需要信号/槽/属性的对象才从QObject派生
// 纯粹的数值数据用普通struct，避免每个节点/单元都是一个QObject

// 纯数据结构（不用QObject — 可能有百万个元素）
struct Node {
    double x, y, z;
};

struct Element {
    int type;          // TRI3, QUAD4, TET4, HEX8 ...
    int nodes[8];       // 最多8节点（HEX8）
    int materialId;
};

struct Material {
    QString name;
    double youngsModulus;
    double poissonRatio;
    double density;
};

// QObject派生类（需要信号/槽/属性树 — 只有几十到几百个）
class ModelPart : public QObject {
    Q_OBJECT
    Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
public:
    explicit ModelPart(const QString& name, QObject* parent = nullptr)
        : QObject(parent), m_name(name) {}

    QString name() const { return m_name; }
    void setName(const QString& n) {
        if (m_name != n) { m_name = n; emit nameChanged(n); }
    }

    // 子部件（对象树管理）
    ModelPart* addSubPart(const QString& name) {
        return new ModelPart(name, this);  // this = parent
    }
    QList<ModelPart*> subParts() const {
        return findChildren<ModelPart*>(QString(), Qt::FindDirectChildrenOnly);
    }

signals:
    void nameChanged(const QString& newName);

private:
    QString m_name;
    // 网格数据是普通struct，不用QObject
    QVector<Node> m_nodes;
    QVector<Element> m_elements;
    Material m_material;
};

// 使用
ModelPart* assembly = new ModelPart("Assembly");
ModelPart* wing     = assembly->addSubPart("Wing");
ModelPart* fuselage = assembly->addSubPart("Fuselage");
ModelPart* rib1     = wing->addSubPart("Rib_01");
ModelPart* rib2     = wing->addSubPart("Rib_02");

// 删除 assembly → 自动删除所有子部件（wing, fuselage, rib1, rib2）
delete assembly;

4.2 求解器生命周期 — 线程安全删除

cpp

// ===== 求解器Manager管理Worker生命周期 =====

class SolverManager : public QObject {
    Q_OBJECT
public:
    explicit SolverManager(QObject* parent = nullptr)
        : QObject(parent) {}

    void startJob(const QString& inputFile) {
        // 确保前一个solver已清理
        cleanupPreviousSolver();

        m_worker = new SolverWorker(inputFile);  // 无parent！
        m_thread = new QThread(this);

        m_worker->moveToThread(m_thread);

        connect(m_thread, &QThread::started,  m_worker, &SolverWorker::run);
        connect(m_worker, &SolverWorker::finished, this, &SolverManager::onJobFinished);
        connect(m_thread, &QThread::finished, m_worker, &QObject::deleteLater);

        m_thread->start();
    }

private slots:
    void onJobFinished(int exitCode) {
        emit jobCompleted(exitCode);
        // 线程退出 → m_worker->deleteLater() 自动执行
        m_thread->quit();
    }

    void cleanupPreviousSolver() {
        if (m_thread && m_thread->isRunning()) {
            qWarning() << "Previous solver still running! Aborting...";
            // 断开所有连接，防止 finished 信号触发两次清理
            disconnect(m_worker, nullptr, this, nullptr);
            m_worker->deleteLater();
            m_thread->quit();
            m_thread->wait(5000);
        }
    }

signals:
    void jobCompleted(int exitCode);

private:
    QPointer<SolverWorker> m_worker;  // QPointer 防止悬空指针
    QThread* m_thread = nullptr;
};

4.3 撤销/重做 — QUndoCommand不继承QObject

cpp

// ===== QUndoCommand 的对象管理 =====
// 注意：QUndoCommand 不继承 QObject！
// 它的所有权由 QUndoStack 管理

class MoveNodeCommand : public QUndoCommand {
public:
    MoveNodeCommand(MeshData* mesh, int nodeId,
                    const QVector3D& oldPos, const QVector3D& newPos)
        : m_mesh(mesh), m_nodeId(nodeId)
        , m_oldPos(oldPos), m_newPos(newPos)
    {
        setText(QString("Move Node %1").arg(nodeId));
    }

    void undo() override {
        m_mesh->setNodePosition(m_nodeId, m_oldPos);
        // m_mesh 发出 dataChanged → 视口刷新
    }

    void redo() override {
        m_mesh->setNodePosition(m_nodeId, m_newPos);
    }

    int id() const override { return 1001; }
    bool mergeWith(const QUndoCommand* other) override {
        // 连续拖拽同一个节点 → 合并为一步
        auto* cmd = dynamic_cast<const MoveNodeCommand*>(other);
        if (!cmd || cmd->m_nodeId != m_nodeId) return false;
        m_newPos = cmd->m_newPos;
        return true;
    }

private:
    MeshData* m_mesh;  // 不拥有所有权，MeshData由Document管理
    int m_nodeId;
    QVector3D m_oldPos, m_newPos;
};

// 使用
void MainWindow::onNodeDragged(int nodeId, QVector3D newPos) {
    QVector3D oldPos = m_mesh->nodePosition(nodeId);
    m_undoStack->push(new MoveNodeCommand(m_mesh, nodeId, oldPos, newPos));
    // QUndoStack 拥有 command 的所有权
    // undoStack 析构时自动 delete 所有 command
}

第5部分：内存调试与排查

5.1 常见QObject内存问题

┌─────────────────────────────────────────────────────────────┐
│             QObject 内存问题与解决方案                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  问题                         原因              解决方案    │
│  ────────────────────────    ────────────────  ─────────── │
│  对象泄漏（一直存在）        忘记指定parent    指定parent   │
│                             孤儿对象未delete   或手动delete │
│                                                             │
│  Double-Free                 Qt管理+智能指针  选一边管理    │
│                              双重管理          不要混用     │
│                                                             │
│  Use-After-Free             裸指针悬空         QPointer     │
│                              QObject已销毁     或connect     │
│                                                context自动断│
│                                                             │
│  析构顺序错误                依赖已析构对象    QPointer检查  │
│                                                        │
│  循环parent                   A→B→A parent链    QObject检测  │
│                               (QObject会拒绝)    并打印警告  │
│                                                             │
│  信号连接阻止析构             跨线程连接        disconnect   │
│                              QueuedConnection   或指定context│
│                              持有引用                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

5.2 调试工具

cpp

// 1. 运行时检查parent关系
void validateObjectTree(QObject* root) {
    for (auto* child : root->children()) {
        Q_ASSERT_X(child->parent() == root,
                   "validateObjectTree",
                   "Child's parent pointer doesn't match!");
        validateObjectTree(child);
    }
}

// 2. 监听对象销毁
connect(obj, &QObject::destroyed, this, [](QObject* o) {
    qDebug() << "Object destroyed:" << o->metaObject()->className()
             << o->objectName();
});

// 3. 检查对象是否被泄漏（应该在析构中被清理的对象仍然存在）
void MainWindow::closeEvent(QCloseEvent* event) {
    // 检查是否所有子对象都正确设置了parent
    auto orphans = findChildren<QObject*>(QString(), Qt::FindDirectChildrenOnly);
    qDebug() << "Direct children count:" << orphans.size();
    // 可以对比预期值来发现泄漏
    event->accept();
}

// 4. 使用 valgrind / AddressSanitizer
// $ cmake -DCMAKE_CXX_FLAGS="-fsanitize=address" ..
// $ ./FastCAE
// 退出时 ASan 会报告所有泄漏的 QObject

5.3 GammaRay 对象检查器

┌─────────────────────────────────────────────────────────────┐
│           GammaRay 的内存调试功能                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. Objects 视图                                            │
│     • 实时显示所有QObject的对象树                            │
│     • 按类型分组（统计每种类型的实例数）                     │
│     • 标记"孤儿对象"（没有parent的顶层QObject）             │
│                                                             │
│  2. 对象详情                                                │
│     • 选中一个对象 → 显示它的属性、信号、槽、连接           │
│     • 显示对象创建时的调用栈（如果启用了profiling）          │
│                                                             │
│  3. 内存泄漏检测                                            │
│     • 打开/关闭一个对话框多次                                │
│     • 观察对象数量是否持续增长（每次打开+10 → 泄漏）        │
│     • 直接定位到泄漏的代码路径                              │
│                                                             │
│  4. 信号槽分析                                              │
│     • 选中一个对象 → 显示所有连接                           │
│     • 标记"悬空连接"（接收者已销毁但连接未断开）             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

核心总结

总结1：对象树是确定性父子所有权，不是 GC

QObject 对象树表达父对象拥有子对象：父对象析构时会删除子对象，子对象提前析构时会从父对象列表移除。它不追踪任意引用、不能回收无 parent 的对象，也不处理一般引用环，因此不应称为垃圾收集器。deleteLater() 的实际删除还依赖相应事件循环和调用时机。

总结2：该用QObject时才用QObject

不要把大规模数值实体逐个建成 QObject。需要元对象、事件、线程亲和性或父子所有权的控制对象适合 QObject；密集网格与场数据更适合连续值容器。具体对象大小取决于类型和 ABI，应以 sizeof、堆分析和实际数据测量，而不是依赖固定字节估算。

总结3：对象树与 RAII 可以协作，但所有权必须唯一

同一对象不能同时由相互独立的所有者删除。有 parent 的堆上 QObject 通常交给对象树；无 parent 对象可以由栈、unique_ptr 或其他明确所有者管理。RAII 仍可管理 QObject、连接句柄和非 QObject 资源，但必须明确删除线程、析构顺序以及自定义删除器是否需要 deleteLater()。

章节测试

测试1：析构顺序

以下代码中，析构顺序是什么？

cpp

auto* window = new QMainWindow;
auto* toolbar = new QToolBar(window);
auto* action1 = new QAction("A", toolbar);
auto* action2 = new QAction("B", toolbar);
delete window;

A. window → toolbar → action1 → action2 B. action2 → action1 → toolbar → window C. action1 → action2 → toolbar → window（不确定） D. 随机顺序

测试2：QPointer行为

cpp

auto* label = new QLabel("test");
QPointer<QLabel> ptr = label;
delete label;
// ptr现在是什么状态？

A. ptr仍然是label的地址（悬空） B. ptr变为nullptr C. ptr触发assert D. 这代码编译不了

测试3：CAE数据建模

对于一个百万节点的FEA模型，节点的内存管理最佳实践是？ A. 每个节点继承QObject，设置parent为MeshData B. 使用QVector<Node>存储，Node是普通struct C. 每个节点用std::shared_ptr管理 D. 每个节点用QSharedPointer管理

测试4：deleteLater时机

deleteLater() 在什么时候真正delete对象？ A. 立即delete B. 在下一个事件循环迭代中 C. 在所有活跃的槽函数返回后（当前调用栈清空后） D. 1秒后

测试5：双重所有权

以下代码有什么问题？

cpp

auto parent = std::make_unique<QWidget>();
auto* child = new QPushButton("OK", parent.get());

A. 没有问题 B. parent析构时child被delete两次 C. child的QPushButton构造失败 D. 内存泄漏

参考答案

测试1答案

答案：B（实际上可能是B或C，取决于children列表的顺序）。QObject::~QObject()从后往前遍历children列表并逐一delete。由于action1和action2都添加到toolbar的列表末尾，所以最后添加的先被删除（后进先出）。但不同的Qt版本可能以不同顺序存储children。

关键是：所有子对象保证在父对象之前析构。toolbar在window之前析构，actions在toolbar之前析构。

测试2答案

答案：B。QPointer内部连接了被观察对象的destroyed信号。当label被delete时，QPointer收到通知并将内部指针置为nullptr。后续检查if(ptr)或if(!ptr.isNull())都能正确检测到对象已不存在。

测试3答案

答案：B。QObject每个实例至少200+字节（vtable + d-pointer + meta object + children list等），百万个节点 = 200MB+仅对象开销。用QVector<Node>存储纯数据，每个节点24字节（3个double），总共24MB——10倍的差距。shared_ptr同样有额外开销且不需要引用计数。

测试4答案

答案：C。deleteLater()向事件队列post一个QDeferredDeleteEvent。当控制权返回事件循环时（所有当前正在处理的信号/槽/事件处理完毕），事件循环处理这个事件并执行实际的delete。这保证了"在槽函数中delete发送者"的安全性。

测试5答案

答案：B。unique_ptr<QWidget>拥有parent的所有权，而Qt对象树（parent→child关系）也拥有child的所有权。unique_ptr离开作用域时delete parent → parent的析构函数delete child（Qt对象树）。然后不再有第二次delete——child只被delete一次。但是：parent在这里被delete了两次吗？不——parent只被unique_ptr管理一次。真正的问题是child：parent析构时delete了child，这本身是正确的。实际上代码不会crash，但存在所有权混淆的风险。更准确地说，这是一种设计上的错误：parent的所有权和child的所有权被不同机制管理，容易在重构时引入bug。

最佳答案：B。这不是立即crash的代码，但它是所有权混淆，极易导致后续维护中的double-free或use-after-free。正确做法是不要混用unique_ptr和Qt parent机制。

下一步学习

[ ] 阅读 03 - CAE开发常用核心API实战 — 掌握CAE开发工具箱
[ ] 检查你现有代码中是否有裸指针悬空的风险，考虑使用QPointer
[ ] 用GammaRay或dumpObjectTree检查一次你的对象树结构

学习状态：🟡 开始学习

QObject 所有权与执行线程的双图

text

Ownership tree                     Thread affinity
MainWindow                         GUI thread
├── Toolbar                        ├── MainWindow/Toolbar/Panel
└── Panel                          └── receives their posted events
    └── WorkerController

Worker(no parent) ----------------> worker thread event loop

树解决销毁，亲和性解决事件执行；两者不是同一个维度。一个对象被 shared_ptr 保活，也不能从任意线程直接调用其非线程安全成员。

析构与在途事件

text

QObject alive
 -> signal/events queued
 -> deleteLater posts DeferredDelete
 -> earlier queued events may run according to queue order
 -> destructor removes posted events/connections
 -> QPointer observers become null

业务层仍要用 closing/task generation 防止“对象未死但文档已切换”的过期更新。

面试连续追问

问：为什么不建议同时给 QObject parent 和独立 unique_ptr 所有权？

答：两条删除责任可能分别触发导致双删；应选择唯一 owner，或使用明确与 parent 协作的 deleter/释放策略。

问：deleteLater 是否线程安全地从任何线程删除？

答：它安排到对象亲和线程事件循环；仍需确认该循环正在运行，并遵守 API 的线程调用契约。

问：QPointer 能否解决并发 UAF？

答：它能在 QObject 析构时清空，但非拥有且检查/使用不是跨线程原子生命周期锁；应通过亲和线程消息通信。

自测与答案

parent 析构时 children 顺序如何理解？ 答：Qt 负责递归删除，业务不应依赖未文档化兄弟顺序来做横向调用。
moveToThread 为何要求无 parent？ 答：父子对象必须保持同一亲和线程。
QThread 成员 slots 在哪执行？ 答：按 QThread 对象自身亲和线程，除非连接/调用方式明确投递到其他线程。

对象树与内存管理 / QObject Trees and Memory Management ​

📋 本章目标 ​

专题扩展 ​

第1部分：QObject父子模型 ​

1.1 为什么需要对象树 ​

1.2 构造时指定parent ​

1.3 QObject析构函数的删除传播 ​

1.4 setParent() 动态重挂载 ​

第2部分：对象树操作API ​

2.1 findChild 与 findChildren ​

2.2 dumpObjectTree — 调试利器 ​

2.3 deleteLater() 详解 ​

第3部分：Qt智能指针与QObject ​

3.1 指针类型全景对比 ​

3.2 QPointer — 受保护的观察指针 ​

3.3 双重删除陷阱 ​

第4部分：CAE场景中的对象管理 ​

4.1 模型零件树 — 复合对象层次 ​

4.2 求解器生命周期 — 线程安全删除 ​

4.3 撤销/重做 — QUndoCommand不继承QObject ​

第5部分：内存调试与排查 ​

5.1 常见QObject内存问题 ​

5.2 调试工具 ​

5.3 GammaRay 对象检查器 ​

核心总结 ​

总结1：对象树是确定性父子所有权，不是 GC ​

总结2：该用QObject时才用QObject ​

总结3：对象树与 RAII 可以协作，但所有权必须唯一 ​

章节测试 ​

测试1：析构顺序 ​

测试2：QPointer行为 ​

测试3：CAE数据建模 ​

测试4：deleteLater时机 ​

测试5：双重所有权 ​

参考答案 ​

测试1答案 ​

测试2答案 ​

测试3答案 ​

测试4答案 ​

测试5答案 ​

相关笔记 ​

下一步学习 ​

QObject 所有权与执行线程的双图 ​

析构与在途事件 ​

面试连续追问 ​

自测与答案 ​