d指针在Qt上的应用及实现(d指针能实现二进制兼容)

Posted 朝闻道

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了d指针在Qt上的应用及实现(d指针能实现二进制兼容)相关的知识,希望对你有一定的参考价值。

Qt为了使其动态库最大程度上实现二进制兼容,引入了d指针的概念。那么为什么d指针能实现二进制兼容呢?为了回答这个问题,首先弄清楚什么是二进制兼容?所谓二进制兼容动态库,指的是一个在老版本库下运行的程序,在不经过编译的情况下,仍然能够在新的版本库下运行;需要经过编译才能在新版本下运行,而不需要修改该程序源代码,我们就说该动态库是源代码兼容的。要使一个dll能达到二进制兼容,对于一个结构,对于一个对象,其数据模型应该不变,若有变动,比如在类中增加数据成员或删除数据成员,其结果肯定影响对象的数据模型,从而导致原有数据程员在对象数据模型里的位移发生变化,这样的话编译后的新版本库很可能使程序发生崩溃,为了使在增加和添加项后不使对象数据模型大小发生变化,一种做法是预先分配若干个保留空间,当要添加项时,使用保留项。如下:

 

[html] view plain copy
 
  1. class A {  
  2.       
  3. private:  
  4.     int a;  
  5.     int reserved[3];  
  6. };  
  7.   
  8. class B {  
  9. private:  
  10.     int a;  
  11.     quint32 b : 1;  
  12.     quint32 reserved : 31;  
  13. };  

这样的话,当样增加项的时候,只需要利用reserved空间,这样的话,对象模型就不会改变。但是这种做法很呆板,因为你不知道未来到底会有多少扩展项,少了不满足要求,多了浪费空间。那麽有没有一种更灵活的方法呢?如下:

 

 

[html] view plain copy
 
  1. class Data {  
  2. public:  
  3.     int a;  
  4. };  
  5.   
  6. class A {  
  7.       
  8. private:  
  9.     Data *d_ptr;  
  10. };  

将A中的成员a放入Data 中,A中放入Data的一个指针,这样的话,无论你向Data中添加多少数据,A的对象模型始终是4个字节的大小(d_ptr指针的大小),这种做法是不是比上面的做法更灵活呢?d_ptr就是我们今天所要说的d指针,Qt为了实现二进制兼容,绝大数类中都包含有这样的指针,下面我们一起来看看Qt的d指针是怎么实现的:

 



如上图,这个是Qt根结点的指针的一般形式,下面来看看非根结点的一般形式,

注意这里QWidge派生自QObject,它里面没有d_ptr,但是它的成员函数可以访问d_ptr,因为 d_ptr是保护成员,且它的对象模型包含 d_ptr(这是因为派生类继承父类的所有成员)。

 

下面我们来看看Qt对上述两种情况是怎么实现的:

qobject.h文件:

 

[html] view plain copy
 
  1. QObjectData {  
  2. public:  
  3.     QObject *q_ptr;  
  4.     ...  
  5. };  
  6.   
  7. class Q_CORE_EXPORT QObject  
  8. {  
  9.     ...  
  10.     Q_DECLARE_PRIVATE(QObject)  
  11. public:  
  12.     Q_INVOKABLE explicit QObject(QObject *parent=0);  
  13.     virtual ~QObject();  
  14.     ...  
  15.   
  16. protected:  
  17.     QObject(QObjectPrivate &dd, QObject *parent = 0);  
  18.     ...      
  19.       
  20. protected:  
  21.     QScopedPointer<QObjectData> d_ptr;  
  22.     ...  
  23. };  

 

如上,在这里我算去了其他的项,只保留了于d_ptr有关的项,首先来看看Q_DECLARE_PRIVATE(QObject)是什么:

 

[html] view plain copy
 
  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;  

根据宏定义,则Q_DECLARE_PRIVATE(QObject)翻译如下:

 

 

[html] view plain copy
 
  1. inline QObjectPrivate *d_func()  
  2. {  
  3.     return reinterpret_cast<QObjectPrivate *>(qGetPtrHelper(d_ptr));   
  4. }  
  5. inline const QObjectPrivate *d_func() const  
  6. {   
  7.     return reinterpret_cast<const QObjectPrivate *>(qGetPtrHelper(d_ptr));  
  8. }  
  9. friend class QObjectPrivate;  


再来看看qGetPtrHelper的定义:

 

 

[html] view plain copy
 
  1. template <typename T> static inline T *qGetPtrHelper(T *ptr)  
  2. {   
  3.     return ptr;  
  4. }  

 

再来看QScopePointer,它类似于智能指针,这样不用关心 d_ptr的释放,当离开QScopePointer的作用范围,QScopePointer会自动释放d_ptr指向的堆内存,那麽这个指针是什么时候生成的呢?q_ptr又是什么时候赋值的呢?让我们来看看qobject.cpp的实现:

 

[html] view plain copy
 
  1. QObject::QObject(QObject *parent)  
  2.     : d_ptr(new QObjectPrivate)  
  3. {  
  4.     Q_D(QObject);  
  5.     d_ptr->q_ptr = this;  
  6.     ...  
  7. }  
  8.   
  9. QObject::QObject(QObjectPrivate &dd, QObject *parent)  
  10.     : d_ptr(&dd)  
  11. {  
  12.     Q_D(QObject);  
  13.     d_ptr->q_ptr = this;  
  14.     ...  
  15. }  

我们看第一个构造函数,对于根结点的d_ptr指向new QObjectPrivate,而QObjectPrivate派生自QObjectData,那麽Q_D(QObject)宏表示什么意思呢?

[html] view plain copy
 
  1. #define Q_D(Class) Class##Private * const d = d_func()  

Q_D(QObject);翻译如下:

 

[html] view plain copy
 
  1. QObjectPrivate * const d = d_func();  

不难看出Q_D(QObject);定义了一个QObjectPrivate的常量指针,指向d_func() 的返回值,而该返回值,正是d_ptr(见头文件 d_func()的定义),因此同过Q_D宏我们就可以访问d指针了。

 

对于第二个构造函数稍后介绍,下面来看看非根结点的d_ptr的实现情况:

头文件:

 

[html] view plain copy
 
  1. class Q_CORE_EXPORT QObjectPrivate : public QObjectData  
  2. {  
  3.     Q_DECLARE_PUBLIC(QObject)  
  4.     ...  
  5. };  
  6.   
  7. class Q_GUI_EXPORT QWidgetPrivate : public QObjectPrivate  
  8. {  
  9.     Q_DECLARE_PUBLIC(QWidget)  
  10.     ...  
  11. };  
  12.   
  13. class Q_GUI_EXPORT QWidget : public QObject  
  14. {  
  15.     ...  
  16.     Q_DECLARE_PRIVATE(QWidget)  
  17.     ...  
  18. public:  
  19.     ...  
  20.     explicit QWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);  
  21.     ...  
  22. };  

我们首先来看看Q_DECLARE_PUBLIC宏:

 

 

[html] view plain copy
 
  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_DECLARE_PUBLIC(QObject)翻译如下:

 

 

[html] view plain copy
 
  1. inline QObject *q_func()  
  2. {   
  3.     return static_cast<QObject *>(q_ptr);  
  4. }   
  5. inline const QObject *q_func() const   
  6. {   
  7.     return static_cast<const QObject *>(q_ptr);  
  8. }   
  9. friend class QObject;  

 

Q_DECLARE_PUBLIC(QWidget)翻译如下:

 

[html] view plain copy
 
  1. inline QWidget *q_func()  
  2. {   
  3.     return static_cast<QWidget *>(q_ptr);  
  4. }   
  5. inline const QWidget *q_func() const   
  6. {   
  7.     return static_cast<const QWidget *>(q_ptr);  
  8. }   
  9. friend class QWidget;  

注意这里的q_ptr是在QObjectData里公有声明的,QObjectPrivate,QWidgetPrivate都派生或间接派生自QObjectData,所以可以访问q_ptr。

 

接下来看Q_DECLARE_PRIVATE(QWidget)的翻译:

 

[html] view plain copy
 
  1. inline QWidgetPrivate *d_func()  
  2. {  
  3.     return reinterpret_cast<QWidgetPrivate *>(qGetPtrHelper(d_ptr));   
  4. }  
  5. inline const QWidgetPrivate *d_func() const  
  6. {   
  7.     return reinterpret_cast<const QWidgetPrivate *>(qGetPtrHelper(d_ptr));  
  8. }  
  9. friend class QWidgetPrivate;  

 

 

接下来看看QWidget的构造函数的实现:

[html] view plain copy
 
  1. QWidget::QWidget(QWidget *parent, Qt::WindowFlags f)  
  2.     : QObject(*new QWidgetPrivate, 0)  
  3. {  
  4.     ...  
  5. }  


看到QObject(*new QwidgetPrivate, 0)这里调用了QObject的第二个构造函数,将d_ptr指向new QWidgetPrivate所指向的堆内存。

http://blog.csdn.net/rabinsong/article/details/9474859

以上是关于d指针在Qt上的应用及实现(d指针能实现二进制兼容)的主要内容,如果未能解决你的问题,请参考以下文章

qt creator源码全方面分析(4-1)

Qt之美:d指针/p指针详解(二进制兼容,不能改变它们的对象布局)

Qt之美:d指针/p指针详解(解释二进制兼容,以及没有D指针就会崩溃的例子。有了D指针,所使用的对象大小永远不会改变,它就是该指针的大小。这个指针就被称作D指针)good

d指针中的“d”代表啥?

Qt之美:D指针/私有实现

Qt中的Q_D宏和d指针