Qt d指针简单实现及解析--威力加强版-CSDN博客

学习d指针，怎能不研究一下q指针呢，说句实话，看完q指针后，你才会发现，它的理解其实比q指针还晦涩。
把代码贴上先：

[cpp]view plaincopy 
    
 /*object.h*/  
 #ifndef _OBJECT_H_  
 #define _OBJECT_H_  
 #include <iostream>  
 #define INVOKE_METHOD_PRIVATE(Class) Class##Private *d_func() {return reinterpret_cast<Class##Private*>(d_ptr);}  
 #define Q_D(Class) Class##Private* d = d_func();  
 #define INVOKE_METHOD_PUBLIC(Class) Class *q_func() {return static_cast<Class*>(q_ptr);}  
 #define Q_Q(Class) Class* q = q_func();  
   
 using namespace std;  
   
 class ObjectPrivate;  
 class Object;  
   
 class ObjectData  
 {  
 public:  
     virtual ~ObjectData() = 0;  
     Object* q_ptr;//公共类的指针  
 };  
   
 class Object  
 {  
     INVOKE_METHOD_PRIVATE(Object)  
 public:  
     Object();  
     ~Object();  
       
     Object(ObjectPrivate &dd);  
   
 protected:  
     ObjectData* d_ptr;//私有类的指针  
     //ObjectPrivate* d_ptr;  
   
 public:  
     int m_nDescription;  
 };  
   
 #endif   

[cpp]view plaincopy 
    
 /*object_p.h*/  
 #ifndef _OBJECT_P_H_  
 #define _OBJECT_P_H_  
 #include "object.h"  
   
 class ObjectPrivate : public ObjectData  
 {  
     INVOKE_METHOD_PUBLIC(Object)  
   
 public:  
     ObjectPrivate();  
     virtual ~ObjectPrivate();  
   
     //Object* q_ptr;  
 };  
   
 #endif   

[cpp]view plaincopy 
    
 /*object.cpp*/  
 #include "object.h"  
 #include "object_p.h"  
   
 ObjectData::~ObjectData()  
 {  
   
 }  
   
 ObjectPrivate::ObjectPrivate()  
 {  
     q_ptr = 0;  
 };  
   
 ObjectPrivate::~ObjectPrivate()  
 {  
   
 };  
   
 Object::Object()  
 :d_ptr(new ObjectPrivate)  
 {  
     d_ptr->q_ptr = this;//初始化公共类指针，如果本类被直接调用（使用）  
     m_nDescription = 5000;//本类的标签  
 }  
   
 Object::Object(ObjectPrivate &dd)  
 :d_ptr(&dd)  
 {  
     d_ptr->q_ptr = this;//初始化公共类指针，子类被调用的同时，本方法被调用  
     m_nDescription = 5000;  
 }  
   
 Object::~Object()  
 {  
   
 }  

[cpp]view plaincopy 
    
 /*widget.h*/  
 #ifndef _WIDGET_H_  
 #define _WIDGET_H_  
 #include "object.h"  
   
 class WidgetPrivate;  
   
 /*enumeration*/  
 enum _state//模拟QWidget的状态  
 {  
     OPEN = 0,  
     CLOSE,  
     UNKNOWN,  
 };  
   
 /*Widget's state data*/  
 class WidgetData  
 {  
 public:  
     _state m_state;  
 };  
   
 class Widget : Object  
 {  
   
     INVOKE_METHOD_PRIVATE(Widget)  
   
 public:  
     Widget();  
     ~Widget();  
   
     /*functions*/  
     void setWidth(int);  
     void setHeight(int);  
   
     int getWidth();  
     int getheight();  
   
     int getSUM(void);  
     long getProduct(void);  
     int getDecrease(void);  
   
     void setState(_state s);  
     _state getState(void);  
   
     WidgetData* data;//本类的状态数据封装类  
   
     void display();//用于测试在WidgetPrivate类中使用q_ptr调用  
   
 public:  
     int m_nDescription;//本类的标签  
 };  
   
 #endif  

[cpp]view plaincopy 
    
 /*widget_p.h*/  
 #ifndef _WIDGET_P_H_  
 #define _WIDGET_P_H_  
 #include "object_p.h"  
 #include "widget.h"  
   
 class WidgetPrivate : public ObjectPrivate  
 {  
     INVOKE_METHOD_PUBLIC(Widget)  
   
 public:  
     WidgetPrivate();  
     ~WidgetPrivate();  
   
     /*members*/  
     int nWidth;  
     int nHeight;  
   
     WidgetData data;  
   
     /*functions*/  
     void init();  
   
     inline int getSUM_p(void)  
     {  
         Q_Q(Widget)  
         if(q == 0)//测试q指针  
         {  
             cout<<"NULL"<<endl;;  
         }  
         std::cout<<"Description :"<<q->m_nDescription<<std::endl;  
         return nWidth+nHeight;  
     }  
   
     inline long getProduct_p(void)  
     {  
         return (long)(nWidth*nHeight);//this will be a problem  
     }  
   
     int getDecrease_p(void);  
   
     void setState_p(_state s);  
     _state getState_p(void);  
 };  
   
 #endif   

[cpp]view plaincopy 
    
 /*widget.cpp*/  
 #include "widget.h"  
 #include "widget_p.h"  
   
 Widget::Widget()  
 :Object(*new WidgetPrivate)  
 {  
     m_nDescription = 100;  
     Q_D(Widget)  
     d->init();  
 }  
   
 Widget::~Widget()  
 {  
     data = 0;  
 }  
   
 WidgetPrivate::WidgetPrivate()  
 {  
   
 }  
   
 WidgetPrivate::~WidgetPrivate()  
 {  
   
 }  
   
 void WidgetPrivate::init()  
 {  
     Q_Q(Widget)  
     q->data = &data;  
     q->display();  
 }  
   
 int WidgetPrivate::getDecrease_p(void)  
 {  
     return nWidth - nHeight;  
 }  
   
 //WidgetPrivate自己设置状态  
 void WidgetPrivate::setState_p(_state s)  
 {  
     data.m_state = s;  
 }  
   
 //WidgetPrivate自己取得状态  
 _state WidgetPrivate::getState_p(void)  
 {  
     return data.m_state;  
 }  
   
 void Widget::setWidth(int n)  
 {  
     Q_D(Widget)  
     d->nWidth = n;  
 }  
   
 void Widget::setHeight(int n)   
 {  
     Q_D(Widget)  
     d->nHeight = n;  
 }  
   
 int Widget::getWidth()  
 {  
     Q_D(Widget)  
     return d->nWidth;  
 }  
   
 int Widget::getheight()  
 {  
     Q_D(Widget)  
     return d->nHeight;  
 }  
   
 int Widget::getSUM(void)  
 {  
     Q_D(Widget)  
     return d->getSUM_p();  
 }  
   
 long Widget::getProduct(void)  
 {  
     Q_D(Widget)  
     return d->getProduct_p();  
 }  
   
 int Widget::getDecrease(void)  
 {  
     Q_D(Widget)  
     return d->getDecrease_p();  
 }  
   
 //Widget自己设置状态  
 void Widget::setState(_state s)  
 {  
     data->m_state = s;  
 }  
   
 //Widget自己取得状态  
 _state Widget::getState(void)  
 {  
     return data->m_state;  
 }  
   
 void Widget::display()  
 {  
     cout<<"Widget::display()"<<endl;  
 }  

[cpp]view plaincopy 
    
 /*main.cpp*/  
 #include "widget.h"  
   
 int main()  
 {  
     Widget w;  
     w.setWidth(6);  
     w.setHeight(7);  
     std::cout<<"width : "<<w.getWidth()<<std::endl;  
     std::cout<<"height : "<<w.getheight()<<std::endl;  
     cout<<"getSUM :"<<w.getSUM()<<std::endl;  
     _state s = OPEN;      
     w.setState(s);  
     cout<<"state : "<<static_cast<int>(w.getState())<<endl;  
     system("pause");  
     return 0;  
 }  

代码比较多，不过都是在上篇文章基础上添加的，可以先看下简单的，再来看这篇文章。

主要修改之处体现在添加了宏INVOKE_METHOD_PUBLIC和Q_Q,后者调用前者提供的私有函数返回一个临时的指向公共类的指针，例如Qt的QWidget类。同时，照着Qt，添加了一个WidgetData类，它也是放一些数据的，我不太理解这个类的具体作用，暂且把它理解为盛放关于Widget状态的数据的类，它在Widget和WidgetPrivate中都有被引用，且同时指向一个对象，所以修改它的数据是同步的。

代码其实也不多，是有规律的，恐怕您看完之后会有一些疑问，在此，我把我的疑问与解答放置于此，看看您是否也是这么认为的：

Object,ObjectPrivate,ObjectData三者到底是什么关系？
INVOKE_METHOD_PUBLIC宏展开后的q_func()函数中为什么是static_cast而不是像d_func()中的reinterpret_cast?
为什么q_ptr的初始化是用Objectd的this指针？而不是某个具体的类

我的理解：

对于问题一，Object其实是它的抽象基类和它自己合二为一了，它的抽象基类对应ObjectData,自己对应ObjectPrivate。在程序中打代码注释的地方，您可以看一下，把ObjectData去掉，把q_ptr移动到ObjectPrivate中，把d_ptr类型改为ObjectPrivate*.不当能成功编译，还能正确执行。不过，如果用汉语去仔细推敲的话，数据指针d_ptr怎么能是某个具体类的类型呢，失去了泛型概念。

对于问题二，static_cast的作用之一是在父子类之间进行转换，虽然从父类型指针转换到子类型指针不安全，但Qt这样做了，我理解不能

对于问题三，我感觉这才是q_ptr难于理解的关键原因，我上网查了很多资料，无一例外，所示例子中q_ptr的初始化全都是用具体的公共类的this去赋值，这很好理解，这不就是多态的概念吗：用父类指针指向一个已经初始化好的子类指针，需要的时候static_cast转换回子类类型，我感觉不出有什么问题，非常完美。可是，Qt不是这样做的，它对于q_ptr,全都是用QObject的this指针去初始化，这不会有问题吗？您可以自己写个程序测试一下，把初始化好的父类指针static_cast到子类指针，然后再用转换后的指针调用函数。你会发现，如果是普通函数被调用，指针是什么类型，就掉那个类型自己的函数，或者继承父类的函数，如果是虚函数被调用，指针是用什么类初始化的，调用的就是那个类的函数，现在您对比一下我的程序，然后再去Qt源码中查找q->函数的字样，会发现，这些函数（猜想）全是普通函数，，，剩下的，，，你懂了。。。。

完毕，感谢观赏。