D指针/私有实现

相信不少刚开始阅读Qt源代码的朋友在看到其中的Private类和诸如Q_D、Q_Q等宏时都会思考，为什么Qt要用这样一个设计模式呢？这样一段增加了不少复杂度的代码，到底有多大的好处呢？简单的说，这样的好处在于保证代码的二进制兼容性。

什么是二进制兼容性？大名鼎鼎的KDE项目是这样介绍的：一个库是二进制兼容的，如果一个程序和某个库的某个版本动态链接，并且不需要重新编译，即可在安装有该库较新版本的环境中运行。为什么要保证二进制兼容性？如果不能保证库的二进制兼容性，就意味着每次发布新版本时，依赖该库的所有程序都必须重新编译才能正常运行。显然，这对于像Qt这样被广泛采用的库而言是完全不可接受的。关于二进制兼容性的更多信息，感兴趣的朋友可以参考下KDE TechBase上的这篇文章，这里就不罗嗦了，仅仅和大家分享下具体的使用。

如果不使用D指针，那我们可能会有如下的一个类声明：

[cpp] view plain copy print ?

1. class MyClass

2. {
3. public:
4. MyClass();
5. ~MyClass();
6. private:
7. int myVar;
8. };

class MyClass { public: MyClass(); ~MyClass(); private: int myVar; };

显然，这里的私有成员myVar是保证代码二进制兼容性的大敌，所以我们需要使用D指针，改写这个类：

[cpp] view plain copy print ?

1. class MyClassPrivate;
2. class MyClass
3. {
4. public:
5. MyClass();
6. ~MyClass();
7. private:
8. MyClassPrivate * const d_ptr;
9. Q_DECLARE_PRIVATE(MyClass);
10. };

class MyClassPrivate; class MyClass { public: MyClass(); ~MyClass(); private: MyClassPrivate * const d_ptr; Q_DECLARE_PRIVATE(MyClass); };

这里，我们定义了一个指针d_ptr指向私有实现类，然后用Q_DECLARE_PRIVATE宏来定义一些辅助函数和声明友元类：

[cpp] view plain copy print ?

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

#define Q_DECLARE_PRIVATE(Class) / inline Class##Private* d_func() { return reinterpret_cast<Class##Private *>(qGetPtrHelper(d_ptr)); } / inline const Class##Private* d_func() const { return reinterpret_cast<const Class##Private *>(qGetPtrHelper(d_ptr)); } / friend class Class##Private;

然后这个私有类的实现如下所示：

[cpp] view plain copy print ?

1. class MyClassPrivate
2. {
3. public:
4. MyClassPrivate(MyClass *parent);
5. private:
6. MyClass * const q_ptr;
7. Q_DECLARE_PUBLIC(MyClass);
8. int myVar;
9. };

class MyClassPrivate { public: MyClassPrivate(MyClass *parent); private: MyClass * const q_ptr; Q_DECLARE_PUBLIC(MyClass); int myVar; };

这里的q_ptr指针就是指向公开的接口了，然后Q_DECLARE_PUBLIC宏则定义了辅助函数并声明了友元类：

[cpp] view plain copy print ?

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

#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;

而我们还可以用Q_D和Q_Q两个宏来进一步简化访问：

[cpp] view plain copy print ?

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

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

这就是Qt中D指针/私有实现的最基本使用方法。最后用一个比较完整的例子作为结尾;)

[cpp] view plain copy print ?

1. // myclass.h
2. #ifndef MYCLASS_H
3. #define MYCLASS_H
4. #include <QtCore/QObject>
5. class MyClassPrivate;
6. class MyClass: public QObject
7. {
8. Q_OBJECT
9. public:
10. MyClass(QObject *parent = 0);
11. virtual ~MyClass();
12. void dummyFunc();
13. signal:
14. void dummySignal();
15. private:
16. MyClassPrivate * const d_ptr;
17. Q_DECLARE_PRIVATE(MyClass);
18. Q_DISABLE_COPY(MyClass);
19. };
20. #endif // MYCLASS_H
21. // myclass.cpp
22. #include "myclass.h"
23. class MyClassPrivate
24. {
25. public:
26. MyClassPrivate(MyClass *parent)
27. : q_ptr(parent)
28. {
29. }
30. void foobar()
31. {
32. Q_Q(MyClass);
33. emit q->dummySignal();
34. }
35. private:
36. MyClass * const q_ptr;
37. Q_DECLARE_PUBLIC(MyClass);
38. };
39. MyClass::MyClass(QObject *parent)
40. : QObject(parent)
41. , d_ptr(new MyClassPrivate(this))
42. {
43. }
44. MyClass::~MyClass()
45. {
46. Q_D(MyClass);
47. delete d;
48. }
49. void MyClass::dummyFunc()
50. {
51. Q_D(MyClass);
52. d->foobar();
53. }