Qt之美（一）：d指针/p指针详解

Translated  by  mznewfacer   2011.11.16

首先，看了Xizhi Zhu 的这篇Qt之美（一）：D指针/私有实现，对于很多批评不美的同路人，暂且不去评论，只是想支持一下Xizhi Zhu，在引用一下Jerry Sun的话，“C++需要宏定义就像需要设计模式一样。也许你不知道，宏是图灵完全（turing complete）的，至少LISP下是这样，C/C++需要宏，几乎所有重要的C/C++库都需要和依赖宏。这些都超过咱们的想象，宏能带给我们所谓语法糖(Syntax sugar)的方便。如果你不理解，并且不能熟练使用宏，内联函数和通用模板，那么你还和熟练的C++程序员有一定距离。”
        这里不去评论Jerry Sun的理解，有关宏是否图灵完全，对实际编程也没有啥意义的。至少我们看到Qt用了不少。闲话少叙，书归正文。

1.二进制兼容性

这里，先简单解释一下什么破坏了代码的二进制兼容性（至于二进制兼容性是什么，相信Xizhi Zhu的文章和KDE上的这篇文章，已经说的很清楚了，有时间的话再翻译一下）。换句话说，在对程序做了什么样的改变需要我们重新编译呢？看下面的例子：

[cpp] view plain copy

  1. class Widget {
  2. ...
  3. private:
  4. Rect m_geometry;
  5. };
  6. class  Label :public Widget {
  7. ...
  8. String text()const{return m_text; }
  9. private:
  10. String m_text;
  11. };

在这里工程名为CuteApp，Widget类包含一个私有成员变量m_geometry。我们编译Widget类，并且将其发布为WidgetLib 1.0。对于WidgetLib 1.1版本，我们希望加入对样式表的支持。在Widget类中我们相应的加入了新的数据成员。

[cpp] view plain copy

  1. class  Widget {
  2. ...
  3. private:
  4. Rect m_geometry;
  5. String m_stylesheet; // NEW in WidgetLib 1.1
  6. };
  7. class  Label :public Widget {
  8. public:
  9. ...
  10. String text()const{return m_text; }
  11. private:
  12. String m_text;
  13. } ;

经过上述改变后，我们发现工程CuteApp可以通过编译，但是当运行调用WidgetLib1.0时，程序崩溃。
为什么会运行出错呢？
是因为我们在加入成员变量m_stylesheet后，改变了Widget和Label类的对象布局。这是由于当编译器在编译程序时，它是用所谓的offsets来标记在类中的成员变量。我们将对象布局简化，其在内存中大致形象如下所示：

在WidegetLib 1.0中，Label类的成员变量m_text还在<offset 1>。被编译器编译后，将Label::text()方法解释为获取Label对象的<offset 1>。而在WidegetLib 1.1中，由于添加新的数据成员，导致m_text的标记位变为<offset 2>。由于工程没有重新编译，c++编译器还会将在编译和运行时的对象大小认为一致。也就是说，在编译时，编译器为Label对象按照其大小在内存上分配了空间。而在运行时，由于Widget中m_stylesheet的加入导致Label的构造函数重写了已经存在的内存空间，导致了程序崩溃。

   所以只要版本已发布，除非重新编译工程，否则就不能更改类的结构和大小。那么，为了能够为原有类方便的引入新的功能，这就是Qt引入D指针的目的。

2.D指针

  保持一个库中的所有公有类的大小恒定的问题可以通过单独的私有指针给予解决。这个指针指向一个包含所有数据的私有数据结构体。这个结构体的大小可以随意改变而不会产生副作用，应用程序只使用相关的公有类，所使用的对象大小永远不会改变，它就是该指针的大小。这个指针就被称作D指针。

[cpp] view plain copy

  1. /* widget.h */
  2. // 私有数据结构体声明。 其定义会在 widget.cpp 或是
  3. //  widget_p.h，总之不能在此头文件
  4. class   WidgetPrivate;
  5. class   Widget {
  6. ...
  7. Rect geometry()const;
  8. ...
  9. private:
  10. // d指针永远不能在此头文件中被引用
  11. //  由于WidgetPrivate没有在此头文件中被定义,
  12. // 任何访问都会导致编译错误。
  13. WidgetPrivate *d_ptr;
  14. };
  15. /* widget_p.h */(_p 指示private)
  16. struct WidgetPrivate {
  17. Rect geometry;
  18. String stylesheet;
  19. };
  20. /* widget.cpp */
  21. #include "widget_p.h"
  22. Widget::Widget()
  23. : d_ptr(new WidgetPrivate)// 初始化 private 数据 {
  24. }
  25. Rect Widget::geoemtry()const{
  26. // 本类的d指针只能被在自己的库内被访问
  27. return d_ptr->geometry;
  28. }
  29. /* label.h */
  30. class   LabelPrivate;
  31. class  Label :publicWidget {
  32. ...
  33. String text();
  34. private:
  35. // 自己类对应自己的d指针
  36. LabelPrivate *d_ptr;
  37. };
  38. /* label.cpp */
  39. // 这里将私有结构体在cpp中定义
  40. struct LabelPrivate {
  41. String text;
  42. };
  43. Label::Label()
  44. : d_ptr(new LabelPrivate) {
  45. }
  46. String Label::text() {
  47. return d_ptr->text;
  48. }

有了上面的结构，CuteApp就不会与d指针直接打交道。因为d指针只能在WidgetLib中被访问，在每一次对Widget修改之后都要对其重新编译，私有的结构体可以随意更改，而不需要重新编译整个工程项目。

3.D指针的其他好处
除了以上优点，d指针还有如下优势：
1.隐藏实现细节——我们可以不提供widget.cpp文件而只提供WidgetLib和相应的头文件和二进制文件。
2.头文件中没有任何实现细节，可以作为API使用。
3.由于原本在头文件的实现部分转移到了源文件，所以编译速度有所提高。
其实以上的点都很细微，自己跟过源代码的人都会了解，qt是隐藏了d指针的管理和核心源的实现。像是在_p.h中部分函数的声明，qt也宣布在以后版本中将会删除。（ This file is not part of the Qt API.  It exists purely as an implementation detail.  This header file may change from version to version without notice, or even be removed.）

4.Q指针
到目前为止，我们已经熟悉了指向私有结构体的d指针。而在实际中，往往它将包含私有方法（helper函数）。例如，LabelPrivate可能会有getLinkTargetFromPoint（）(helper函数）以当按下鼠标时去找到相应的链接目标。在很多场合，这些helper函数需要访问公有类，例如访问一些属于Label类或是其基类Widget的函数。
比方说，一个帮助函数setTextAndUpdateWidget()可能会调用Widget::update()函数去重新绘制Widget。因此，我们同样需要WidgetPrivate存储一个指向公有类的q指针。

[cpp] view plain copy

  1. /* widget.h */
  2. class  WidgetPrivate;
  3. class  Widget {
  4. ...
  5. Rect geometry()const;
  6. ...
  7. private:
  8. WidgetPrivate *d_ptr;
  9. };
  10. /* widget_p.h */
  11. struct     WidgetPrivate {
  12. // 初始化q指针
  13. WidgetPrivate(Widget *q) : q_ptr(q) { }
  14. Widget *q_ptr;// q-ptr指向基类API
  15. Rect geometry;
  16. String stylesheet;
  17. };
  18. /* widget.cpp */
  19. #include "widget_p.h"
  20. // 初始化 private 数据，将this指针作为参数传递以初始化 q-ptr指针
  21. Widget::Widget()
  22. : d_ptr(new WidgetPrivate(this)) {
  23. }
  24. Rect Widget::geoemtry()const{
  25. return d_ptr->geometry;
  26. }
  27. /* label.h */
  28. class   LabelPrivate;
  29. class  Label :publicWidget {
  30. ...
  31. String text()const;
  32. private:
  33. LabelPrivate *d_ptr;};
  34. /* label.cpp */
  35. struct LabelPrivate {
  36. LabelPrivate(Label *q) : q_ptr(q) { }
  37. Label *q_ptr; //Label中的q指针
  38. String text;
  39. };
  40. Label::Label()
  41. : d_ptr(new LabelPrivate(this)) {
  42. }
  43. String Label::text() {
  44. return d_ptr->text;
  45. }

5.进一步优化

在以上代码中，每产生一个Label对象，就会为相应的LabelPrivate和WidgetPrivate分配空间。如果我们用这种方式使用Qt的类，那么当遇到像QListWidget(此类在继承结构上有6层深度），就会为相应的Private结构体分配6次空间。
在下面示例代码中，将会看到，我们用私有类结构去实例化相应构造类，并在其继承体系上全部通过d指针来初始化列表。

[cpp] view plain copy

  1. /* widget.h */
  2. class  Widget {
  3. public:
  4. Widget();
  5. ...
  6. protected:
  7. // 只有子类会访问以下构造函数
  8. Widget(WidgetPrivate &d);// 允许子类通过它们自己的私有结构体来初始化
  9. WidgetPrivate *d_ptr;
  10. };
  11. /* widget_p.h */
  12. struct  WidgetPrivate {
  13. WidgetPrivate(Widget *q) : q_ptr(q) { }
  14. Widget *q_ptr;
  15. Rect geometry;
  16. String stylesheet;
  17. };
  18. /* widget.cpp */
  19. Widget::Widget()
  20. : d_ptr(new WidgetPrivate(this)) {
  21. }
  22. Widget::Widget(WidgetPrivate &d)
  23. : d_ptr(&d) {
  24. }
  25. /* label.h */
  26. class Label :public Widget {
  27. public:
  28. Label();
  29. ...
  30. protected:
  31. Label(LabelPrivate &d);// 允许Label的子类通过它们自己的私有结构体来初始化
  32. //  注意Label在这已经不需要d_ptr指针，它用了其基类的d_ptr
  33. };
  34. /* label.cpp */
  35. #include "widget_p.h"
  36. class LabelPrivate :public WidgetPrivate {
  37. public:
  38. String text;
  39. };
  40. Label::Label()
  41. : Widget(*new LabelPrivate)//用其自身的私有结构体来初始化d指针
  42. }
  43. Label::Label(LabelPrivate &d)
  44. : Widget(d) {
  45. }

这时候，我觉得我体会到了不一样的感觉，有点意思了吧，说不美的，可以想个更好的解决方案么？
当我们建立一个Label对象时，它就会建立相应的LabelPrivate结构体（其是WidgetPrivate的子类）。它将其d指针传递给Widget的保护构造函数。这时，建立一个Label对象仅需为其私有结构体申请一次内存。Label同样也有一个保护构造函数可以被继承Label的子类使用，以提供自己对应的私有结构体。

6.将q-ptr和d-ptr转换成正确类型

前面一步优化导致的副作用是q-ptr和d-ptr分别是Widget和WidgetPrivate类型。这就意味着下面的操作是不起作用的。

[cpp] view plain copy

  1. void Label::setText(constString &text) {
  2. // 不起作用的，因为d_ptr是WidgetPrivate类型的，即使其指向LabelPrivate对象
  3. d_ptr->text = text;
  4. }

所以为了在子类能够使用d指针，我们用static_cast来做强制转换。

[cpp] view plain copy

  1. void Label::setText(const String &text) {
  2. LabelPrivate *d =static_cast<LabelPrivate *>(d_ptr);// cast to our private type
  3. d->text = text;
  4. }

为了不让所有地方都飘满static_cast，我们才引入宏定义。

[cpp] view plain copy

  1. // global.h (macros)
  2. #define DPTR(Class) Class##Private *d = static_cast<Class##Private *>(d_ptr)
  3. #define QPTR(Class) Class *q = static_cast<Class *>(q_ptr)
  4. // label.cpp
  5. void Label::setText(constString &text) {
  6. DPTR(Label);
  7. d->text = text;
  8. }
  9. void LabelPrivate::someHelperFunction() {
  10. QPTR(label);
  11. q->selectAll();// 我们现在可以通过此函数来访问所有Label类中的方法
  12. }

至于，Qt中的D指针和Q指针的具体形式以及相应的宏定义，这里就不再重复，Xizhi Zhu的文章中已经有写，完整的d指针和q指针的程序实例程序如下：（结合信号和槽机制）

 //d_ptr.h

[cpp] view plain copy

  1. #ifndef D_PTR_H
  2. #define D_PTR_H
  3. #include <QObject>
  4. template <typename T> static inline T *GetPtrHelper(T *ptr) { return ptr; }
  5. #define DECLARE_PRIVATE(Class) \
  6. inline Class##Private* d_func() { return reinterpret_cast<Class##Private*>(GetPtrHelper(d_ptr)); } \
  7. inline const Class##Private* d_func() const { return reinterpret_cast<const Class##Private*>(GetPtrHelper(d_ptr)); }\
  8. friend class Class##Private;
  9. #define DPTR(Class) Class##Private * const d  = d_func()
  10. class MyClassPrivate;
  11. class MyClass : public QObject {
  12. Q_OBJECT
  13. public:
  14. explicit MyClass(QObject *parent = 0);
  15. virtual ~MyClass();
  16. void testFunc();
  17. protected:
  18. MyClass(MyClassPrivate &d);
  19. private:
  20. MyClassPrivate * const d_ptr;
  21. DECLARE_PRIVATE(MyClass);
  22. MyClass(const MyClass&);
  23. MyClass& operator= (const MyClass&);
  24. };
  25. #endif

//d_ptr.cpp

[cpp] view plain copy

  1. #include "d_ptr.h"
  2. #include "q_ptr.h"
  3. MyClass::MyClass(QObject *parent) : QObject(parent),
  4. d_ptr(new MyClassPrivate(this)) {}
  5. MyClass::~MyClass() {
  6. DPTR(MyClass);
  7. delete d;
  8. }
  9. void MyClass::testFunc() {
  10. DPTR(MyClass);
  11. d->fool();
  12. }

//q_ptr.h

[cpp] view plain copy

  1. #ifndef Q_PTR_H
  2. #define Q_PTR_H
  3. #include <QObject>
  4. #include "d_ptr.h"
  5. #define DECLARE_PUBLIC(Class) \
  6. inline Class* q_func() { return static_cast<Class *>(q_ptr); } \
  7. inline const Class* q_func() const { return static_cast<const Class *>(q_ptr); } \
  8. friend class Class;
  9. #define QPTR(Class) Class * const q = q_func()
  10. class MyClassPrivate : public QObject
  11. {
  12. Q_OBJECT
  13. public:
  14. MyClassPrivate(MyClass *q, QObject *parent = 0);
  15. virtual ~MyClassPrivate() {}
  16. signals:
  17. void testSgnl();
  18. private slots:
  19. void testSlt();
  20. public:
  21. void fool();
  22. private:
  23. MyClass * const q_ptr;
  24. DECLARE_PUBLIC(MyClass);
  25. };
  26. #endif

//q_ptr.cpp

[cpp] view plain copy

  1. #include <stdio.h>
  2. #include "q_ptr.h"
  3. MyClassPrivate::MyClassPrivate(MyClass *q, QObject *parent) : QObject(parent), q_ptr(q) {
  4. connect(this, SIGNAL(testSgnl()), this, SLOT(testSlt()));
  5. }
  6. void MyClassPrivate::fool() {
  7. emit testSgnl();
  8. }
  9. void MyClassPrivate::testSlt() {
  10. printf("This is a pimpl pattern sample implemented in qt‘s \"d_ptr, q_ptr\" way\n");
  11. }

//main.cpp

[cpp] view plain copy

    1. #include "q_ptr.h"
    2. int main(/*int argc, char *argv[]*/) {
    3. MyClass * d_ptr = new MyClass;
    4. d_ptr->testFunc();
    5. delete d_ptr;
    6. while(1);
    7. return 0;
    8. }

-------------------------------------------------------------------

写的真好。我一开始也是认为是数据和实现分开，然后看了有二进制兼容部分。博主还写到了内存分配的部分，确实是挺好的，我现在写程序从没有考虑到内存的问题，现在实力还没达到要考虑内存的时候。

楼主分析的很到位，比Xizhi Zhu剖析得清楚。
其实，D指针这种东西，在看C++ GUI with QT4 programming的时候我就看到了，就在第五章那个plot的例子里；我自己提供给别人的模块里也用了这种privateData的方式来保存私有的数据。以前的主要认识就是为了隐藏自己实现细节，还有就是可以使用一个模板类来继承privateData类，用来处理不同的数据类型。没想到Qt里还有二进制兼容的考虑。
关于宏，我觉得对于Qt这样的跨平台语言来说，根本就无法避免。只要能让程序变得简洁，用宏也挺好的，没必要自己给自己设置樊笼，就如同有的人用goto语句也可以让程序清晰明了。
楼主有空写写关于Qt里集合类，如QVector、QList之类的实现吧。

http://blog.csdn.net/mznewfacer/article/details/6976293

时间： 2024-10-29 22:33:48

Qt之美（一）：d指针/p指针详解的相关文章

Qt Quick 之 QML 与 C++ 混合编程详解

Qt Quick 技术的引入,使得你能够快速构建 UI ,具有动画.各种绚丽效果的 UI 都不在话下.但它不是万能的,也有很多局限性,原来 Qt 的一些技术,比如低阶的网络编程如 QTcpSocket ,多线程,又如 XML 文档处理类库 QXmlStreamReader / QXmlStreamWriter 等等,在 QML 中要么不可用,要么用起来不方便,所以呢,很多时候我们是会基于这样的原则来混合使用 QML 和 C++: QML 构建界面, C++ 实现非界面的业务逻辑和复杂运算. 请给

传美云商系统软件开发代码详解

2012年,中国网民互联网接入的方式呈现出全新格局.据中国互联网139信2673息7371中心的数据统计,在2012年上半年,通过手机接入互联网的网民数量达到3.88亿,相比之下台式电脑为3.80亿,手机成为我国网民的第一大上网终端.2017年,移动互联网也迎来井喷式的发展,各产业链相互渗透,行业竞争格局出现明显变化,移动互联网产业链初具雏形,盈利渐现曙光. 传美云商系统为什么受到那么多创业者的欢迎,传美云商,是在互联网上做生意的不二之选.传美云商系统专为众多做生鲜产品的创业者而生.传美云商微商

C++ 指针函数的详解

1.函数指针 (1)一般来说函数通常包括一系列指令,通过编译后,在内存中占据了一块存储空间. 它有一个起始地址,这个起始(入口)地址就称为函数的指针. (2)主函数在调用子函数时,就是让程序转移到函数的入口地址开始执行. (3)我们可以定义一个指针变量用来指向函数,然后通过使用该指针变量调用此函数. 指向函数的指针:就是能够存放某个函数入口地址的指针变量. 总结了一下,函数指针有两个用途:一个是调用函数,另一个是做函数的参数 函数指针定义的一般形式: 数据类型     (*指针变量名)(参数表)

二级指针的使用详解

欢迎转载,转载请注明原文地址:http://blog.csdn.net/majianfei1023/article/details/46629065 一.概念 在如下的A指向B.B指向C的指向关系中: 首先 C是"一段内容",比如你用malloc或者new分配了一块内存,然后塞进去"一段内容",那就是C了.C的起始地址是0x00000008. B是一个指针变量,其中存放着C的地址,但是B也要占空间的啊,所以B也有地址,B的起始地址是0x00000004,但是B内存中

C函数类型和函数指针使用方法详解

二.通常的函数调用 一个通常的函数调用的例子: /* 自行包含头文件 */ void MyFun(int x); /* 此处的声明也可写成:void MyFun(int) */ int main(int argc, char* argv[]) {    MyFun(10); /* 这里是调用MyFun(10) 函数 */    return(0); } void MyFun(int x) /* 这里定义一个MyFun函数 */ {    printf("%d\n",x); } 这个My

C++中this指针的用法详解

转自 http://blog.chinaunix.net/uid-21411227-id-1826942.html 1. this指针的用处: 一个对象的this指针并不是对象本身的一部分,不会影响sizeof(对象)的结果.this作用域是在类内部,当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数.也就是说,即使你没有写上this指针,编译器在编译的时候也是加上this的,它作为非静态成员函数的隐含形参,对各成员的访问均通过this进行.

C++中this指针的用法详解（转）

原文地址:http://blog.chinaunix.net/uid-21411227-id-1826942.html 1. this指针的用处: 一个对象的this指针并不是对象本身的一部分,不会影响sizeof(对象)的结果.this作用域是在类内部,当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数.也就是说,即使你没有写上this指针,编译器在编译的时候也是加上this的,它作为非静态成员函数的隐含形参,对各成员的访问均通过this进

c++的引用与指针的关系详解

[TOC]#1.引用的概念及用法概念:引用就是某一变量(目标)的一个别名,对引用的操作与对变量直接操作完全一样.     温馨提示:引用不是定义一个新的变量定义的格式为:    类型 &引用变量名 = 已定义过的变量名;用法:举个例子: int a = 5; int& b = a; 这就是引用,b引用a,b是a的别名. #2.引用做参数我们在C语言中经常用指针做参数: Func(int *a) ; int main() { int arr[1000]; Func(arr); } 像这种情况

Qt QTreeWidget节点的添加+双击响应+删除详解（转）

QTreeWidget是实现树形结构的类,在很多软件中都可以看到类似树形结构的界面. 我做的一个示例如下图,用来处理图像,最顶层节点是图像的路径名,子节点是图像的各个波段,双击各个波段会显示图像各波段的灰度图像,同时还有删除指定节点(父节点和子节点同时删除)的功能.效果如下所示 要完成这样的功能需要注意一下几点: ①.在内存中保存各个节点,当然要在堆上分配内存,删除节点时,除了去除QtreeWidget控件上的节点外,还要讲存储在内存中的节点也要删除,否则会出现内存泄露的问题. ②.节点双击的事

Qt项目管理文件（.pro）及其作用详解

http://c.biancheng.net/view/1819.html 在 Qt Creator 中新建一个 Widget Application 项目 samp2_1,在选择窗口基类的页面选择 QWidget 作为窗体基类,并选中“Generate form”复选框.创建后的项目文件目录树如图 1 所示. 图 1 项目文件的目录树 这个项目包含以下一些文件: 项目管理文件 samp2_1.pro,存储项目设置的文件. 主程序入口文件 main.cpp,实现 main()函数的程序文件. 窗