D-pointer的应用

看dtk源码的时候对于其组织结构看得不是很明白，直到看了deepin官方的文档,才知道用到了Qt里常用的d-pointer技术。可能这篇文章没说很明白，这里写一下自己的一些理解。

d-pointer主要是为了解决这些问题：

消除为类加入新的成员导致的偏移量改变，不再会使使用动态库的程序出错而不得不重新编译
隐藏实现细节，只在头文件里展示公有的api。头文件可以直接当作文档。

简单来说d-pointer的原理就是为类设计一个私有类，通常情况下储存类的所有成员，以及一些私有的辅助函数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


class Foo{
    public:
        explicit Foo(int,const char*);
        int getNum() const;
        const char* getString() const;
    private:
        int _num;
        char* _string;
};

class Bar: public Foo{
    public:
        explicit Bar(int,const char*,double);
        double getFloat() const;
    private:
        double _f;
};

把源文件编译成动态库，现在我们写一个主函数创建Bar实例，调用getFloat，编译运行，没什么问题。

如果我们在foo里添加一个bool类型的成员，重新编译动态库之后，原来的程序将不再适用。原因是_f的偏移量由于基类增加的新成员而增加了一个字节，而导致在调用函数时访问了错误的内存。很显然在编译之后，函数调用和成员的访问都是通过动态库中的偏移量来实现的。

使用dpointer很简单，将上述的类成员全部剥离为私有类，这样在外部类中只有一个指针的大小，此大小也是固定不变的。当调用函数或访问成员时，都是在库内部进行，和编译好的二进制文件无关。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class FooPrivate;

class Foo{
    public:
        explicit Foo(int,const char*);
        int getNum() const;
        const char* getString() const;
    private:
        FooPrivate* d_ptr;
};

class BarPrivate;

class Bar: public Foo{
    public:
        explicit Bar(int,const char*,double);
        double getFloat() const;
    private:
        BarPrivate* d_ptr
};

因为是前置类，在头文件里不能有任何成员函数的定义。在实现文件中定义私有类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include "Foo.h"
struct FooPrivate{
    int _num;
    char* _string;
};

struct BarPrivate{
    double _f;
};

int Foo::getNum(){
    return d_ptr->_num;
}

//省略其他

面向对象编程中继承是很常见的情况，在这样的设计中，每一次继承都要增加一个私有类，从而在实例化派生类时需要多次分配内存，这不是最佳的办法。

Qt中将私有类按照同样的关系进行继承,通过为子类提供保护构造函数实现只使用一个dpointer实例。摘抄qt官网的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


/* widget.h */
 class Widget {
 public:
 Widget();
 …
 protected:
 // only sublasses may access the below
 Widget(WidgetPrivate &d); // 允许子类通过他们自己的实体私有对象来初始化
 WidgetPrivate *d_ptr;
 };

 /* widget_p.h */ (_p means private)
 struct WidgetPrivate {
 WidgetPrivate(Widget *q) : q_ptr(q) { } // 构造函数初始化 q-ptr
 Widget *q_ptr; // 指向API类的
 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); // 允许Label的子类传递自己的私有数据
 //注意 Label 没有 d_ptr！它用了父类 Widget 的 d_ptr。
 };

 /* label.cpp */
 #include "widget_p.h" // 所以我们能够访问 WidgetPrivate

class LabelPrivate : public WidgetPrivate {
 public:
 String text;
 };

不过显然这会带来类型的问题，当派生类使用dpointer的时候需要进行类型转换。Qt提供了宏来简化步骤

Q_D和Q_Q分别是得到转换后dpointer和qpointer的宏，此外还有Q_DECLARE_PRIVATE等，用于友元从外部类访问私有类的数据结构和方法，从略。

关于在Qt等库中广泛应用的d-pointer

On This Page: