原创 Qt之美（一）：D指针/私有实现 收藏 此文于2010-12-01被推荐到CSDN首页 如何被推荐？ The English version is available at: http://xizhizhu.blogspot.com/2010/

  Qt之美（一）：D指针/私有实现 收藏

此文于2010-12-01被推荐到CSDN首页
如何被推荐？

The English version is available at: http://xizhizhu.blogspot.com/2010/11/beauty-of-qt-1-d-pointer-private.html

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

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

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

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指针，改写这个类：

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宏来定义一些辅助函数和声明友元类：

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;

 

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

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宏则定义了辅助函数并声明了友元类：

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两个宏来进一步简化访问：

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指针/私有实现的最基本使用方法。最后用一个比较完整的例子作为结尾;)

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. }