Qt之美(一) D指针/私有实现

相信不少刚开始阅读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. };  
 

 

显然,这里的私有成员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. };  
 

 

这里,我们定义了一个指针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;  
 

 

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

 

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

 

这里的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;  
 

 

而我们还可以用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()  
 

 

这就是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. }  

 

你可能感兴趣的:(设计模式,Class,qt,Signal)