原文:http://blog.csdn.net/oowgsoo/article/details/1529284

我感觉oowgsoo兄弟写的分析相当透彻,赞!

1.试验代码:

  1. #include <QApplication>
    #include <QtCore>
    #include <QtGui>
  2.  
  3. int main(int argc, char *argv[])
    {
    QApplication app(argc, argv);
  4.  
  5. int size = sizeof(QObject);
  6.  
  7. QPushButton* quit = new QPushButton("Quit");
    delete quit;
  8.  
  9. return app.exec();
    }

QObject是Qt类体系的唯一基类,就象MFC中的CObject和Dephi中的TObject,是Qt各种功能的源头活水,因此Qt源码分析的第一节就放在这个QObject上

  1. int size = sizeof(QObject);

QObject的大小是8,除了虚函数表指针需要的4个字节以外,另外的4个字节是:
    QObjectData *d_ptr;
QObject中的数据被封装在QObjectData类中了,为什么要封装数据呢?
原因是Qt中有一个很重要的设计模式就是句柄实体模式,也就是以QObject为基类的类一般都是句柄类,一般只有一个指针指向一个实体类,在实体类中保存全部的数据
而且一般情况下这个指针还是私有的,方便以后修改句柄类的实现细节
因此,也可以说和句柄类继承关系平行的也有一套实体类派生体系,因此,准确的说,Qt的基类其实有两个,一个是QObject,这是句柄类的唯一基类,另一个是QObjectData,这是实体
类的基类

QObjectData类定义如下:

  1. class QObjectData {
    public:
    virtual ~QObjectData() = 0;
    QObject *q_ptr;
    QObject *parent;
    QObjectList children;
  2.  
  3. uint isWidget : 1;
    uint pendTimer : 1;
    uint blockSig : 1;
    uint wasDeleted : 1;
    uint ownObjectName : 1;
    uint sendChildEvents : 1;
    uint receiveChildEvents : 1;
    uint unused : 25;
    int postedEvents;
    #ifdef QT3_SUPPORT
    int postedChildInsertedEvents;
    #else
    int reserved;
    #endif
    };

QObject *q_ptr;
这个指针指向实体类对应的句柄类,这和上面的代码
QObjectData *d_ptr;
遥相呼应,使得句柄类和实体类可以双向的引用,为什么是这样的命名方式呢?可能q指的是Qt接口类,d指的是Data数据类,这当然是猜测了,但是或许可以方便你记忆,在Qt中,
这两个指针名字是非常重要的,必须记住

但是仅仅如此还是不容易使用这两个指针,因为它们都是基类的类型,难道每次使用都要类型转换吗?为了简单起见,Qt在这里声明了两个宏

  1. #define Q_DECLARE_PRIVATE(Class) /
    inline Class##Private* d_func() { return reinterpret_cast<Class##Private *>(d_ptr); } /
    inline const Class##Private* d_func() const { return reinterpret_cast<const Class##Private *>(d_ptr); } /
    friend class Class##Private;
  2.  
  3. #define Q_DECLARE_PUBLIC(Class) /
    inline Class* q_func() { return static_cast<Class *>(q_ptr); } /
    inline const Class* q_func() const { return static_cast<const Class *>(q_ptr); } /
    friend class Class;

只要在类的头文件中使用这两个宏,就可以通过函数直接得到实体类和句柄类的实际类型了,而且这里还声明了友元,使得数据类和句柄类连访问权限也不用顾忌了

而且为了cpp文件中调用的方便,更是直接声明了以下两个宏

  1. #define Q_D(Class) Class##Private * const d = d_func()
    #define Q_Q(Class) Class * const q = q_func()

好了,使用起来倒是方便了,但是以后局部变量可千万不能声明为d和q了

这里的d_func和q_func函数是非常常用的函数,可以理解为一个是得到数据类,一个是得到Qt接口类

QObject *parent;
这里指向QObject的父类
QObjectList children;
这里指向QObject相关的子类列表
这确实是个大胆的设计,如果系统中产生了1000000个QObject实例(对于大的系统,这个数字很容易达到吧),每个QObject子类平均下来是100(这个数字可能大了),
光这些指针的开销就有1000000*100*4=400M,是够恐怖的,如果我们必须在灵活性和运行开销之间做一个选择的话,无疑Qt选择了前者,对此我也很难评论其中的优劣,
还是祈求越来越强的硬件水平和Qt这么多年来得到的赫赫威名保佑我们根本就没有这个问题吧,呵呵
总之,Qt确实在内存中保存了所有类实例的树型结构

uint isWidget : 1;
    uint pendTimer : 1;
    uint blockSig : 1;
    uint wasDeleted : 1;
    uint ownObjectName : 1;
    uint sendChildEvents : 1;
    uint receiveChildEvents : 1;
    uint unused : 25;
这些代码就简单了,主要是一些标记位,为了节省内存开销,这里采用了位域的语法,还保留了25位为unused,留做以后的扩充

  1. #ifdef QT3_SUPPORT
    int postedChildInsertedEvents;
    #else
    int reserved;
    #endif

这里或许是为了兼容Qt3下序列化的数据吧,即使没有定义QT3_SUPPORT,还是保留了一个数据reserved,以保证整个QObjectData的大小不变

具体看一个例子吧,对这种句柄实体模式加深认识,这就是Qt中的按钮类QPushButton
QPushButton的句柄类派生关系是:
QObject
 QWidget
  QAbstractButton
   QPushButton
   
QPushButton的实体类派生关系是:
QObjectData
 QObjectPrivate
  QWidgetPrivate
   QAbstractButtonPrivate
    QPushButtonPrivate

可以看出,这里确实是一个平行体系,只不过实体类派生关系中多了一个QObjectPrivate,这个类封装了线程处理,信号和槽机制等具体的实现,可以说它才是Qt实体类中
真正起作用的基类,而QObjectData不过是一层浅浅的数据封装而已

先不忙了解QObjectPrivate类中的接口和实现,我们先看看在Qt中,句柄类和实体类这两条体系是如何构造的?

  1. QPushButton* quit = new QPushButton("Quit");

创建一个Qt的按钮,简简单单一行代码,其实背后大有玄机

  1. QPushButton::QPushButton(const QString &text, QWidget *parent): QAbstractButton(*new QPushButtonPrivate, parent)

首先QPushButton的构造函数中调用了QAbstractButton的构造函数,同时马上new出来一个QPushButtonPrivate实体类,然后把指针转换为引用传递给QAbstractButton

  1. QAbstractButton::QAbstractButton(QAbstractButtonPrivate &dd, QWidget *parent): QWidget(dd, parent, 0)

QAbstractButton的构造函数中继续调用基类QWidget的构造函数,同时把QPushButtonPrivate实体类指针继续传给基类

  1. QWidget::QWidget(QWidgetPrivate &dd, QWidget* parent, Qt::WFlags f): QObject(dd, ((parent && (parent->windowType() == Qt::Desktop)) ? 0 : parent)),QPaintDevice()

QWidget继续坐着同样的事情

  1. QObject::QObject(QObjectPrivate &dd, QObject *parent): d_ptr(&dd)

终于到了基类QObject,这里就直接把QPushButtonPrivate的指针赋值给了d_ptr(还记得这个变量名称吧)

最终在QPushButton构造时同时产生的new QPushButtonPrivate被写到了QObject中的d_ptr中

  1. QObject::QObject(QObjectPrivate &dd, QObject *parent)
    : d_ptr(&dd)
    {
    Q_D(QObject);
    ::qt_addObject(d_ptr->q_ptr = this);
    QThread *currentThread = QThread::currentThread();
    d->thread = currentThread ? QThreadData::get(currentThread)->id : -1;
    Q_ASSERT_X(!parent || parent->d_func()->thread == d->thread, "QObject::QObject()",
    "Cannot create children for a parent that is in a different thread.");
    if (parent && parent->d_func()->thread != d->thread)
    parent = 0;
    if (d->isWidget) {
    if (parent) {
    d->parent = parent;
    d->parent->d_func()->children.append(this);
    }
    // no events sent here, this is done at the end of the QWidget constructor
    } else {
    setParent(parent);
    }
    }

然后执行QObject的构造函数,这里主要是一些线程的处理,先不理它

  1. QWidget::QWidget(QWidgetPrivate &dd, QWidget* parent, Qt::WFlags f)
    : QObject(dd, ((parent && (parent->windowType() == Qt::Desktop)) ? 0 : parent)), QPaintDevice()
    {
    d_func()->init((parent && parent->windowType() == Qt::Desktop ? parent : 0), f);
    }

然后是QWidget的构造函数,这里调用了数据类QWidgetPrivate的init函数,这个函数不是虚函数,因此静态解析成QWidgetPrivate的init函数调用

  1. QAbstractButton::QAbstractButton(QAbstractButtonPrivate &dd, QWidget *parent)
    : QWidget(dd, parent, 0)
    {
    Q_D(QAbstractButton);
    d->init();
    }

然后是QAbstractButton的构造函数,这里调用了数据类QAbstractButton的init函数,这个函数不是虚函数,因此静态解析成QAbstractButton的init函数调用

  1. QPushButton::QPushButton(const QString &text, QWidget *parent)
    : QAbstractButton(*new QPushButtonPrivate, parent)
    {
    Q_D(QPushButton);
    d->init();
    setText(text);
    }

然后是QPushButton的构造函数,这里调用了数据类QPushButton的init函数,这个函数不是虚函数,因此静态解析成QPushButton的init函数调用

现在的事情很清楚了,总结一下:
QPushButton在构造的时候同时生成了QPushButtonPrivate指针,QPushButtonPrivate创建时依次调用数据类基类的构造函数
QPushButton的构造函数中显示的调用了基类的构造函数并把QPushButtonPrivate指针传递过去,QPushButton创建时依次调用接口类基类的构造函数
在接口类的构造函数中调用了平行数据类的init函数,因为这个函数不是虚函数,因此就就是此次调用了数据类的init函数

需要指出的是,为什么QPushButtonPrivate实体类指针要转换为引用呢?为什么不是直接传递指针?结论是人家喜欢这样写,就是不传指针传引用,而且要用一个*new之类的怪异语法,
真叫人没有办法,其实这里用指针是一样的,代码看起来也自然一些.

delete quit;
说完了构造,再说说析构

  1. QPushButton::~QPushButton()
    {
    }

这里当然会调用QPushButton的析构函数了

  1. QAbstractButton::~QAbstractButton()
    {
    #ifndef QT_NO_BUTTONGROUP
    Q_D(QAbstractButton);
    if (d->group)
    d->group->removeButton(this);
    #endif
    }

然后是QAbstractButton的析构函数

  1. QWidget::~QWidget()
    {
    Q_D(QWidget);
    ...
    }

然后是QWidget的析构函数,这里洋洋洒洒一大堆代码,先不管它

  1. QObject::~QObject()
    {
    ...
    }

最后是QObject的析构函数,这里也是洋洋洒洒的一大堆

  1. Q_D(QObject);
    if (d->wasDeleted) {
    #if defined(QT_DEBUG)
    qWarning("Double QObject deletion detected");
    #endif
    return;
    }
    d->wasDeleted = true;

这些没有什么好说的,就是设一个wasDeleted的标志,防止再被引用,对于单线程情况下,马上就要被删除了,还搞什么标记啊,根本没用,但是对于多线程情况下,这个标记应该是有用的

  1. // set all QPointers for this object to zero
    GuardHash *hash = ::guardHash();
    if (hash) {
    QWriteLocker locker(guardHashLock());
    GuardHash::iterator it = hash->find(this);
    const GuardHash::iterator end = hash->end();
    while (it.key() == this && it != end) {
    *it.value() = 0;
    it = hash->erase(it);
    }
    }

这里是支持QPointers的实现代码,我们以后再说

  1. emit destroyed(this);

Qt的一个指针删除时要发送destroyed信号,一般情况下是没有槽来响应的

  1. QConnectionList *list = ::connectionList();
    if (list) {
    QWriteLocker locker(&list->lock);
    list->remove(this);
    }

这里清除了信号槽机制中的记录

  1. if (d->pendTimer) {
    // have pending timers
    QThread *thr = thread();
    if (thr || d->thread == 0) {
    // don't unregister timers in the wrong thread
    QAbstractEventDispatcher *eventDispatcher = QAbstractEventDispatcher::instance(thr);
    if (eventDispatcher)
    eventDispatcher->unregisterTimers(this);
    }
    }

这里清除定时器

  1. d->eventFilters.clear();

这里清除事件过滤机制

  1. // delete children objects
    if (!d->children.isEmpty()) {
    qDeleteAll(d->children);
    d->children.clear();
    }

这里清除所有子类指针,当然每个子类指针清除时又会清除它的所有子类,因此Qt中new出来的指针很少有显示对应的delete,因为只要最上面的指针被框架删除了,
它所连带的所有子类都被自动删除了

  1. {
    QWriteLocker locker(QObjectPrivate::readWriteLock());
    ::qt_removeObject(this);
  2.  
  3. /*
    theoretically, we cannot check d->postedEvents without
    holding the postEventList.mutex for the object's thread,
    but since we hold the QObjectPrivate::readWriteLock(),
    nothing can go into QCoreApplication::postEvent(), which
    effectively means noone can post new events, which is what
    we are trying to prevent. this means we can safely check
    d->postedEvents, since we are fairly sure it will not
    change (it could, but only by decreasing, i.e. removing
    posted events from a differebnt thread)
    */
    if (d->postedEvents > 0)
    QCoreApplication::removePostedEvents(this);
    }
  4.  
  5. if (d->parent) // remove it from parent object
    d->setParent_helper(0);
  6.  
  7. delete d;
    d_ptr = 0;

这里要删除相关的数据类指针了

http://www.cnblogs.com/hicjiajia/archive/2011/08/27/2155505.html

Qt源码分析之QObject的更多相关文章

  1. QT源码分析:QObject

    QT框架里面最大的特色就是在C++的基础上增加了元对象系统(Meta-Object System),而元对象系统里面最重要的内容就是信号与槽机制,这个机制是在C++语法的基础上实现的,使用了函数.函数 ...

  2. QT源码分析(从QApplication开始)

    QT源码分析 转载自:http://no001.blog.51cto.com/1142339/282130 今天,在给同学讲东西的时候,谈到了Qt源代码的问题,才发现自己对Qt机制的了解是在太少了,而 ...

  3. QT源码分析:QTcpServer

    最近在看有关IO复用方面的内容,自己也用标准c++库实现了select模型.iocp模型.poll模型.回过头来很想了解QT的socket是基于什么模型来实现的,所以看了QT关于TcpServer实现 ...

  4. Qt源码分析之信号和槽机制

    Qt的信号和槽机制是Qt的一大特点,实际上这是和MFC中的消息映射机制相似的东西,要完成的事情也差不多,就是发送一个消息然后让其它窗口响应,当然,这里的消息是广义的说法,简单点说就是如何在一个类的一个 ...

  5. Qt源码分析之信号和槽机制(QMetaObject是一个内部struct)

    Qt的信号和槽机制是Qt的一大特点,实际上这是和MFC中的消息映射机制相似的东西,要完成的事情也差不多,就是发送一个消息然后让其它窗口响应,当然,这里的消息是广义的说法,简单点说就是如何在一个类的一个 ...

  6. Qt源码分析之QPointer

    QPointer是一个指针封装类,其作用类似于智能指针,但是它最大的特点应该是在指针的控制上,它希望一个Qt的指针(当然是从QObject派生的)可以同时被多个类拥有,这在界面编程中当然是很常见的事情 ...

  7. QT 源码分析--1

    Ref: http://blog.sina.com.cn/s/blog_6e80f1390100qoc0.html 安装qt之后(我使用的是online自动安装),安装目录下有\5.10.1\Src\ ...

  8. Qt update刷新之源码分析总结

    大家好,我是IT文艺男,来自一线大厂的一线程序员 经过前面几次的Qt源码讲解,我相信大家对Qt update刷新机制从底层原理上有了一个深刻的理解:这次做一个收尾总结,来复盘前面几次所讲解的内容: 分 ...

  9. Qt之使用setWindowFlags方法遇到的问题(追踪进入QWidget的源码分析原因,最后用WINAPI解决问题)good

    一.简述 前段时间在使用setWindowFlags方法时遇到了一个坑,具体情况是想通过窗口界面上一个checkBox来控制窗口当前状态是否置顶,而Qt提供了Qt::WindowStaysOnTopH ...

随机推荐

  1. 冒泡排序(Bubble Sort)

    常见的排序算法有Bubble Sort.Merge Sort.Quick Sort 等,所有排序算的基本法思想都是把一个无限大的数据规模通过算法一步步缩小,指导最后完成排序. 这里分享一下Buuble ...

  2. How to achieve dialog with lookup control

    How to create a dialog with the lookup as a control, the other control SalesId ItemId lookup is the ...

  3. 用开源AOP简化MVVM框架

    本文的前提是知晓基于Xaml开发,本文以WPF为例 一 .简化属性通知事件 普通的属性通知会写一个基于INotifyPropertyChanged接口的类 public class RasieProp ...

  4. Cisco IOS Basic CLI Configuration:Access Security 01

    1.  Telnet Switch Config: Switch>en Switch#conf t Enter configuration commands, one per line.  En ...

  5. SQL的自增列如何重置

    第一种方法:首先去除该列自增的标识,然后再修改id的值,成功修改后,再加上自增标识:如果不修改自增标识,会报错:“无法更新标识列”. 第二种方法:删除该自增列,而后重建一个自增列.

  6. iOS内存管理retain,assign,copy,strong,weak

    转自:http://www.cnblogs.com/nonato/archive/2013/11/28/3447162.html iOS的对象都继承于NSObject, 该对象有一个方法:retain ...

  7. Google面试题及答案

    1. 村子里有100对夫妻,其中每个丈夫都瞒着自己的妻子偷情...村里的每个妻子都能立即发现除自己丈夫之外的其他男人是否偷情,唯独不知道她自己的丈夫到底有没有偷情.村里的规矩不容忍通奸.任何一个妻子, ...

  8. Hadoop2

    http://www.cnblogs.com/miaoxiaoyu/archive/2012/07/29/2614060.html

  9. 在Web API中使用Swagger-UI开源组件(一个深坑的解决)

    介绍: Swagger-Ui是一个非常棒的Web API说明帮助页,具体详情可自行Google和百度. 官网:http://swagger.io/    GitHub地址:https://github ...

  10. 【BZOJ 1188】 [HNOI2007]分裂游戏

    Description 聪聪和睿睿最近迷上了一款叫做分裂的游戏. 该游戏的规则试: 共有 n 个瓶子, 标号为 0,1,2.....n-1, 第 i 个瓶子中装有 p[i]颗巧克力豆,两个人轮流取豆子 ...