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

你可能感兴趣的:(设计模式,二进制,源代码,qt)