Qt之美（一）：d指针/p指针详解

Translated  by  mznewfacer   2011.11.16

首先，看了Xizhi Zhu 的这篇Qt之美（一）：D指针/私有实现，对于很多批评不美的同路人，暂且不去评论，只是想支持一下Xizhi Zhu，在引用一下Jerry Sun的话，“C++需要宏定义就像需要设计模式一样。也许你不知道，宏是图灵完全（turing complete）的，至少LISP下是这样，C/C++需要宏，几乎所有重要的C/C++库都需要和依赖宏。这些都超过咱们的想象，宏能带给我们所谓语法糖(Syntax sugar)的方便。如果你不理解，并且不能熟练使用宏，内联函数和通用模板，那么你还和熟练的C++程序员有一定距离。”
        这里不去评论Jerry Sun的理解，有关宏是否图灵完全，对实际编程也没有啥意义的。至少我们看到Qt用了不少。闲话少叙，书归正文。

1.二进制兼容性

这里，先简单解释一下什么破坏了代码的二进制兼容性（至于二进制兼容性是什么，相信Xizhi Zhu的文章和KDE上的这篇文章，已经说的很清楚了，有时间的话再翻译一下）。换句话说，在对程序做了什么样的改变需要我们重新编译呢？看下面的例子：

1. class Widget {
2. ...
3. private:
4. Rect m_geometry;
5. };
6. class  Label :public Widget {
7. ...
8. String text()const{return m_text; }
9. private:
10. String m_text;
11. };

在这里工程名为CuteApp，Widget类包含一个私有成员变量m_geometry。我们编译Widget类，并且将其发布为WidgetLib 1.0。对于WidgetLib 1.1版本，我们希望加入对样式表的支持。在Widget类中我们相应的加入了新的数据成员。

1. class  Widget {
2. ...
3. private:
4. Rect m_geometry;
5. String m_stylesheet; // NEW in WidgetLib 1.1
6. };
7. class  Label :public Widget {
8. public:
9. ...
10. String text()const{return m_text; }
11. private:
12. String m_text;
13. } ;

经过上述改变后，我们发现工程CuteApp可以通过编译，但是当运行调用WidgetLib1.0时，程序崩溃。
为什么会运行出错呢？
是因为我们在加入成员变量m_stylesheet后，改变了Widget和Label类的对象布局。这是由于当编译器在编译程序时，它是用所谓的offsets来标记在类中的成员变量。我们将对象布局简化，其在内存中大致形象如下所示：

在WidegetLib 1.0中，Label类的成员变量m_text还在<offset 1>。被编译器编译后，将Label::text()方法解释为获取Label对象的<offset 1>。而在WidegetLib 1.1中，由于添加新的数据成员，导致m_text的标记位变为<offset 2>。由于工程没有重新编译，c++编译器还会将在编译和运行时的对象大小认为一致。也就是说，在编译时，编译器为Label对象按照其大小在内存上分配了空间。而在运行时，由于Widget中m_stylesheet的加入导致Label的构造函数重写了已经存在的内存空间，导致了程序崩溃。

   所以只要版本已发布，除非重新编译工程，否则就不能更改类的结构和大小。那么，为了能够为原有类方便的引入新的功能，这就是Qt引入D指针的目的。

2.D指针

  保持一个库中的所有公有类的大小恒定的问题可以通过单独的私有指针给予解决。这个指针指向一个包含所有数据的私有数据结构体。这个结构体的大小可以随意改变而不会产生副作用，应用程序只使用相关的公有类，所使用的对象大小永远不会改变，它就是该指针的大小。这个指针就被称作D指针。

1. /* widget.h */
2. // 私有数据结构体声明。 其定义会在 widget.cpp 或是
3. //  widget_p.h，总之不能在此头文件
4. class   WidgetPrivate;
5. class   Widget {
6. ...
7. Rect geometry()const;
8. ...
9. private:
10. // d指针永远不能在此头文件中被引用
11. //  由于WidgetPrivate没有在此头文件中被定义,
12. // 任何访问都会导致编译错误。
13. WidgetPrivate *d_ptr;
14. };
15. /* widget_p.h */(_p 指示private)
16. struct WidgetPrivate {
17. Rect geometry;
18. String stylesheet;
19. };
20. /* widget.cpp */
21. #include "widget_p.h"
22. Widget::Widget()
23. : d_ptr(new WidgetPrivate)// 初始化 private 数据 {
24. }
25. Rect Widget::geoemtry()const{
26. // 本类的d指针只能被在自己的库内被访问
27. return d_ptr->geometry;
28. }
29. /* label.h */
30. class   LabelPrivate;
31. class  Label :publicWidget {
32. ...
33. String text();
34. private:
35. // 自己类对应自己的d指针
36. LabelPrivate *d_ptr;
37. };
38. /* label.cpp */
39. // 这里将私有结构体在cpp中定义
40. struct LabelPrivate {
41. String text;
42. };
43. Label::Label()
44. : d_ptr(new LabelPrivate) {
45. }
46. String Label::text() {
47. return d_ptr->text;
48. }

有了上面的结构，CuteApp就不会与d指针直接打交道。因为d指针只能在WidgetLib中被访问，在每一次对Widget修改之后都要对其重新编译，私有的结构体可以随意更改，而不需要重新编译整个工程项目。

3.D指针的其他好处
除了以上优点，d指针还有如下优势：
1.隐藏实现细节——我们可以不提供widget.cpp文件而只提供WidgetLib和相应的头文件和二进制文件。
2.头文件中没有任何实现细节，可以作为API使用。
3.由于原本在头文件的实现部分转移到了源文件，所以编译速度有所提高。
其实以上的点都很细微，自己跟过源代码的人都会了解，qt是隐藏了d指针的管理和核心源的实现。像是在_p.h中部分函数的声明，qt也宣布在以后版本中将会删除。（ This file is not part of the Qt API.  It exists purely as an implementation detail.  This header file may change from version to version without notice, or even be removed.）

4.Q指针
到目前为止，我们已经熟悉了指向私有结构体的d指针。而在实际中，往往它将包含私有方法（helper函数）。例如，LabelPrivate可能会有getLinkTargetFromPoint（）(helper函数）以当按下鼠标时去找到相应的链接目标。在很多场合，这些helper函数需要访问公有类，例如访问一些属于Label类或是其基类Widget的函数。
比方说，一个帮助函数setTextAndUpdateWidget()可能会调用Widget::update()函数去重新绘制Widget。因此，我们同样需要WidgetPrivate存储一个指向公有类的q指针。

1. /* widget.h */
2. class  WidgetPrivate;
3. class  Widget {
4. ...
5. Rect geometry()const;
6. ...
7. private:
8. WidgetPrivate *d_ptr;
9. };
10. /* widget_p.h */
11. struct     WidgetPrivate {
12. // 初始化q指针
13. WidgetPrivate(Widget *q) : q_ptr(q) { }
14. Widget *q_ptr;// q-ptr指向基类API
15. Rect geometry;
16. String stylesheet;
17. };
18. /* widget.cpp */
19. #include "widget_p.h"
20. // 初始化 private 数据，将this指针作为参数传递以初始化 q-ptr指针
21. Widget::Widget()
22. : d_ptr(new WidgetPrivate(this)) {
23. }
24. Rect Widget::geoemtry()const{
25. return d_ptr->geometry;
26. }
27. /* label.h */
28. class   LabelPrivate;
29. class  Label :publicWidget {
30. ...
31. String text()const;
32. private:
33. LabelPrivate *d_ptr;};
34. /* label.cpp */
35. struct LabelPrivate {
36. LabelPrivate(Label *q) : q_ptr(q) { }
37. Label *q_ptr; //Label中的q指针
38. String text;
39. };
40. Label::Label()
41. : d_ptr(new LabelPrivate(this)) {
42. }
43. String Label::text() {
44. return d_ptr->text;
45. }

5.进一步优化

在以上代码中，每产生一个Label对象，就会为相应的LabelPrivate和WidgetPrivate分配空间。如果我们用这种方式使用Qt的类，那么当遇到像QListWidget(此类在继承结构上有6层深度），就会为相应的Private结构体分配6次空间。
在下面示例代码中，将会看到，我们用私有类结构去实例化相应构造类，并在其继承体系上全部通过d指针来初始化列表。

1. /* widget.h */
2. class  Widget {
3. public:
4. Widget();
5. ...
6. protected:
7. // 只有子类会访问以下构造函数
8. Widget(WidgetPrivate &d);// 允许子类通过它们自己的私有结构体来初始化
9. WidgetPrivate *d_ptr;
10. };
11. /* widget_p.h */
12. struct  WidgetPrivate {
13. WidgetPrivate(Widget *q) : q_ptr(q) { }
14. Widget *q_ptr;
15. Rect geometry;
16. String stylesheet;
17. };
18. /* widget.cpp */
19. Widget::Widget()
20. : d_ptr(new WidgetPrivate(this)) {
21. }
22. Widget::Widget(WidgetPrivate &d)
23. : d_ptr(&d) {
24. }
25. /* label.h */
26. class Label :public Widget {
27. public:
28. Label();
29. ...
30. protected:
31. Label(LabelPrivate &d);// 允许Label的子类通过它们自己的私有结构体来初始化
32. //  注意Label在这已经不需要d_ptr指针，它用了其基类的d_ptr
33. };
34. /* label.cpp */
35. #include "widget_p.h"
36. class LabelPrivate :public WidgetPrivate {
37. public:
38. String text;
39. };
40. Label::Label()
41. : Widget(*new LabelPrivate)//用其自身的私有结构体来初始化d指针
42. }
43. Label::Label(LabelPrivate &d)
44. : Widget(d) {
45. }

这时候，我觉得我体会到了不一样的感觉，有点意思了吧，说不美的，可以想个更好的解决方案么？
当我们建立一个Label对象时，它就会建立相应的LabelPrivate结构体（其是WidgetPrivate的子类）。它将其d指针传递给Widget的保护构造函数。这时，建立一个Label对象仅需为其私有结构体申请一次内存。Label同样也有一个保护构造函数可以被继承Label的子类使用，以提供自己对应的私有结构体。

6.将q-ptr和d-ptr转换成正确类型

前面一步优化导致的副作用是q-ptr和d-ptr分别是Widget和WidgetPrivate类型。这就意味着下面的操作是不起作用的。

1. void Label::setText(constString &text) {
2. // 不起作用的，因为d_ptr是WidgetPrivate类型的，即使其指向LabelPrivate对象
3. d_ptr->text = text;
4. }

所以为了在子类能够使用d指针，我们用static_cast来做强制转换。

1. void Label::setText(const String &text) {
2. LabelPrivate *d =static_cast<LabelPrivate *>(d_ptr);// cast to our private type
3. d->text = text;
4. }

为了不让所有地方都飘满static_cast，我们才引入宏定义。

1. // global.h (macros)
2. #define DPTR(Class) Class##Private *d = static_cast<Class##Private *>(d_ptr)
3. #define QPTR(Class) Class *q = static_cast<Class *>(q_ptr)
4. // label.cpp
5. void Label::setText(constString &text) {
6. DPTR(Label);
7. d->text = text;
8. }
9. void LabelPrivate::someHelperFunction() {
10. QPTR(label);
11. q->selectAll();// 我们现在可以通过此函数来访问所有Label类中的方法
12. }

至于，Qt中的D指针和Q指针的具体形式以及相应的宏定义，这里就不再重复，Xizhi Zhu的文章中已经有写，完整的d指针和q指针的程序实例程序如下：（结合信号和槽机制）

 //d_ptr.h

1. #ifndef D_PTR_H
2. #define D_PTR_H
3. #include <QObject>
4. template <typename T> static inline T *GetPtrHelper(T *ptr) { return ptr; }
5. #define DECLARE_PRIVATE(Class) \
6. inline Class##Private* d_func() { return reinterpret_cast<Class##Private*>(GetPtrHelper(d_ptr)); } \
7. inline const Class##Private* d_func() const { return reinterpret_cast<const Class##Private*>(GetPtrHelper(d_ptr)); }\
8. friend class Class##Private;
9. #define DPTR(Class) Class##Private * const d  = d_func()
10. class MyClassPrivate;
11. class MyClass : public QObject {
12. Q_OBJECT
13. public:
14. explicit MyClass(QObject *parent = 0);
15. virtual ~MyClass();
16. void testFunc();
17. protected:
18. MyClass(MyClassPrivate &d);
19. private:
20. MyClassPrivate * const d_ptr;
21. DECLARE_PRIVATE(MyClass);
22. MyClass(const MyClass&);
23. MyClass& operator= (const MyClass&);
24. };
25. #endif

//d_ptr.cpp

1. #include "d_ptr.h"
2. #include "q_ptr.h"
3. MyClass::MyClass(QObject *parent) : QObject(parent),
4. d_ptr(new MyClassPrivate(this)) {}
5. MyClass::~MyClass() {
6. DPTR(MyClass);
7. delete d;
8. }
9. void MyClass::testFunc() {
10. DPTR(MyClass);
11. d->fool();
12. }

//q_ptr.h

1. #ifndef Q_PTR_H
2. #define Q_PTR_H
3. #include <QObject>
4. #include "d_ptr.h"
5. #define DECLARE_PUBLIC(Class) \
6. inline Class* q_func() { return static_cast<Class *>(q_ptr); } \
7. inline const Class* q_func() const { return static_cast<const Class *>(q_ptr); } \
8. friend class Class;
9. #define QPTR(Class) Class * const q = q_func()
10. class MyClassPrivate : public QObject
11. {
12. Q_OBJECT
13. public:
14. MyClassPrivate(MyClass *q, QObject *parent = 0);
15. virtual ~MyClassPrivate() {}
16. signals:
17. void testSgnl();
18. private slots:
19. void testSlt();
20. public:
21. void fool();
22. private:
23. MyClass * const q_ptr;
24. DECLARE_PUBLIC(MyClass);
25. };
26. #endif

//q_ptr.cpp

1. #include <stdio.h>
2. #include "q_ptr.h"
3. MyClassPrivate::MyClassPrivate(MyClass *q, QObject *parent) : QObject(parent), q_ptr(q) {
4. connect(this, SIGNAL(testSgnl()), this, SLOT(testSlt()));
5. }
6. void MyClassPrivate::fool() {
7. emit testSgnl();
8. }
9. void MyClassPrivate::testSlt() {
10. printf("This is a pimpl pattern sample implemented in qt's \"d_ptr, q_ptr\" way\n");
11. }

//main.cpp

1. #include "q_ptr.h"
2. int main(/*int argc, char *argv[]*/) {
3. MyClass * d_ptr = new MyClass;
4. d_ptr->testFunc();
5. delete d_ptr;
6. while(1);
7. return 0;
8. }

-------------------------------------------------------------------

写的真好。我一开始也是认为是数据和实现分开，然后看了有二进制兼容部分。博主还写到了内存分配的部分，确实是挺好的，我现在写程序从没有考虑到内存的问题，现在实力还没达到要考虑内存的时候。

楼主分析的很到位，比Xizhi Zhu剖析得清楚。
其实，D指针这种东西，在看C++ GUI with QT4 programming的时候我就看到了，就在第五章那个plot的例子里；我自己提供给别人的模块里也用了这种privateData的方式来保存私有的数据。以前的主要认识就是为了隐藏自己实现细节，还有就是可以使用一个模板类来继承privateData类，用来处理不同的数据类型。没想到Qt里还有二进制兼容的考虑。
关于宏，我觉得对于Qt这样的跨平台语言来说，根本就无法避免。只要能让程序变得简洁，用宏也挺好的，没必要自己给自己设置樊笼，就如同有的人用goto语句也可以让程序清晰明了。
楼主有空写写关于Qt里集合类，如QVector、QList之类的实现吧。

http://blog.csdn.net/mznewfacer/article/details/6976293