QT namespace UI / PIMPL (Private Implementation / Pointer to Implementation)

简述：

Qt编程中，会见到类似于如下的声明：

1

namespace Ui

2

{

3

    class Dialog;

4

}

那么，为何要这样声明，这样声明有什么好处。

这是Designer使用了pimpl手法，pImpl手法主要作用是解开类的使用接口和实现的耦合，即为了减少各个源文件之间的联系。

下面详细讲解一下。

1、新建Qt 设计师界面类

dialog.h

1

#ifndef DIALOG_H

2

#define DIALOG_H

3

4

#include <QtGui/QDialog>

5

6

namespace Ui

7

{

8

    class Dialog;

9

}

10

11

class Dialog : public QDialog

12

{

13

    Q_OBJECT

14

15

public:

16

    Dialog(QWidget *parent = 0);

17

    ~Dialog();

18

19

private:

20

    Ui::Dialog *ui;

21

};

22

23

#endif // DIALOG_H

dialog.cpp

1

#include "dialog.h"

2

#include "ui_dialog.h"

3

4

Dialog::Dialog(QWidget *parent)

5

    : QDialog(parent), ui(new Ui::Dialog)

6

{

7

    ui->setupUi(this);

8

    //QObject::connect(ui->pushButton, SIGNAL(clicked()),this, SLOT(quit()));

9

}

10

11

Dialog::~Dialog()

12

{

13

    delete ui;

14

}

ui_dialog.h

1

#ifndef UI_DIALOG_H

2

#define UI_DIALOG_H

3

4

#include <QtCore/QVariant>

5

#include <QtGui/QAction>

6

#include <QtGui/QApplication>

7

#include <QtGui/QButtonGroup>

8

#include <QtGui/QDialog>

9

#include <QtGui/QHeaderView>

10

#include <QtGui/QListView>

11

#include <QtGui/QPushButton>

12

    

13

QT_BEGIN_NAMESPACE

14

15

class Ui_Dialog

16

{

17

public:

18

    QListView *listView;

19

    QPushButton *pushButton

20

    

21

    

22

    void setupUi(QDialog *Dialog)

23

    {

24

        if (Dialog->objectName().isEmpty())

25

            Dialog->setObjectName(QString::fromUtf8("Dialog"));

26

        Dialog->resize(600, 400);

27

        listView = new QListView(Dialog);

28

        listView->setObjectName(QString::fromUtf8("listView"));

29

        listView->setGeometry(QRect(30, 10, 256, 192));

30

        pushButton = new QPushButton(Dialog);

31

        pushButton->setObjectName(QString::fromUtf8("pushButton"));

32

        pushButton->setGeometry(QRect(140, 280, 75, 23));

33

    

34

        retranslateUi(Dialog);

35

    

36

        QMetaObject::connectSlotsByName(Dialog);

37

    } // setupUi

38

    

39

    void retranslateUi(QDialog *Dialog)

40

    {

41

        Dialog->setWindowTitle(QApplication::translate("Dialog", "Dialog", 0, QApplication::UnicodeUTF8));

42

        pushButton->setText(QApplication::translate("Dialog", "bye", 0, QApplication::UnicodeUTF8));

43

        Q_UNUSED(Dialog);

44

    } // retranslateUi

45

    

46

};

47

48

namespace Ui {

49

    class Dialog: public Ui_Dialog {};

50

} // namespace Ui

51

52

QT_END_NAMESPACE

53

54

#endif // UI_DIALOG_H

2、分析代码

1 > ui_dialog.h代码中有很多被硬编码的地方。

1

listView->setGeometry(QRect(30, 10, 256, 192));

2

pushButton = new QPushButton(Dialog);

3

pushButton->setObjectName(QString::fromUtf8("pushButton"));

4

pushButton->setGeometry(QRect(140, 280, 75, 23));

Designer生成的这个东西， 如何让程序的其他代码去使用呢？

最直接的， 它应该产生一个

1

class Ui_Dialog {

2

QListView *listView;

3

QPushButton *pushButton;

4

};

这样的类去让其他代码使用：

1

// My.h

2

#include "ui_dialog.h"

3

4

class My

5

{

6

    Ui_Dialog dlg;

7

};

8

9

// My.cpp

10

#include "My.h"

11

// 实现My

但是这样存在问题， 如果ui_dialog.h文件的内容被改变，不但My.cpp会被重新编译，

所有包含My.h的文件也都会被重新编译。

而且这确实是一个问题： Designer确实经常被拖来拖去。

2 > 如果产生ui_dialog.h的那个程序能将如下代码：

1

listView->setGeometry(QRect(30, 10, 256, 192));

2

pushButton = new QPushButton(Dialog);

3

pushButton->setObjectName(QString::fromUtf8("pushButton"));

4

namespace Ui {

5

class Dialog;

6

}

7

8

class Dialog : public QDialog {

9

Ui:: Dialog *ui; // 使用该类的一个指针

10

};

11

12

13

pushButton->setGeometry(QRect(140, 280, 75, 23));

移动到一个ui_dialog.cpp 中， 至少在移动dlg上的那些界面元素时，只会重新编译ui_dialog.cpp。

不会修改ui_dialog.h， 也就不会引发另一连串重编译。

3 > 但是， 除了将界面元素拖来拖去， Designer还经常干的一些事就是添加，删除一些界面元素，如：

1

class Ui_Dialog

2

{

3

public:

4

QListView *listView;

5

QPushButton *pushButton;

6

// ...

7

};

这样 ui_dialog.h 文件还是得改变。

4 > 如何让Designer改变GUI外观后， 不会引发工程大范围的重新编译？

所以Designer使用了pimpl手法 ……

前置声明一个 Ui:: Dialog类

1

namespace Ui {

2

class Dialog;

3

}

4

5

class Dialog : public QDialog {

6

Ui:: Dialog *ui; // 使用该类的一个指针

7

};

然后用户使用 dialog.h 头文件以及 Dialog类。

该文件被修改的频率就会低很多很多。

无论是将designer上的界面元素拖来拖去， 还是添加删除， dialog.h文件的内容——Dialog类的定义——都不会改变。

然后用户可以使用这个Dialog了：

1

#include "dialog.h"

2

class My

3

{

4

Dialog dlg;

5

};

3、Ui 创建两种不同的方式

1 > 在qt4中使用了继承的方式来使用designer创建的窗体，也就是同时继承QDialog和UI_Dialog。

2 > 而在Qt Creator自动创建的项目中，使用了组合的方式来使用Designer创建的窗体，就是集成QDialog，而将UI_Dialog作为一个成员变量来使用，也就是

1

private:

2

Ui::Dialog *ui;

区别：

在前一种方式中，你可以在继承类中直接使用UI_Dialog上的组件。

在后一种方式中，你要使用ui->XXX的方式使用UI_Dialog上的组件。 

两种方式都可以，但个人感觉第二种好一些，毕竟组合比继承的耦合度来的弱一些，就是稍有点麻烦，要加ui->，但同时也带来了更清晰的代码结构。

4、pImpl的原理

1 > pImpl惯用手法的主要作用是解开类的使用接口和实现的耦合。

如果不使用pImpl惯用手法，代码会像这样

1

#include<x.hpp>

2

class C

3

{

4

public:

5

    void f1();

6

private:

7

    X x; //与X的强耦合

8

};

像上面这样的代码，C与它的实现就是强耦合的，从语义上说，x成员数据是属于C的实现部分，不应该暴露给用户。从语言的本质上来说，在用户的代码中，每一次使用”new C”和”C c1”这样的语句，都会将X的大小硬编码到编译后的二进制代码段中（如果X有虚函数，则还不止这些）——这是因为，对于”new C”这样的语句，其实相当于operator new(sizeof(C))后面再跟上C的构造函数，而”C c1”则是在当前栈上腾出sizeof(C)大小的空间，然后调用C的构造函数。因此，每次X类作了改动，使用c.hpp的源文件都必须重新编译一次，因为X的大小可能改变了。

在一个大型的项目中，这种耦合可能会对build时间产生相当大的影响。

pImpl惯用手法可以将这种耦合消除，使用pImpl惯用手法的代码像这样：

1

//c.hpp

2

class X; //用前导声明取代include

3

class C

4

{

5

    ...

6

    private:

7

    X* pImpl; //声明一个X*的时候，class X不用完全定义

8

};

2 > 在一个既定平台上，任何指针的大小都是相同的。之所以分为X*，Y*这些各种各样的指针，主要是提供一个高层的抽象语义，即该指针到底指向的是那个类的对象，并且，也给编译器一个指示，从而能够正确的对用户进行的操作（如调用X的成员函数）决议并检查。但是，如果从运行期的角度来说，每种指针都只不过是个32位的长整型（如果在64位机器上则是64位，根据当前硬件而定）。

正由于pImpl是个指针，所以这里X的二进制信息（sizeof(C)等）不会被耦合到C的使用接口上去，也就是说，当用户”new C”或”C c1”的时候，编译器生成的代码中不会掺杂X的任何信息，并且当用户使用C的时候，使用的是C的接口，也与X无关，从而X被这个指针彻底的与用户隔绝开来。只有C知道并能够操作pImpl成员指向的X对象。

3 > 防火墙

“修改X的定义会导致所有使用C的源文件重新编译”这种事就好比“城门失火，殃及池鱼”，其原因是“护城河”离“城门”太近了（耦合）。

pImpl惯用手法又被成为“编译期防火墙”，什么是“防火墙”，指针？不是。C++的编译模式为“分离式编译”，即不同的源文件是分开编译的。也就是说，不同的源文件之间有一道天然的防火墙，一个源文件“失火”并不会影响到另一个源文件。

但是，这里我们考虑的是头文件，如果头文件“失火”又当如何呢？头文件是不能直接编译的，它包含于源文件中，并作为源文件的一部分被一起编译。

这也就是说，如果源文件S.cpp使用了C.hpp，那么class C的（接口部分的）变动将无可避免的导致S.CPP的重新编译。但是作为class C的实现部分的class X却完全不应该导致S.cpp的重新编译。

因此，我们需要把class X隔绝在C.hpp之外。这样，每个使用class C的源文件都与class X隔离开来（与class X不在同一个编译单元）。但是，既然class C使用了class X的对象来作为它的实现部分，就无可避免的要“依赖”于class X。只不过，这个“依赖”应该被描述为：“class C的实现部分依赖于class X”，而不应该是“class C的用户使用接口部分依赖于class X”。

如果我们直接将X的对象写在class C的数据成员里面，则显而易见，使用class C的用户“看到”了不该“看到”的东西——class X——它们之间产生了耦合。然而，如果使用一个指向class X的指针，就可以将X的二进制信息“推”到class C的实现文件中去，在那里，我们#include”x.hpp”，定义所有的成员函数，并依赖于X的实现，这都无所谓，因为C的实现本来就依赖于X，重要的是：此时class X的改动只会导致class C的实现文件重新编译，而用户使用class C的源文件则安然无恙！

指针在这里充当了一座桥。将依赖信息“推”到了另一个编译单元，与用户隔绝开来。而防火墙是C++编译器的固有属性。

4 > 穿越C++编译期防火墙

是什么穿越了C++编译期防火墙？是指针！使用指针的源文件“知道”指针所指的是什么对象，但是不必直接“看到”那个对象——它可能在另一个编译单元，是指针穿越了编译期防火墙，连接到了那个对象。

从某种意义上说，只要是代表地址的符号都能够穿越C++编译期防火墙，而代表结构(constructs)的符号则不能。

例如函数名，它指的是函数代码的始地址，所以，函数能够声明在一个编译单元，但定义在另一个编译单元，编译器会负责将它们连接起来。用户只要得到函数的声明就可以使用它。而类则不同，类名代表的是一个语言结构，使用类，必须知道类的定义，否则无法生成二进制代码。变量的符号实质上也是地址，但是使用变量一般需要变量的定义，而使用extern修饰符则可以将变量的定义置于另一个编译单元中。