什么是D指针
如果你已经看过到Qt源码，你会发现它经常使用Q_D和Q_Q`宏。本文介绍了这些宏的用途。
该Q_D和Q_Q宏是一个设计模式的一部分被称为d-指针（也称为*不透明的指针*，其中一个库的实现细节可以从它的用户，并转移到执行被隐藏），另外也保护了库的二进制兼容性。
在设计类似Qt的库时，希望即使在将Qt库升级/替换为另一个版本之后，也可以继续运行动态链接到Qt的应用程序而无需重新编译。例如，如果您的应用程序CuteApp基于Qt 4.5，则应该能够将Qt库（在该应用程序附带的Windows上，在Linux上通常自动来自程序包管理器！）从版本4.5升级到Qt 4.6，而您的CuteApp使用Qt 4.5构建的窗口仍应能够运行。
什么破坏了二进制兼容性？
那么，库中的更改何时需要重新编译应用程序？让我们举一个简单的例子：
class Widget
{
// ...
private：
Rect m_geometry;
};
class Label：public Widget
{
public：
// ...
string text（）const
{
return m_text;
}
private：
string m_text;
};
在这里，我们有一个小部件，其中包含几何作为成员变量。我们编译Widget并将其作为WidgetLib 1.0交付。
对于WidgetLib 1.1，有人想出了一个聪明的主意来添加对样式表的支持。不费吹灰之力，我们只需添加新方法并添加新的数据成员。
class Widget
{
// ...
private：
Rect m_geometry;
string m_stylesheet; // WidgetLib 1.1中的新增功能
};
class Label：public Widget
{
public：
// ...
string text（）const
{
return m_text;
}
private：
string m_text;
};
我们提供了带有上述更改的WidgetLib 1.1，只是发现在WidgetLib 1.0中编译并运行良好的CuteApp崩溃崩溃了！
为什么会崩溃？
原因是通过添加新的数据成员，我们最终更改了Widget和Label对象的大小。为什么这么重要？当您的C ++编译器生成代码时，它使用偏移量来访问对象内的数据(一般项目，在头文件有过改动，都需要应用程序重新编译，免除一些奇怪的问题出现)。
这是上述POD对象在内存中的外观的简化版本。
| WidgetLib 1.0中的标签对象布局 | WidgetLib 1.1中的标签对象布局 |
|---|---|
| m_geometry <offset 0> | m_geometry <offset 0> |
| — | m_stylesheet <offset 1> |
| m_text | — |
| — | m_text <offset 2> |
在WidgetLib 1.0中，Label的文本成员位于（逻辑）偏移量1。由应用程序中的编译器为Label :: text（）方法生成的代码转换为访问应用程序中Label对象的偏移量1。在WidgetLib 1.1中，Label的文本成员已移至（逻辑）偏移量2！由于尚未重新编译应用程序，因此它继续认为文本在偏移量1处，并最终访问了 样式表变量！
我可以肯定地说，有些人想知道为什么Label :: text（）的偏移量计算代码最终出现在CuteApp二进制文件而不是WidgetLib二进制文件中。答案是在头文件中定义了Label :: text（）的代码，编译器最终对其进行了*内联*。
那么，如果没有内联Label :: text（），情况会改变吗？说，Label :: text（）已移至源文件？好吧，不。C ++编译器依赖于在编译时和运行时相同的对象大小。例如，堆栈缠绕/展开-如果在堆栈上创建了Label对象，则编译器将生成代码，以根据编译时Label的大小在堆栈上分配空间。由于WidgetLib 1.1中Label的大小在运行时是不同的，因此Label的构造函数将覆盖现有的堆栈数据并最终破坏堆栈。
切勿更改导出的C ++类的大小
总而言之，一旦发布了库，就永远不要更改导出（即用户可见）的C ++类的大小或布局（不要移动数据）。C ++编译器会生成代码，假设在编译应用程序后，类中数据的大小或顺序不会更改。
那么，如何才能不改变对象的大小而又添加新的功能呢？
d指针
诀窍是通过仅存储单个指针来使库的所有公共类的大小保持恒定。该指针指向包含所有数据的私有/内部数据结构。内部结构的大小可以缩小或增长，而对应用程序没有任何副作用，因为仅在库代码中访问指针，并且从应用程序的角度来看，对象的大小从不改变-始终是对象的大小。指针。该指针称为d指针。
下面的代码概述了这种模式的实质（本文中的所有代码都没有析构函数，当然您应该在真实代码中添加它们）。
widget.h
/*由于d_ptr是一个指针，并且从未在头文件中引用
*（这会导致编译错误），因此不必包含WidgetPrivate，
*而应进行前向声明。
*该类的定义可以写在widget.cpp或
*单独的文件中，例如widget_p.h */
class WidgetPrivate ;
class Widget
{
// ...
Rect geometry（）const;
// ...
private：
WidgetPrivate * d_ptr;
};
widget_p.h，它是小部件类的私有头文件
/ * widget_p.h（_p表示私有）* /
struct WidgetPrivate
{
Rect geometry;
String stylesheet;
};
widget.cpp
//通过此#include，我们可以访问WidgetPrivate。
#include "widget_p.h"
Widget::Widget（）：d_ptr（new WidgetPrivate）
{
//创建私有数据
}
Rect Widget :: geometry（）const
{
//仅在库代码
return d_ptr->geometry;
}
接下来，有一个基于Widget的子类的示例。
Label.h
class Label：public Widget
{
// ...
string text（）;
private：
//每个类维护自己的d指针
LabelPrivate * d_ptr;
};
Label.cpp
// Unlike WidgetPrivate, the author decided LabelPrivate
// to be defined in the source file itself
struct LabelPrivate
{
String text;
};
Label::Label() : d_ptr(new LabelPrivate)
{
}
String Label::text()
{
return d_ptr->text;
}
通过上述结构，CuteApp永远不会直接访问d指针。并且由于仅在WidgetLib中访问了d指针，并且每个版本都对WidgetLib进行了重新编译，因此Private类可以自由更改，而不会影响CuteApp。
d指针的其他好处
二进制兼容性并不是全部。d指针还有其他好处：
- 隐藏实现细节-我们可以将WidgetLib与头文件和二进制文件一起提供。.cpp文件可以是封闭源。
- 头文件中没有实现细节，可以用作API参考。
- 由于实现所需的头文件已从头文件移至实现（源）文件，因此编译速度要快得多。
确实，上述好处显得微不足道。在Qt中使用d指针的真正原因是为了二进制兼容性以及Qt从封闭源开始的事实。
q指针
到目前为止，我们仅将d指针视为C样式的数据结构。实际上，它包含私有方法（辅助函数）。例如，LabelPrivate可能具有getLinkTargetFromPoint（）帮助函数，该函数在单击鼠标时才能找到链接目标。在许多情况下，这些帮助程序方法需要访问公共类，即Label或其基类Widget中的某些功能。例如，一个辅助方法setTextAndUpdateWidget（）可能要调用Widget :: update（），它是一个公共方法，用于计划重新绘制Widget。因此，WidgetPrivate存储一个指向公共类的指针，称为q指针。修改上面的q指针代码，我们得到：
widget.h
class WidgetPrivate;
class Widget
{
// ...
Rect geometry() const;
// ...
private:
WidgetPrivate *d_ptr;
};
widget_p.h
struct WidgetPrivate
{
// Constructor that initializes the q-ptr
WidgetPrivate(Widget *q) : q_ptr(q) { }
Widget *q_ptr; // q-ptr points to the API class
Rect geometry;
String stylesheet;
};
widget.cpp
#include "widget_p.h"
// Create private data.
// Pass the 'this' pointer to initialize the q-ptr
Widget::Widget() : d_ptr(new WidgetPrivate(this))
{
}
Rect Widget::geometry() const
{
// the d-ptr is only accessed in the library code
return d_ptr->geometry;
}
接下来，另一个基于Widget的类。
label.h
class Label : public Widget
{
// ...
String text() const;
private:
LabelPrivate *d_ptr;
};
label.cpp
// Unlike WidgetPrivate, the author decided LabelPrivate
// to be defined in the source file itself
struct LabelPrivate
{
LabelPrivate(Label *q) : q_ptr(q) { }
Label *q_ptr;
String text;
};
Label::Label() : d_ptr(new LabelPrivate(this))
{
}
String Label::text()
{
return d_ptr->text;
}
继承d指针进行优化
在上面的代码中，创建单个Label将导致为LabelPrivate和WidgetPrivate分配内存。如果我们将这种策略用于Qt，则对于类似QListWidget的类，情况将变得更加糟糕-它在类继承层次结构中位于6级，这将导致最多6个内存分配(每一个继承都会分配一个d指针的内存分配)！
这可以通过为我们的私有类建立继承层次结构，并使实例化的类一直沿d指针传递来解决。
请注意，在继承d指针时，私有类的声明必须在单独的文件中，例如widget_p.h。不再可以在widget.cpp文件中声明它。
widget.h
class Widget
{
public:
Widget();
// ...
protected:
// only subclasses may access the below
// allow subclasses to initialize with their own concrete Private
Widget(WidgetPrivate &d);
WidgetPrivate *d_ptr;
};
widget_p.h
struct WidgetPrivate
{
WidgetPrivate(Widget *q) : q_ptr(q) { } // constructor that initializes the q-ptr
Widget *q_ptr; // q-ptr that points to the API class
Rect geometry;
String stylesheet;
};
widget.cpp
Widget::Widget() : d_ptr(new WidgetPrivate(this))
{
}
Widget::Widget(WidgetPrivate &d) : d_ptr(&d)
{
}
label.h
class Label : public Widget
{
public:
Label();
// ...
protected:
Label(LabelPrivate &d); // allow Label subclasses to pass on their Private
// notice how Label does not have a d_ptr! It just uses Widget's d_ptr.
};
label.cpp
#include "widget_p.h"
class LabelPrivate : public WidgetPrivate
{
public:
String text;
};
Label::Label()
: Widget(*new LabelPrivate) // initialize the d-pointer with our own Private
{
}
Label::Label(LabelPrivate &d) : Widget(d)
{
}
你看到这么使用的优点了吗？现在，当我们创建Label对象时，它将创建LabelPrivate（子类WidgetPrivate）。它将具体的d指针传递给Widget的受保护构造函数！现在，创建Label对象时，只有一个内存分配。Label还具有受保护的构造函数，其子类可以使用其提供自己的私有类。
Qt中的d指针
在Qt中，几乎每个公共类都使用d指针方法。唯一不使用它的情况是，当事先知道该类永远不会添加任何成员变量时。例如，对于QPoint，QRect之类的类，不希望添加任何新成员，因此数据成员直接存储在类本身中，而不是使用d指针。
注意，在Qt中，所有Private对象的基类都是QObjectPrivate。
Q_D和Q_Q
我们在上一步中所做的优化的副作用是q-ptr和d-ptr的类型为Widget和WidgetPrivate。这意味着以下操作无效。
void Label :: setText（const String＆text）
{
//不起作用！因为d_ptr的类型为WidgetPrivate，即使它
//指向LabelPrivate对象
d_ptr-> text = text；
}
因此，当访问子类中的d指针时，我们需要static_cast为适当的类型。
void Label :: setText（const String＆text）
{
LabelPrivate * d = static_cast <LabelPrivate *>（d_ptr）; //转换为私有类型
d-> text = text;
}
如您所见，到处都有static_cast并不是一件很漂亮的事情。相反，在src / corelib / global / qglobal.h中定义了两个宏，这些宏使其很直观：
global.h
#define Q_D(Class) Class##Private * const d = d_func()
#define Q_Q(Class) Class * const q = q_func()
label.cpp
// With Q_D you can use the members of LabelPrivate from Label
void Label::setText(const String &text)
{
Q_D(Label);
d->text = text;
}
// With Q_Q you can use the members of Label from LabelPrivate
void LabelPrivate::someHelperFunction()
{
Q_Q(Label);
q->selectAll();
}
Q_DECLARE_PRIVATE和Q_DECLARE_PUBLIC
Qt类在公共类中具有Q_DECLARE_PRIVATE宏。该宏显示为：
qglobal.h
#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;
可以通过以下方式使用此宏：
qlabel.h
class QLabel
{
private:
Q_DECLARE_PRIVATE(QLabel)
};
这个想法是QLabel提供了一个函数d_func（），该函数允许访问其私有内部类。该方法本身是私有的（因为宏在qlabel.h中的私有部分内）。但是d_func（）可以由QLabel的朋友（C ++朋友）调用。这对于Qt类访问信息非常有用，因为Qt类无法使用公共api访问某些QLabel信息。举一个奇怪的例子，QLabel可能会跟踪用户单击链接的次数。但是，没有公共API可以访问此信息。QStatistics是需要此信息的类。Qt开发人员将添加`````````QStatistics作为QLabel的朋友，然后QStatistics可以执行label-> d_func（）-> linkClickCount`。
该d_func还具有的优点是执行常量正确性：在MyClass的一个const成员函数，你需要一个Q_D（常量MyClass的），因此你只能调用const成员函数中MyClassPrivate。使用裸露的d_ptr，您还可以调用非const函数。
扫一扫
3025
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
