1. Python技术站首页
  2. 其他
  3. C++

Qt源码阅读(三) 对象树管理

• C++

对象树管理

个人经验总结，如有错误或遗漏，欢迎各位大佬指正 ?

@

目录

设置父对象的作用

众所周知，Qt中，有为对象设置父对象的方法——setParent。

而设置父对象的作用主要有，在父对象析构的时候，会自动去析构其子对象。如果是一个窗口对象，如果其父对象设置了样式表(Style Sheet)，子对象也会继承父对象的样式。

所以，这篇文章，咱们主要看一下setParent的源码以及QObject是怎么进行对象管理的。

设置父对象(setParent)

我们可以看到，setParent这个函数就是调用了QObjectPrivate类的setParent_helper这个函数。

void QObject::setParent(QObject *parent)
{
    Q_D(QObject);
    Q_ASSERT(!d->isWidget);
    d->setParent_helper(parent);
}

所以，我们进一步分析setParent_helper这个函数

完整源码

void QObjectPrivate::setParent_helper(QObject *o)
{
    Q_Q(QObject);
	// 不能把自己设为父对象
    Q_ASSERT_X(q != o, Q_FUNC_INFO, "Cannot parent a QObject to itself");
#ifdef QT_DEBUG
	// 检查对象树的循环
    const auto checkForParentChildLoops = qScopeGuard([&](){
        int depth = 0;
        auto p = parent;
        while (p) {
            if (++depth == CheckForParentChildLoopsWarnDepth) {
                qWarning("QObject %p (class: '%s', object name: '%s') may have a loop in its parent-child chain; "
                         "this is undefined behavior",
                         q, q->metaObject()->className(), qPrintable(q->objectName()));
            }
            p = p->parent();
        }
    });
#endif

	// 如果要设置的父对象就是当前的父对象，直接返回
    if (o == parent)
        return;

    if (parent) {
        QObjectPrivate *parentD = parent->d_func();
        if (parentD->isDeletingChildren && wasDeleted
            && parentD->currentChildBeingDeleted == q) {
            // don't do anything since QObjectPrivate::deleteChildren() already
            // cleared our entry in parentD->children.
        } else {
            const int index = parentD->children.indexOf(q);
            if (index < 0) {
                // we're probably recursing into setParent() from a ChildRemoved event, don't do anything
            } else if (parentD->isDeletingChildren) {
                parentD->children[index] = 0;
            } else {
				// 如果对象已经存在父对象的列表中，将原先存在的对象删除，并发送事件
                parentD->children.removeAt(index);
                if (sendChildEvents && parentD->receiveChildEvents) {
                    QChildEvent e(QEvent::ChildRemoved, q);
                    QCoreApplication::sendEvent(parent, &e);
                }
            }
        }
    }
	// 设置父对象
    parent = o;
    if (parent) {
        // object hierarchies are constrained to a single thread
        if (threadData != parent->d_func()->threadData) {
            qWarning("QObject::setParent: Cannot set parent, new parent is in a different thread");
            parent = nullptr;
            return;
        }
		// 父对象添加子对象，并发送事件
        parent->d_func()->children.append(q);
        if(sendChildEvents && parent->d_func()->receiveChildEvents) {
            if (!isWidget) {
                QChildEvent e(QEvent::ChildAdded, q);
                QCoreApplication::sendEvent(parent, &e);
            }
        }
    }
    if (!wasDeleted && !isDeletingChildren && declarativeData && QAbstractDeclarativeData::parentChanged)
        QAbstractDeclarativeData::parentChanged(declarativeData, q, o);
}

片段分析

  1. 一些先决条件的判断

    • 判断设置的父对象是否是自己

      	// 不能把自己设为父对象 
	Q_ASSERT_X(q != o, Q_FUNC_INFO, "Cannot parent a QObject to itself"); 
	/*...*/ 
	// 如果要设置的父对象就是当前的父对象，直接返回 
	if (o == parent)    return;

    • 判断原来的父对象是否处于正在删除子对象的过程中，并且当前对象已经被删除了，如果是，则什么都不做（有点迷惑）

      	if (parentD->isDeletingChildren && wasDeleted            
		&& parentD->currentChildBeingDeleted == q) {
	            // don't do anything since QObjectPrivate::deleteChildren() 
	            //already  cleared our entry in parentD->children.
	 }

    • 判断是不是通过从ChildRemoved事件递归到setParent()

      if (index < 0) {                
	// we're probably recursing into setParent() from a ChildRemoved event,
	// don't do anything 
} else if (parentD->isDeletingChildren) {    
	parentD->children[index] = 0; 
}

    • 判断对象是不是已存在父对象的列表中，如果存在，就将对象删除，并发送事件

      else { 			
// 如果对象已经存在父对象的列表中，将原先存在的对象删除，并发送事件                
	parentD->children.removeAt(index);                
	if (sendChildEvents && parentD->receiveChildEvents) {                    
		QChildEvent e(QEvent::ChildRemoved, q);
		QCoreApplication::sendEvent(parent, &e);                
	}            
}

  2. 设置父对象，这里有一个限制，就是新设置的父对象，必须和当前对象在同一个线程，否则不能设置。

    // 设置父对象
    parent = o;
    if (parent) {
        // object hierarchies are constrained to a single thread
        if (threadData != parent->d_func()->threadData) {
            qWarning("QObject::setParent: Cannot set parent, \
             new parent is in a different thread");
            parent = nullptr;
            return;
        }
		// 父对象添加子对象，并发送事件
        parent->d_func()->children.append(q);
        if(sendChildEvents && parent->d_func()->receiveChildEvents) {
            if (!isWidget) {
                QChildEvent e(QEvent::ChildAdded, q);
                QCoreApplication::sendEvent(parent, &e);
            }
        }
    }

对象的删除

  然后就是对象的管理，也就是在父对象析构的时候，自动析构掉所有的子对象。这一个在我们使用窗口部件的时候很有用，因为一个界面可能有很多个子控件，比如按钮、label等，这时候，如果一个小窗口被关闭，我们也不需要一个一个的去析构，由Qt的对象树去进行析构就好了。

QObject::~QObject()
{
   /*...*/

	// 删除子对象
    if (!d->children.isEmpty())
        d->deleteChildren();

#if QT_VERSION < 0x60000
    qt_removeObject(this);
#endif
    if (Q_UNLIKELY(qtHookData[QHooks::RemoveQObject]))
        reinterpret_cast<QHooks::RemoveQObjectCallback>(qtHookData[QHooks::RemoveQObject])(this);

    Q_TRACE(QObject_dtor, this);

    if (d->parent)        // remove it from parent object
        d->setParent_helper(nullptr);
}

将所有的子对象进行删除，遍历容器，按照子对象所加入进来的顺序进行析构。

void QObjectPrivate::deleteChildren()
{
	// 清空子对象
    Q_ASSERT_X(!isDeletingChildren, "QObjectPrivate::deleteChildren()", "isDeletingChildren already set, did this function recurse?");
    isDeletingChildren = true;
    // delete children objects
    // don't use qDeleteAll as the destructor of the child might
    // delete siblings
    for (int i = 0; i < children.count(); ++i) {
        currentChildBeingDeleted = children.at(i);
        children[i] = 0;
        delete currentChildBeingDeleted;
    }
    children.clear();
    currentChildBeingDeleted = nullptr;
    isDeletingChildren = false;
}

夹带私货时间

在使用Qt的对象树这个功能的时候，可能会遇到一种问题，会导致程序崩溃：就是手动的管理(也就是直接delete)一个有父对象的QObject，为什么会出现这样的情况呢，因为，你在delete子对象之后，并没有把这个对象从父对象的对象树里移除。在父对象进行析构的时候，还是会去遍历子对象容器，一个一个析构。这个时候，就会出现，一个对象指针被删除了两次，自然就会崩溃。

那么，如果非要自己管理这个对象，有什么办法呢？我们从对象树下手，有两种办法：

  1. 使用deleteLater

    就是调用QObject对象的deleteLater函数，来实现删除。关于deleteLater的分析，可以看这个大佬的文章Qt 中 deleteLater() 函数的使用

    QObject *object = new QObject();
QObject *m_child = new QObject(object);

// 需要手动删除的时候
m_child->deleteLater();

  2. 先将父对象设置为空，再直接delete

    QObject *object = new QObject();
QObject *m_child = new QObject(object);

// 需要手动删除的时候
m_child->setParent(nullptr);
delete m_child;
m_child = nullptr;

  3. 先将父对象设置为空，再直接delete

    QObject *object = new QObject();
QObject *m_child = new QObject(object);

// 需要手动删除的时候
m_child->setParent(nullptr);
delete m_child;
m_child = nullptr;

个人建议使用第一种方法，也就是调用deleteLater

原文链接：https://www.cnblogs.com/codegb/p/17270627.html

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：Qt源码阅读(三) 对象树管理 - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年4月18日
下一篇 2023年4月18日

相关文章

  • 2023.5.5 面向对象程序设计实验报告

    实验项目名称：模板 一、实验目的 1、熟练掌握函数模板和类模板的定义格式。 2、熟练运用函数模板和类模板解决实际问题。 二、实验内容 1、复数类Complex有两个数据成员：a和b, 分别代表复数的实部和虚部，并有若干构造函数和一个重载-（减号，用于计算两个复数的距离）的成员函数。 要求设计一个函数模板 template < class T > …

    C++ 2023年5月5日
    00

  • 最少步数

    在各种棋中，棋子的走法总是一定的，如中国象棋中马走“日”。有一位小学生就想如果马能有两种走法将增加其趣味性，因此，他规定马既能按“日”走，也能如象一样走“田”字。他的同桌平时喜欢下围棋，知道这件事后觉得很有趣，就想试一试，在一个（100*100）的围棋盘上任选两点A、B，A点放上黑子，B点放上白子，代表两匹马。棋子可以按“日”字走，也可以按“田”字走，俩人一…

    C++ 2023年4月25日
    00

  • 内存淘汰策略|页面置换算法对比总结

    在学习【操作系统】 【MySQL】【Redis】后，发现其都有一些缓存淘汰的策略，因此一篇小文章总结一下。 目前还没着笔，初略一想MySQL和操作系统应该都是使用的年轻代和老生代的改进策略，而Redis使用的是随机抽的策略。 MySQL MySQL中存在一个内存缓存池，Buffer Pool。里面存在着控制块和缓存的数据页（当然还有些其他缓存，比如：锁信息、…

    C++ 2023年4月18日
    00

  • LeetCode 力扣 205. 同构字符串

    给定两个字符串 s 和 t ，判断它们是否是同构的。 如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。 每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。 示例 1: 输入：s = “egg”, t = “add”输出：true示例…

    C++ 2023年4月18日
    00

  • C++容器（vector、deque、list、map）

    (1) vector：将元素置于一个动态数组中，可以随机存储元素（也就是用索引直接存取）。 数组尾部添加或删除元素非常迅速。但在中部或头部就比较费时。 *代码演示：* 取：at在下标越界时会抛出异常，我们能捕获异常进行处理；而[]下标越界会让程序直接终止； 构造函数： cbegin, cend, crbegin, crend返回的是常量迭代器，不能通过迭代器…

    C++ 2023年5月5日
    00

  • 32位进程设置大地址(3G)空间

    对应32位应用，我们不做任何设置，我们能用的地址空间其实不足2G，有两种方式设置大地址空间： 一、设置链接选项 二、工具editbin 1.开启方法 (1)利用管理员身份运行”Visual Studio 工具命令提示”程序; (2)输入命令：editbin /LARGEADDRESSAWARE D:\xxx.exe 2.检查是否开启成功 (1)利用管理员身份…

    C++ 2023年5月6日
    00

  • C++：explicit关键字

    C++中的explicit关键字只能用于修饰只有一个参数的类构造函数，它的作用是表明该构造函数是显示的，而非隐式的，跟它相对应的另一个关键字是implicit，意思是隐藏的，类构造函数默认情况下即声明为implicit(隐式)。 那么显示声明的构造函数和隐式声明的有什么区别呢? 来看下面的例子： class CxString // 没有使用explicit关…

    C++ 2023年4月18日
    00

  • day3 函数的定义和调用，练习编写简单的程序（记录1）

    一、函数的定义 可以分为以下两种： 1、函数声明和函数定义分离 这种方法将函数声明和函数定义分开，通常在头文件中先声明函数原型，然后在源文件中实现函数定义。 例如，头文件 example.h 中声明了一个函数 add： #ifndef EXAMPLE_H #define EXAMPLE_H int add(int a, int b); // 声明函数原型 #…

    C++ 2023年4月18日
    00
合作推广
合作推广
分享本页
返回顶部