前面我们已经看到了怎样使用标准的 C++ 代码以及 Qt 提供的 API 来达到信息隐藏这一目标。下面我们来看一下 Qt 是如何实现的。

还是以 QObject 的源代码作为例子。先打开 qobject.h,找到 QObjectData 这个类的声明。具体代码如下所示:

  1. QObjectData {  
  2. public:  
  3.        virtual ~QObjectData() = 0;  
  4.        // others  
  5. };  

然后在下面就可以找到 QObject 的声明:

  1. class QObject  
  2. {  
  3.        Q_DECLARE_PRIVATE(QObject)  
  4. public:  
  5.        Q_INVOKABLE explicit QObject(QObject *parent=0);  
  6. protected:  
  7.        QObject(QObjectPrivate &dd, QObject *parent = 0);  
  8.        QScopedPointer<QObjectData> d_ptr;  
  9.        // others  
  10. }  

注意,这里我们只是列出了我们所需要的代码,并且我的 Qt 版本是 2010.03。这部分代码可能会随着不同的 Qt 版本所有不同。

首先先了解一下 Qt 的设计思路。既然每个类都应该把自己的数据放在一个 private 类中,那么,为什么不把这个操作放在几乎所有类的父类 QObject 中呢?所以,Qt 实际上是用了这样一个思路,实现了我们前面介绍的数据隐藏机制。

首先回忆一下,我们前面说的 D-Pointer 需要有一个 private 或者 protected 的指向自己数据类的指针。在 QObject 中,

  1. QScopedPointer<QObjectData> d_ptr; 

就扮演了这么一个角色。或许,你可以把它理解成

  1. QObjectData *d_ptr; 

这不就和我们前面说的 D-Pointer 技术差不多了?QScopedPointer 是 Qt 提供的一个辅助类,这个类保存有一个指针,它的行为类似于一种智能指针:它能够保证在这个作用域结束后,里面的所有指针都能够被自动 delete 掉。也就是说,它其实就是一个比普通指针更多功能的指针。而这个指针被声明成 protected 的,也就是只有它本身以及其子类才能够访问到它。这就提供了让子类不必须声明这个 D-Pointer 的可能。

那么,前面我们说,QObjectData 这种数据类不应该放在公开的头文件中,可 Qt 怎么把它放进来了呢?这样做的用途是,QObject 的子类的数据类都可能继承自这个 QObjectData。这个类有一个纯虚的析构函数。没有实现代码,保证了这个类不能被初始化;虚的析构函数,保证了其子类都能够被正确的析构。

回到我们前面说明的 Q_DECLARE_PRIVATE 这个宏:

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

我们把代码中的 Q_DECLARE_PRIVATE(QObject) 展开看看是什么东西:

  1. inline QObjectPrivate* d_func() { return reinterpret_cast(qGetPtrHelper(d_ptr)); }  
  2.     inline const QObjectPrivate* d_func() const { return reinterpret_cast(qGetPtrHelper(d_ptr)); }  
  3.     friend class QObjectPrivate; 

清楚是清楚,只是这个 QObjectPrivate 是哪里来的?既然是 Private,那么它肯定不会在公开的头文件中。于是我们立刻想到到 qobject.cpp 或者是 qobject_p.h 中寻找。终于,我们在 qobject_p.h 中找到了这个类的声明:

  1. class Q_CORE_EXPORT QObjectPrivate : public QObjectData     
  2.     {  
  3.         Q_DECLARE_PUBLIC(QObject)     
  4.          
  5. public:     
  6.         QObjectPrivate(int version = QObjectPrivateVersion);     
  7.         virtual ~QObjectPrivate();     
  8.         // others     

这个类是继承 QObjectData 的!想想也是,因为我们说过,QObjectData 是不能被实例化的,如果要使用,必须创建它的一个子类。显然,QObjectPrivate 就扮演了这么一个角色了。不仅如此,我们还在这里看到了熟悉的 Q_DECLARE_PUBLIC 宏。好在我们已经知道它的含义了。

在 qobject.cpp 中,我们看一下 QObject 的构造函数:

  1. QObject::QObject(QObject *parent)  
  2.         : d_ptr(new QObjectPrivate)     
  3. {     
  4.       // others     
  5. }  
  6.          
  7. QObject::QObject(QObjectPrivate &dd, QObject *parent)  
  8.         : d_ptr(&dd)     
  9. {     
  10.        // others     

第一个构造函数就是我们经常见到的那个。它使用自己创建的 QObjectPrivate 指针对 d_ptr 初始化。第二个构造函数使用传入的 QObjectPrivate 对象,但它是 protected 的,也就是说,你不能在外部类中使用这个构造函数。那么这个构造函数有什么用呢?我们来看一下 QWidget 的代码:

  1. class QWidget : public QObject, public QPaintDevice  
  2. {     
  3.         Q_OBJECT     
  4.         Q_DECLARE_PRIVATE(QWidget)     
  5.         // others     
  6. }     

QWidget 是 QObject 的子类,然后看它的构造函数:

  1. QWidget::QWidget(QWidget *parent, Qt::WindowFlags f)     
  2.         : QObject(*new QWidgetPrivate, 0), QPaintDevice()  
  3. {  
  4.         QT_TRY {     
  5.             d_func()->init(parent, f);     
  6.         } QT_CATCH(...) {     
  7.             QWidgetExceptionCleaner::cleanup(this, d_func());     
  8.             QT_RETHROW;     
  9.         }     
  10. }    

它调用了那个QObject 的 protected 构造函数,并且传入一个 QWidgetPrivate !这个 QWidgetPrivate 显然继承了 QObjectPrivate。于是我们已经明白,为什么 QWidget 中找不到 d_ptr 了,因为所有的 d_ptr 都已经在父类 QObject 中定义好了!尝试展开一下 Q_DECLARE_PRIVATE 宏,你就能够发现,它实际上把父类的 QObjectPrivate 指针偷偷地转换成了 QWidgetPrivate 的指针。这个就是前面说的 Qt 的设计思路。