看懂Qt源代码-Qt源码的对象数据存储

Posted 2020-08-27 朝闻道

第一次看Qt源代码的人都会被其代码所迷惑，经常会看到代码中的d_ptr成员、d_func(函数)和Q_DECLARE_PRIVATE等奇怪的宏，总是让人一头雾水，下面这篇文章转自http://www.qkevin.com/archives/31，它很好的向我们介绍了Qt源代码的编写习惯，为我们看Qt源码打下基础：

对象数据存储

前言，为什么先说这个？

     我们知道，在C++中，几乎每一个类(class)中都需要有一些类的成员变量(class member variable)，在通常情况下的做法如下：

 

[cpp] view plain copy

 

 

1. class Person  
2. {  
3. private:  
4.     string mszName; // 姓名  
5.     bool mbSex;    // 性别  
6.     int mnAge;     // 年龄  
7. };  

     就是在类定义的时候，直接把类成员变量定义在这里，甚至于，把这些成员变量的存取范围直接定义成是 public 的，您是不是这是这样做的呢？

 

在Qt中，却几乎都不是这样做的，那么，Qt是怎么做的呢？

     几乎每一个C++的类中都会保存许多的数据，要想读懂别人写的C++代码，就一定需要知道每一个类的的数据是如何存储的，是什么含义，否则，我们不可能读懂别人的C++代码。在这里也就是说，要想读懂Qt的代码，第一步就必须先搞清楚Qt的类成员数据是如何保存的。

    为了更容易理解Qt是如何定义类成员变量的，我们先说一下Qt 2.x 版本中的类成员变量定义方法，因为在 2.x 中的方法非常容易理解。然后在介绍 Qt 4.6 中的类成员变量定义方法。

Qt 2.x 中的方法

在定义class的时候(在.h文件中)，只包含有一个类成员变量，只是定义一个成员数据指针，然后由这个指针指向一个数据成员对象，这个数据成员对象包含所有这个class的成员数据，然后在class的实现文件(.cpp文件)中，定义这个私有数据成员对象。示例代码如下：

 

[cpp] view plain copy

 

 

1. //————————————————————————————————————–  
2. // File name:  person.h  
3.   
4. struct PersonalDataPrivate; // 声明私有数据成员类型  
5.   
6. class Person  
7. {  
8. public:  
9.   
10.     Person ();   // constructor  
11.     virtual ~Person ();  // destructor  
12.     void setAge(const int);  
13.     int getAge();  
14.   
15. private:  
16.   
17.     PersonalDataPrivate* d;  
18. };  
19.   
20.    
21.   
22. //————————————————————————————————————–  
23. // File name:  person.cpp  
24.   
25. struct PersonalDataPrivate  // 定义私有数据成员类型  
26. {  
27.     string mszName; // 姓名  
28.     bool mbSex;    // 性别  
29.     int mnAge;     // 年龄  
30. };  
31.   
32. // constructor  
33. Person::Person ()  
34. {  
35.     d = new PersonalDataPrivate;  
36. };  
37.   
38. // destructor  
39. Person::~Person ()  
40. {  
41.     delete d;  
42. };  
43.   
44. void Person::setAge(const int age)  
45. {  
46.     if (age != d->mnAge)  
47.         d->mnAge = age;  
48. }  
49.   
50. int Person::getAge()  
51. {  
52.     return d->mnAge;  
53. }  

 

在最初学习Qt的时候，我也觉得这种方法很麻烦，但是随着使用的增多，我开始很喜欢这个方法了，而且，现在我写的代码，基本上都会用这种方法。具体说来，它有如下优点：

    * 减少头文件的依赖性
      把具体的数据成员都放到cpp文件中去，这样，在需要修改数据成员的时候，只需要改cpp文件而不需要头文件，这样就可以避免一次因为头文件的修改而导致所有包含了这个文件的文件全部重新编译一次，尤其是当这个头文件是非常底层的头文件和项目非常庞大的时候，优势明显。
      同时，也减少了这个头文件对其它头文件的依赖性。可以把只在数据成员中需要用到的在cpp文件中include一次就可以，在头文件中就可以尽可能的减少include语句
    * 增强类的封装性
      这种方法增强了类的封装性，无法再直接存取类成员变量，而必须写相应的 get/set 成员函数来做这些事情。
      关于这个问题，仁者见仁，智者见智，每个人都有不同的观点。有些人就是喜欢把类成员变量都定义成public的，在使用的时候方便。只是我个人不喜欢这种方法，当项目变得很大的时候，有非常多的人一起在做这个项目的时候，自己所写的代码处于底层有非常多的人需要使用(#include)的时候，这个方法的弊端就充分的体现出来了。

还有，我不喜欢 Qt 2.x 中把数据成员的变量名都定义成只有一个字母，d，看起来很不直观，尤其是在search的时候，很不方便。但是，Qt kernel 中的确就是这么干的。

 

Qt 4.6.x 中的方法

在 Qt 4.6 中，类成员变量定义方法的出发点没有变化，只是在具体的实现手段上发生了非常大的变化，下面具体来看。

在 Qt 4.6 中，使用了非常多的宏来做事，这凭空的增加了理解 Qt source code 的难度，不知道他们是不是从MFC学来的。就连在定义类成员数据变量这件事情上，也大量的使用了宏。

在这个版本中，类成员变量不再是给每一个class都定义一个私有的成员，而是把这一项common的工作放到了最基础的基类 QObject 中，然后定义了一些相关的方法来存取，好了，让我们进入具体的代码吧。

 

[cpp] view plain copy

 

 

1. //————————————————————————————————————–  
2. // file name: qobject.h  
3.   
4. class QObjectData  
5. {  
6. public:  
7.     virtual ~QObjectData() = 0;  
8.     // 省略  
9. };  
10.   
11. class QObject  
12. {  
13.     Q_DECLARE_PRIVATE(QObject)  
14.   
15. public:  
16.   
17.     QObject(QObject *parent=0);  
18.   
19. protected:  
20.   
21.     QObject(QObjectPrivate &dd, QObject *parent = 0);  
22.     QObjectData *d_ptr;  
23. }  

这些代码就是在 qobject.h 这个头文件中的。在 QObject class 的定义中，我们看到，数据员的定义为：QObjectData *d_ptr; 定义成 protected 类型的就是要让所有的派生类都可以存取这个变量，而在外部却不可以直接存取这个变量。而 QObjectData 的定义却放在了这个头文件中，其目的就是为了要所有从QObject继承出来的类的成员变量也都相应的要在QObjectData这个class继承出来。而纯虚的析构函数又决定了两件事：

 

    * 这个class不能直接被实例化。换句话说就是，如果你写了这么一行代码，new QObjectData， 这行代码一定会出错，compile的时候是无法过关的。
    * 当 delete 这个指针变量的时候，这个指针变量是指向的任意从QObjectData继承出来的对象的时候，这个对象都能被正确delete，而不会产生错误，诸如，内存泄漏之类的。

我们再来看看这个宏做了什么，Q_DECLARE_PRIVATE(QObject)

 

[cpp] view plain copy

 

 

1. #define Q_DECLARE_PRIVATE(Class) \  
2.     inline Class##Private* d_func() { return reinterpret_cast<Class##Private *>(d_ptr); } \  
3.     inline const Class##Private* d_func() const { return reinterpret_cast<const Class##Private *>(d_ptr); } \  
4.     friend class Class##Private;  

 

这个宏主要是定义了两个重载的函数，d_func()，作用就是把在QObject这个class中定义的数据成员变量d_ptr安全的转换成为每一个具体的class的数据成员类型指针。我们看一下在QObject这个class中，这个宏展开之后的情况，就一幕了然了。

Q_DECLARE_PRIVATE(QObject) 展开后，就是下面的代码：

 

[cpp] view plain copy

 

 

1. inline QObjectPrivate* d_func() { return reinterpret_cast<QObjectPrivate *>(d_ptr); }  
2. inline const QObjectPrivate* d_func() const  
3. { return reinterpret_cast<const QObjectPrivate *>(d_ptr); } \  
4. friend class QObjectPrivate;  

宏展开之后，新的问题又来了，这个QObjectPrivate是从哪里来的？在QObject这个class中，为什么不直接使用QObjectData来数据成员变量的类型？

 

还记得我们刚才说过吗，QObjectData这个class的析构函数的纯虚函数，这就说明这个class是不能实例化的，所以，QObject这个class的成员变量的实际类型，这是从QObjectData继承出来的，它就是QObjectPrivate !

这个 class 中保存了许多非常重要而且有趣的东西，其中包括 Qt 最核心的 signal 和 slot 的数据，属性数据，等等，我们将会在后面详细讲解，现在我们来看一下它的定义：

下面就是这个class的定义：

 

[cpp] view plain copy

 

 

1. class QObjectPrivate : public QObjectData  
2. {  
3.     Q_DECLARE_PUBLIC(QObject)  
4.   
5. public:  
6.   
7.     QObjectPrivate(int version = QObjectPrivateVersion);  
8.     virtual ~QObjectPrivate();  
9.     // 省略  
10. }  

那么，这个 QObjectPrivate 和 QObject 是什么关系呢？他们是如何关联在一起的呢？

 

让我们来看看这个 QObjectPrivate 和 QObject 是如何关联在一起的。

 

[cpp] view plain copy

 

 

1. //————————————————————————————————————–  
2. // file name: qobject.cpp  
3.   
4. QObject::QObject(QObject *parent)   
5.     : d_ptr(new QObjectPrivate)  
6. {  
7.   // ………………………  
8. }  
9.   
10. QObject::QObject(QObjectPrivate &dd, QObject *parent)  
11.     : d_ptr(&dd)  
12. {  
13.    // …………………  
14. }  

 

怎么样，是不是一目了然呀？

从第一个构造函数可以很清楚的看出来，QObject class 中的 d_ptr 指针将指向一个 QObjectPrivate 的对象，而QObjectPrivate这个class是从QObjectData继承出来的。

这第二个构造函数干什么用的呢？从 QObject class 的定义中，我们可以看到，这第二个构造函数是被定义为 protected 类型的，这说明，这个构造函数只能被继承的class使用，而不能使用这个构造函数来直接构造一个QObject对象，也就是说，如果写一条下面的语句，编译的时候是会失败的，
        new QObject(*new QObjectPrivate, NULL)

为了看的更清楚，我们以QWidget这个class为例说明。

QWidget是QT中所有UI控件的基类，它直接从QObject继承而来，

 

[cpp] view plain copy

 

 

1. class QWidget : public QObject, public QPaintDevice  
2. {  
3.     Q_OBJECT  
4.     Q_DECLARE_PRIVATE(QWidget)  
5.     // …………………  
6. }  

我们看一个这个class的构造函数的代码：

 

 

[cpp] view plain copy

 

 

1. QWidget::QWidget(QWidget *parent, Qt::WindowFlags f)  
2.     : QObject(*new QWidgetPrivate, 0), QPaintDevice()  
3. {  
4.     d_func()->init(parent, f);  
5. }  

非常清楚，它调用了基类QObject的保护类型的构造函数，并且以 *new QWidgetPrivate 作为第一个参数传递进去。也就是说，基类(QObject)中的d_ptr指针将会指向一个QWidgetPrivate类型的对象。

 

再看QWidgetPrivate这个class的定义：

 

[cpp] view plain copy

 

 

1. class QWidgetPrivate : public QObjectPrivate  
2. {  
3.     Q_DECLARE_PUBLIC(QWidget)  
4.     // …………………  
5. }  

好了，这就把所有的事情都串联起来了。

 

关于QWidget构造函数中的唯一的语句 d_func()->init(parent, f) 我们注意到在class的定义中有这么一句话： Q_DECLARE_PRIVATE(QWidget)

我们前面讲过这个宏，当把这个宏展开之后，就是这样的：

 

[cpp] view plain copy

 

 

1. inline QWidgetPrivate* d_func() { return reinterpret_cast<QWidgetPrivate *>(d_ptr); }  
2. inline const QWidgetPrivate* d_func() const  
3. { return reinterpret_cast<const QWidgetPrivate *>(d_ptr); } \  
4. friend class QWidgetPrivate;  

 

很清楚，它就是把QObject中定义的d_ptr指针转换为QWidgetPrivate类型的指针。

小结：

要理解Qt Kernel的code，就必须要知道Qt中每一个Object内部的数据是如何保存的，而Qt没有象我们平时写code一样，把所有的变量直接定义在类中，所以，不搞清楚这个问题，我们就无法理解一个相应的class。其实，在Qt4.6中的类成员数据的保存方法在本质是与Qt2.x中的是一样的，就是在class中定义一个成员数据的指针，指向成员数据集合对象(这里是一个QObjectData或者是其派生类)。初始化这个成员变量的办法是定义一个保护类型的构造函数，然后在派生类的构造函数new 一个派生类的数据成员，并将这个新对象赋值给QObject的数据指针。在使用的时候，通过预先定义个宏里面的一个inline函数来把数据指针在安全类型转换，就可以使用了。

本文原始地址：http://www.qkevin.com/archives/63

http://blog.csdn.net/czyt1988/article/details/19255541