笔记 - Qt Creator快速入门_第三版_qtcreator快速入门

第一章 Qt Creator 简介

Qt 开源社区：www.qter.org。
1

1.1 Qt Creator 的下载与安装

开发平台：Window 7 桌面平台。
软件版本：Qt 5.6.1版本，其中包含了 Qt Creator 4.0.1.
1
2

MinGW 即 Minimalist GNU For Windows, 是将 GNU 开发工具移植到 Win32 平台下的产物，时一套 Windows 上的 GNU 工具集，用其开发的程序不需要额外的第三方 DLL 支持就可以直接在 Windows 下运行。

1.2 Qt Creator 环境介绍

Qt Creator 界面，主要由主窗口区、菜单栏、模式选择器、构建套件选择器、定位器和输出窗格等部分组成；

1.3 Qt 工具简介

Qt 中包含的工具：Qt Assistant（Qt 助手）、Qt Designer（Qt 设计师）、Qt Linguist（Qt 语言家）

1.3.1 Qt Assistant(Qt 助手)

Qt Assistant 是可配置且可重新发布的文档阅读器，可以方便地进行定制，并与Qt应用程序一起重新发布。

1.3.2 Qt Designer(Qt 设计师)

Qt Designer 是强大的跨平台 GUI 布局和格式构建器。

1.3.3 Qt Linguist(Qt 语言家)

Qt Linguist 提供了一套加速应用程序翻译和国际化的工具。

第二章 Hello World

2.1 编写Hello World程序

在Qt Creator 中创建一个图形用户界面的项目，从而生成一个可以显示Hello World字符串的程序。

2.1.1 新建Qt Widgets应用

• 第一步，选择项目模板。选择“文件->新建文件或项目”菜单项，在选择模板页面选择Application中的Qt Widgets Application项，然后单击 Choose按钮。
• 第二步，输入项目信息。在“项目介绍和位置”页面输入项目的名称为helloworld，然后单击创建路径右边的“浏览”按钮来选择源码路径。如果选中了“设置默认的项目路径”，那么以后创建的项目会默认使用该目录。单击“下一步”进入下一个页面。
  注意：项目名和路径中都不能出现中文。
• 第三步，选择构建套件。
• 第四步，输入类信息。在“类信息”页面中创建一个自定义类。这里设定类名为HelloDialog，基类选择QDialog，表明该类继承自QDialog类，使用这个类可以生成一个对话框界面。这时下面的头文件、源文件和界面文件都会自动生成，保持默认即可。然后单击“下一步”按钮。
• 第五步，设置项目管理。在这里可以看到这个项目的汇总信息，还可以使用版本控制系统，这个项目不会涉及，所以可以直接单击“完成”按钮完成项目创建。

2.1.2 文件说明与界面设计

项目建立完成后会直接进入编辑模式。界面的右边是编辑器，可以阅读和编辑代码。如果觉得字体太小，则可以使用快捷键Ctrl+"+“来放大字体，使用Ctrl+”-"来缩小字体，或者使用Ctrl+鼠标滚轮，使用Ctrl+0可以使字体还原到默认大小。
项目目录中各个文件说明

• helloworld.pro: 该文件是项目文件，其中包含了项目相关信息；
• helloworld.pro.user: 该文件中包含了与用户有关的项目信息；
• hellodialog.h: 该文件是新建HelloDialog类的头文件；
• hellodialog.cpp: 该文件是新建HelloDialog类的源文件；
• main.cpp: 该文件中包含了main()主函数；
• hellodialog.ui: 该文件时设计师设计的界面对应的界面文件；

在Qt Creator 的编辑模式下双击项目文件列表中界面文件分类下的hellodialog.ui文件，这时进入了设计模式。
设计模式由以下几部分构成：

• 主设计区：
  主要用来设计界面以及编辑各个部件的属性；
• 部件列表窗口(Widget Box)：
  窗口分类罗列了各种常用的标准部件，可以使用鼠标将这些部件拖入主设计区中，放到主设计区中的界面上。
• 对象查看器(Object Inspector)：
  查看器列出了界面上所有部件的对象名称和父类，而且以树形结构显示了各个部件的所属关系。可以在这里单击对象来选中该部件。
• 属性编辑器(Property Editor)：
  编辑器显示了各个部件的常用属性信息，可以更改部件的一些属性，入大小、位置等。这些属性按照从祖先继承的属性，从父类继承的属性和自己属性的顺序进行了分类。
• 动作(Action)编辑器与信号和槽编辑器：
  两个编辑器可以对相应的对象内容进行编辑。
• 常用功能图标
  单击最上面侧边栏中的前四个图标可以进入相应的模式，分别是窗口部件编辑模式（默认）、信号/槽编辑模式、伙伴编辑模式和Tab顺序编辑模式。后面的几个图标用来实现添加布局管理器以及调整大小等功能。
  可以使用“工具->Form Editor”菜单项来实现预览设计效果、设置界面上栅格间距、在设计部件与其对应的源文件间进行切换等操作。这部分内容可以在帮助索引中通过Getting to Know Qt Designer关键字查看。

2.2 程序的运行与发布

2.2.1 程序的运行

• 编译运行程序
  可以使用快捷键Ctrl+ R或者通过按左下角的运行按钮来运行程序。
  可以选择“构建之前总是先保存文件”选项，则以后再运行程序时就可以自动保存文件了。
• 查看构建项目生成的文件
  Qt Creator 将项目源文件和编译生成的文件进行分类存放；
  build-helloworld-Desktop_Qt_5_6_1_MinGW_32bit_Debug文件夹，这是默认的构建目录，存放编译后生成的文件。
  该文件夹中，有3个Makefile文件和一个ui_hellodialog.h文件，还有两个目录debug和release.进入release/debug文件夹，有3个.o文件和一个.cpp文件，它们是编译时生成的中间文件，不必管它，而剩下的一个helloworld.exe文件便是生成的可执行文件。
• 直接运行生成的可执行文件
  应用程序运行是需要dll动态链接库的，可以直接将Qt的bin目录路径加入到系统Path环境变量中；
  具体做法：右击“计算机”，在弹出的级联菜单中选择“属性”，然后在弹出的系统属性对话框中选择“高级系统设置”项。单击“环境变量”按钮进入环境变量设置界面。在“系统变量”栏中找到Path变量，单击“编辑”弹出编辑系统变量对话框。在变量值的最后添加路径“;C:\Qt\Qt5.6.1\5.6\mingw49_32\bin”（注意前面有一个英文的分号），然后单击“确定”即可；

2.2.2 程序的发布

• 在Qt Creator中对helloworld程序进行release版本的编译。在左下角目标选择器（Target selector）中将构建目录设置为Release，然后单击运行图标。编译完成后在构建目录中release目录下，其中已经生成了helloworld.exe文件。如果前面已经添加了Path系统环境变量，那么现在就可以直接双击运行该程序。如果要使Release版本程序可以在别的计算机上运行，还需要将几个dll文件与其一起发布。
• Qt提供了一个windeployqt工具来自动创建可部署的文件夹。
  在开始菜单的Qt 5.6.1菜单中启动Qt 5.6 for Desktop命令行工具，然后输入下面命令即可：windeployqt c:\myapp （可执行文件所在目录路径）
• 用windeployqt工具会将所有可用的文件都复制过来，有些可能是现在并不需要的，所以建议一般情况下不要使用，只有在无法确定程序依赖的文件时再使用该工具。如果不想使用Qt 5.6 for Desktop 命令行工具来运行该命令，而是用cmd命令行提示符，那么必须保证已经将Qt安装目录的bin目录路径添加到了系统PATH环境变量中。
• 若程序中使用了png以外格式的图片，则发布程序时就要将Qt安装目录下的plugins目录中的imageformats文件夹复制到发布程序文件夹中，其中只要保留自己用到的文件格式的dll文件即可。例如用到了gif文件，那么只需要保留qgif.dll。如果程序中使用了其他的模块，比如数据库，那么就要将plugins目录中的sqldrivers文件夹复制过来，里面只须保留用到的数据库dll文件。
• 动态编译&静态编译
  动态编译：Qt Creator默认的编译方式，编译的程序发布时需要包含dll文件；
  静态编译：将库进行重新编译，用静态编译的库来链接程序，这样生成的目标文件就可以直接运行，而不再需要dll文件的支持；不过这样生成的exe文件很大且缺乏灵活性，也不能部署插件。
  想了解更多Qt发布的知识和静态编译的方法，可以在Qt Creator帮助的索引方式下通过Deploying Qt Applications关键字查看，Windows平台发布程序对应的关键字是Qt for Windows-Deployment.

2.2.3 设置应用程序图标

可以在Qt Creator的帮助索引中查找Setting the Application Icon关键字，这里列出了在Windows上设置应用程序图标的方法，步骤如下：

• 第一步，创建 .ico文件。将ico图标文件复制到工程文件夹的helloworld目录中，重命名为“myico.ico”。
• 第二步，修改项目文件。在QtCreator中的编辑模式双击helloworld.pro文件，在最后面添加下面一行代码：
  RC_ICONS = myico.ico
• 第三步，运行程序。

2.3 helloworld程序源码与编译过程详解

2.3.1 纯代码编写程序与命令行编译

在Qt Creator中使用纯代码编写helloworld程序并编译运行，然后再使用普通文本编辑器编写helloworld程序，并在命令行编译运行。该部分内容可以在帮助中通过Getting Started Programming with Qt Widgets 关键字查看。

1. 在Qt Creator中用纯代码编写程序

• 第一步，新建空项目。打开Qt Creator并新建项目，选择“其他项目”中的Empty qmake Project。然后将项目命名为helloworld并设置路径。完成后，双击helloworld.pro文件，添加一行代码：

  // 这行代码的意思是，如果Qt主版本大于4（也就是说当前使用的是Qt5或更高版本）
  //，则需要添加widgets模块。
  greaterThan(QT_MAJOR_VERSION,4): QT += widgets
  1
  2
  3

• 第二步，往项目中添加main.cpp文件。在项目文件列表中的项目文件夹helloworld上右击，在弹出的级联菜单中选择“添加新文件”项，然后选择C++ Source File，名称设置为main.cpp，路径就是默认的项目目录。

• 第三步，编写源代码。向新建的main.cpp文件中添加如下代码：

  // 前3行是头文件包含。Qt中每一个类都有一个与其同名的头文件
  #include <QApplication>
  #include <QDialog>
  #include <QLabel>
  // C++中最常见的main()函数
  // 它有两个参数，用来接收命令行参数
  int main(int argc, char * argv[])
  {
  	// 新建 QApplication 类对象，用于管理应用程序的资源。
  	// 任何一个 Qt Widget 程序都要有一个 QApplication 对象。
  	// 因为 Qt 程序可以接收命令行参数，所以它需要 argc 和 argv 两个参数。
  	QApplication a(argc,argv);
  	// 新建 QDialog 对象，QDialog 类用来实现一个对话框界面。
  	QDialog w;
  	// 设置对话框宽高，单位是像素。
  	w.resize(400,300);
  	// 新建 QLabel 对象，并将 QDialog 对象作为参数。
  	// 表明了对话框是它的父窗口，即这个标签放在对话框窗口中。
  	QLabel label(&w);
  	label.move(120,120);
  	// 标签设置要显示的字符
  	// QObject::tr()函数可以实现多语言支持。
  	label.setText(QObject::tr"Hello World!");
  	// 让对话框显示出来
  	// 在默认情况下，新建的可视部件对象都是不可见的，使用 show() 函数显示出来。
  	w.show();
  	// 让 QApplication 对象进入事件循环。
  	// 这样当 Qt 应用程序运行时便可以接收产生的事件。
  	return a.exec();
  }
  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

• 第五步，编译运行。按下Alt+4快捷键可以显示编译输出信息；

2. 在命令行编译程序

前面在Qt Creator中使用纯代码实现了helloworld程序。下面不使用Qt Creator，而是在其他的编译器（如Windows的记事本）中编写源码，然后再到命令行去编译运行该程序，步骤如下：

• 第一步，新建工程目录。在Qt的安装目录中新建文件夹helloworld，然后在其中新建文本文档，将Qt Creator的main.cpp文件中的所有内容复制过来，并将文件另存为main.cpp（保存时要将编码选择为UTF-8，否则中文可能显示乱码）。

• 第二步，使用命令编译程序。打开开始菜单中Qt安装目录下的命令提示符程序Qt 5.6 for Desktop (MinGW 4.9.2 32bit)，这里已经配置好了环境。输入"cd C:\Qt\helloworld"跳转到新建的helloworld目录中。然后再输入"qmake-project"命令来生成pro工程文件。使用记事本打开该文件，然后在最后面添加如下一行代码：

  greaterThan (QT_MAJOR_VERSION,4):QT += widgets
  1

  然后输入qmake命令来生成用于编译的Makefile文件。最后输入"mingw32-make"命令来编译程序，编译完成后会在release目录中出现helloworld.exe文件。

  补充：
  上面使用的qmake是Qt提供的一个编译工具，它可以生成与平台无关的.pro文件，然后利用该文件生成与平台无关的Makefile文件。Makefile文件中包含了要创建的目标文件或可执行文件、创建目标文件所依赖的文件和创建每个目标文件时需要运行的命令等信息。最后使用mingw32-make工具来完成自动编译，mingw32-make就是通过读入Makefile文件的内容来执行编译工作的。使用mingw32-make命令时会为每一个源文件生成一个对应的.o目标文件，最后将这些目标文件进行链接来生成最终的可执行文件。qmake.exe工具在Qt安装目录的bin目录中，mingw32-make.exe工具在MinGW编译器目录的bin目录中。

• 第三步，运行程序。
  这就是Qt程序编辑，编译和运行的整个过程，可以看到，Qt Creator是将工程目录管理、源码编辑和程序编辑运行等功能集合在一起，这就是IDE（集成开发环境）的含义。

2.3.2 使用.ui文件

在Qt Creator中往前面的helloworld项目里添加.ui文件，使用.ui文件生成界面来代替前面代码生成界面，并讲解.ui文件的作用以及其编译过程。这部分内容可以在帮助索引中通过Using a Designer UI File in Your Application关键字查看。

1. 使用.ui界面文件

• 第一步，添加.ui文件。在模板中选择Qt中的Qt Designer Form，在选择界面模板时选择Dialog witout Buttons项。

• 第二步，设计界面。生成文件后即进入了设计模式。

• 第三步，生成ui头文件。保存修改，然后按下Ctrl+2快捷键回到编辑模式，会看到.ui文件的内容，是一个XML文件，里面是界面部件的相关信息。使用Ctrl+Shift+B快捷键或左下角的构建图标来构建工程。

  在项目构造目录中可以看到由.ui文件生成的ui_hellodialog.h头文件。下面看一下这个头文件中的具体内容：

  // 第1~7行是注释信息。
  /********************************************************************************
  ** Form generated from reading UI file 'hellodialog.ui'
  **
  ** Created by: Qt User Interface Compiler version 5.6.3
  **
  ** WARNING! All changes made in this file will be lost when recompiling UI file!
  ********************************************************************************/
  
  // 预处理指令，能够防止对这个头文件的多重包含。
  #ifndef UI_HELLODIALOG_H
  #define UI_HELLODIALOG_H
  // 包含了几个类的头文件
  #include <QtCore/QVariant>
  #include <QtWidgets/QAction>
  #include <QtWidgets/QApplication>
  #include <QtWidgets/QButtonGroup>
  #include <QtWidgets/QDialog>
  #include <QtWidgets/QHeaderView>
  #include <QtWidgets/QLabel>
  
  // Qt 的命名空间开始宏
  QT_BEGIN_NAMESPACE
  
  // 定义了一个 Ui_HelloDialog 类
  // 该类名就是在前面更改的对话框类对象的名称前添加了“Ui_”字符，这是默认的名字。
  class Ui_HelloDialog
  {
  public:
  	// 定义了一个 QLabel 类对象的指针，这个就是对话框窗口添加的 label 部件。
      QLabel *label;
  	// setupUi()函数用来生成界面
  	// 因为当时选择模板时使用的是对话框，所以现在这个函数的参数是 QDialog 类型。
      void setupUi(QDialog *HelloDialog)
      {
      	// 设置对话框的对象名称
          if (HelloDialog->objectName().isEmpty())
              HelloDialog->setObjectName(QStringLiteral("HelloDialog"));
          // 设置窗口的大小
          HelloDialog->resize(400, 300);
          // 在对话框上创建了标签对象，并设置了它的对象名称，大小和位置。
          label = new QLabel(HelloDialog);
          label->setObjectName(QStringLiteral("label"));
          label->setGeometry(QRect(120, 110, 141, 41));
  		// 调用 retranslateUi()函数，这个函数在后面进行了定义。
  		// 实现了对窗口里的字符串进行编码转换功能。
          retranslateUi(HelloDialog);
  		// 调用了 QMetaObjec 类的 connectSlotsByName()静态函数。
  		// 使得窗口中的部件可以实现按对象名进行信号和槽的关联。
          QMetaObject::connectSlotsByName(HelloDialog);
      } // setupUi
  
      void retranslateUi(QDialog *HelloDialog)
      {
          HelloDialog->setWindowTitle(QApplication::translate("HelloDialog", "HelloDialog", Q_NULLPTR));
          label->setText(QApplication::translate("HelloDialog", "Hello World! \344\275\240\345\245\275Qt\357\274\201", Q_NULLPTR));
      } // retranslateUi
  
  };
  // 定义了命名空间 Ui，其中定义了一个 HelloDialo 类，继承自 Ui_HelloDialog 类。
  namespace Ui {
      class HelloDialog: public Ui_HelloDialog {};
  } // namespace Ui
  // Qt的命名空间结束宏。
  QT_END_NAMESPACE
  
  #endif // UI_HELLODIALOG_H
  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
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67

  可以看到，Qt中使用ui文件生成相应的头文件，其中代码的作用与2.3.1小节中纯代码编写程序中代码的作用是相同的。使用Qt设计师可以直观的看到设计的界面，而且省去了编写界面代码的过程。

• 第四步，更改main.cpp文件。将main.cpp文件中的内容更改如下：

  // 头文件包含
  // ui_hellodialog.h 中已经包含了其他类的定义。
  // 所以这里只需要包含这个文件就可以了。
  #include "hellodialog.h"
  #include <QApplication>
  
  int main(int argc, char *argv[])
  {
      QApplication a(argc, argv);
  	QDialog w;
  	// 使用命名空间 Ui 中的 HelloDialog 类定义了一个 ui 对象。
  	Ui::HelloDialog ui;
  	// 使用 setupUi()函数，并将对话框类对象作为参数。
  	// 这样就可以将设计好的界面应用到对象w所表示的对话框上。
  	ui.setupUi(&w);
      w.show();
      return a.exec();
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18

  对于头文件的包含，使用"<>"时，系统会到默认目录（编译器及环境变量、项目文件所定义的头文件寻找目录，包括Qt安装的include 目录）查找要包含的文件，这是标准方式；用双引号时，系统先到用户当前目录（即项目目录）中查找要包含的文件，找不到再按标准方式查找。

• 第五步，运行程序

2. 在命令行编译ui文件和程序

• 第一步，新建工程目录。在C:\Qt目录中新建文件夹helloworld_2，然后将上面的项目文件夹helloworld目录下的hellodialog.ui和main.cpp两个文件复制过来。

• 第二步，编译.ui文件。打开命令提示符程序Qt 5.6 for Desktop (MinGW 4.9.2 32 bit)，然后输入“cd C:\Qt\helloworld_2”命令进入helloworld_2文件夹中。再使用uic编译工具，从ui文件生成头文件。具体命令是：

  uic-o ui_hellodialog.h hellodialog.ui
  1

• 第三步，编译运行程序。输入如下命令：

  qmake - project
  1

  这时在helloworld_2.pro文件中添加“QT += widgets”，然后依次执行如下命令：

  qmake
  mingw32 - make
  cd release
  helloworld_2.exe
  1
  2
  3
  4

这样就完成了整个编译运行过程。可以看到，.ui文件是使用uic编译工具来编译的，这里的Qt程序通过调用相应的头文件来使用ui界面文件。

2.3.3 自定义C++类

• 第一步，新建空的Qt项目Empty qmake Project，项目名称为helloworld.完成后打开helloworld.pro文件，添加如下代码并保存该文件：
  greaterThan(QT_MAJOR_VERSION,4):QT += widgets

• 第二步，添加文件。向项目中添加新文件，模板选择C++ Class. 类名Class Name为HelloDialog，基类Base class 选择自定义，然后在下面手动填写为QDialog.

• 第三步，编写源码。在main.cpp中添加如下代码：

  #include <QApplication>
  // 包含了新建的 HelloDialog 类的头文件。
  #include "hellodialog.h"
  int main(int argc, char *argv[])
  {
  	QApplication a(argc, argv);
  	// 定义了一个该类的对象
  	HelloDialog w;
  	w.show();
  	return a.exec().
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

• 第四步，添加ui文件。将hellodialog.ui文件复制到项目目录下，然后在Qt Creator项目文件列表中的项目文件夹右击，在弹出的级联菜单中选择“添加现有文件”，然后在弹出的对话框中选择helloworld.ui文件，将其添加到项目中。

• 第五步，更改C++类文件。这次不在main()函数中使用ui文件，而是在新建立的C++类中使用。先将头文件hellodialog.h中修改如下：

  // 预处理指令，避免该头文件多重包含
  #ifndef HELLODIALOG_H
  #define HELLODIALOG_H
  
  #include <QDialog>
  // 定义了命名空间 Ui，并在其中前置声明了 HelloDialog 类。
  // 这个类是在 ui_hellodialog.h 文件中定义的。
  // 因为它与新定义的类同名，所以使用了Ui命名空间。
  // 前置声明是为了加快编译速度，也可以避免在一个头文件中随意包含其他头文件而产生错误。
  // 因为只使用了该类对象的指针，并不需要该类的完整定义，所以可以使用前置声明。
  // 不需要包含 ui_hellodialog.h 头文件。
  namespace Ui{
  class HelloDialog;
  }
  // 新定义的HelloDialog类，继承自QDialog类。
  class HelloDialog:public QDialog
  {
  	// 定义了Q_OBJECT宏，扩展了普通C++类的功能。
  	Q_OBJECT
  public:
  	// 显式构造函数
  	explicit HelloDialog(QWidget *parent = 0);
  	~HelloDialog();
  
  private:
  	Ui::HelloDialog *ui;
  };
  
  #endif // HELLODIALOG_H
  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

  然后在hellodialog.cpp文件中添加代码

  #include "hellodialog.h"
  // 包含了ui头文件，因为hellodialog.h文件中只使用了前置声明。
  // 所以头文件在这里添加。
  #include "ui_hellodialog.h"
  HelloDialog::HelloDialog(QWidget *parent):
  	QDialog(parent),
  	ui(new Ui::HelloDialog)
  {
  // 为现在这个类所代表的对话框创建界面。
  	ui->setupUi(this);
  }
  HelloDialog::~HelloDialog()
  {
  	delete ui;
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

2.3.4 使用Qt设计师界面类

新建空项目，名称为helloworld。在项目文件中添加widgets模块调用代码，然后向该项目中添加新文件，模板选择Qt中的“Qt设计师界面类”。界面模板选择Dialog without Buttons一项，类名为HelloDialog。完成后在设计模式往窗口上添加一个Label，更改显示文本为“Hello Wolrd!”。然后在往项目中添加main.cpp文件，并更改其内容如下：

#include <QApplication>
#include "hellodialog.h"
int main(int argc, char *argv[])
{
	QApplication a(argc,argv);
	HelloDialog w;
	w.show();
	return a.exec();
}
1
2
3
4
5
6
7
8
9

现在可以运行程序。
补充说明：
如果在建立新项目时，没有关闭上一个项目，在Qt Creator的项目文件列表中会有两个项目，可以在这个项目的项目文件夹上右击，在弹出的菜单中选择“运行”，则本次运行该项目。也可以选择第一项“设置为活动项目”，那么就可以按下运行按钮或者使用Ctrl+R快捷键来运行程序了。

2.4 项目模式和项目文件介绍

2.4.1 项目模式

按下快捷键Ctrl+5，或者单击“项目”图标，都可以进入项目模式。如果没有打开任何工程，则项目模式是不可用的。项目模式分为构建和运行、编辑器、代码风格、依赖关系和Clang Static Analyzer这5个页面。如果当前打开了多个项目，那么最上面会分板列出这些项目，可以选择自己要设置的项目。

• 构建和运行页面
  在构建和运行页面可以设置要构建的版本，如Debug版或是Release版本。还可以设置所使用的Qt版本。这里有一个Shadow build选项，就是所谓的“影子构建”,作用是将项目的源码和编译生成的文件分别存放。

• 编辑器
  在编辑器中可以设置默认的文件编码、制表符和缩进、鼠标和键盘的相关功能，这些都是默认的全局设置，一般不建议修改。当然也可以按照自己的习惯进行自定义设置。

• 代码风格
  在代码风格设置页面可以自定义代码风格，还可以将代码风格文件导出或者导入。

• 依赖关系
  在依赖关系中，如果同时打开了多个项目，则可以设置它们之间的依赖关系；

• Clang Static Analyzer
  Qt Creator集成了Clang Static Analyzer可以用来发现C、C++和Objective-C程序中的问题，具体使用方法可以在帮助中索引Using Clang Static Analyzer关键字查看。

• 项目文件
  下面来看一下2.1节中建立的helloworld项目的helloworld.pro文件的内容：

  // 注释信息，说明这个文件生成的时间
  #-------------------------------------------------
  #
  # Project created by QtCreator 2016-07-16T21:45:42
  #
  #-------------------------------------------------
  // 表明这个项目使用的模块。
  // core模块包含了Qt的核心功能，其他所有模块都依赖于这个模块。
  // gui模块提供了窗口系统集成、事件处理、OpenGL和OpenGL ES集成、2D图形、基本图像、字体和文本等功能。
  // 使用qmake工具来构建项目时，core模块和gui模块是被默认包含的。
  // 模块就是很多相关类的集合，可以在Qt帮助中查看Qt Core和Qt GUI关键字。
  QT    += core gui
  // 添加widgets模块
  // Qt Widgets模块中提供了经典的桌面用户界面的UI元素集合。
  // 所有的C++程序用户界面部件都在该模块中。
  greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
  // 生成目标文件的名称，就是生成的exe文件的名字。
  // 默认是项目的名称，也可以在这里改为别的名称。
  TARGET = helloworld
  // 使用app模板，表明这是个应用程序。
  TEMPLATE = app
  
  // 工程中包含的源文件、头文件和界面文件。
  SOURCES += main.cpp\
          hellodialog.cpp 
  
  HEADERS  += hellodialog.h 
  
  FORMS    += hellodialog.ui
  // 添加应用程序图标，这些文件都使用了相对路径，因为都在项目目录中。
  RC_ICONS = myico.ico
  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

补充说明：
在项目文件夹中生成的.pro.user文件，它包含了本地构建信息，包含Qt版本和构建目录等。可以用记事本或者写字板将这个文件打开查看其它内容。使用Qt Creator打开一个.pro文件时会自动生成一个.pro.user文件。因为系统环境不一样，Qt的安装与设置也不尽相同，所以如果要将自己的源码公开，一般不需要包含这个user文件。如果要打开别人的项目文件，但里面包含了user文件，则Qt Creator会弹出提示窗口，询问是否载入特定的环境设置。这时应该选择“否”，然后选择自己的Qt套件即可。

第三章 窗口部件

QMainWindow是带有菜单栏和工具栏的主窗口类，QDialog是各种对话框的基类，它们全部继承自QWidget。

3.1 基础窗口部件QWidget

QWidget类是所有用户界面对象的基类，被称为基础窗口部件。在图3-1中可以看到，QWidget继承自QObject类和QPaintDevice类，其中，QObject类是所有支持Qt对象模型(Qt Object Model)的对象的基类，QPaintDevice类是所有可以绘制的对象的基类。

3.1.1 窗口、子部件以及窗口类型

1. 窗口与子部件

打开Qt Creator,新建空的qmake项目，在.pro中添加“QT += widget”。然后往项目中添加C++源文件main.cpp，并添加以下代码：

**#include <QtWidgets>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    // 新建QWidget类对象，默认parent参数是0，所以它是个窗口
    QWidget *widget = new QWidget(0, Qt::Dialog | Qt::FramelessWindowHint);
    // 设置窗口标题
    widget->setWindowTitle(QObject::tr("我是widget"));
    // 新建QLabel对象，默认parent参数是0，所以它是个窗口
    QLabel *label = new QLabel(0, Qt::SplashScreen | Qt::WindowStaysOnTopHint);
    label->setWindowTitle(QObject::tr("我是label"));
    // 设置要显示的信息
    label->setText(QObject::tr("label:我是个窗口"));
    // 改变部件大小，以便能显示出完整的内容
    label->resize(180, 20);
    // label2指定了父窗口为widget，所以不是窗口
    QLabel *label2 = new QLabel(widget);
    label2->setText(QObject::tr("label2:我不是独立窗口，只是widget的子部件"));
    label2->resize(250, 20);
    // 在屏幕上显示出来
    label->show();
    widget->show();

    int ret = a.exec();
    delete label;
    delete widget;
    return ret;
}**
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

补充说明：

• 一般原则是要包含尽可能少的头文件；
• 在Qt中销毁父对象的时候会自动销毁子对象；
• 窗口部件(Widget)简称部件，是Qt中建立用户界面的主要元素。
• Qt中把没有嵌入到其他部件中的部件称为窗口，一般窗口都有边框和标题栏。
• QMainWindow和大量的QDialog子类是最一般的窗口类型。
• 窗口部件就是没有父部件的部件，所以又称为顶级部件(top-level widget)。
• 非窗口部件，又称子部件(child widget)。

2. 窗口类型

QWidget的构造函数有两个参数：QWidget * parent = 0 和 QT::WindowFlags f = 0，前面的parent指父窗口部件，默认值为0，表明没有父窗口；后面的f参数是Qt::WindowFlags类型的，是Qt::WindowType枚举类型值的或组合。Qt::WindowType枚举类型用来为部件指定各种窗口系统属性。

为窗口添加一些功能：窗口属性

这部分内容可以在帮助中索引中查看Qt::WindowFlags关键字。QWidget中还有一个setWindowState()函数用来设置窗口状态。

3.1.2 窗口几何布局

对于一个窗口，需要设置它的大小和运行时出现的位置，这就是窗口几何布局。对于窗口的大小和位置，根据是否包含边框和标题栏两种情况，要用不同的函数来获取。可以在帮助索引中查看Window and Dialog Widgets关键字，文档中显示了窗口的几何布局图。
图3-6 窗口几何布局

补充说明：

1. 这里的函数分为两类，一类是包含框架的，一类是不包含框架的：
   包含框架：x(), y(), frameGeometry(), pos()和move()等函数；
   不包含框架：geometry(), width(), height(), rect()和size()等函数；
2. 光标定位到函数上，然后按下F1键，可以打开函数的帮助文档；

3.1.3 程序调试

下面讲解程序调试方面的内容。这部分内容可以在帮助索引中通过Interacting with the Debugger和Debugging a C++ Example Application关键字查看。

1. 设置断点

在一行代码的标号前面单击可以设置断点。所谓断点，就是程序运行到该行代码时会暂停下来，从而可以查看一些信息。要取消断点，只要在断点上再点击一下即可。设置好断点后可以按下F5或者左下角的调试按钮开始调试。
下面对调试模式的几个按钮和窗口进行简单的介绍：
图3-7 调试模式

1. 继续按钮：程序在断点处停下来，按下继续按钮后，程序正常运行，执行后面的代码，直到遇到下一个断点，或者程序结束。
2. 停止调试按钮：按下该按钮后结束调试。
3. 单步跳过按钮：直接执行本行代码，然后指向下一行代码。
4. 单步进入按钮：进入调用的函数内部。
5. 单步跳出按钮：当进入函数内部时，跳出该函数，一般与单步进入配合使用。
6. 重新启动调试会话。
7. 显示源码对应的汇编指令，并可以单步调试。
8. 堆栈视图：这里显示了从程序开始到断点处，所有嵌套调用的函数所在的源文件和行号。
9. 其他视图：这里可以选择多种视图，
   局部变量和表达式视图(locals and Expressions)，用来显示局部变量和它们的类型及数值；
   断点视图(Breakpoints)，用来显示所有的断点，以及添加或者删除断点；
   线程视图(Threads)，用来显示所有的线程和现在所在的线程；
   快照视图(Snapshots)，用来管理快照，快照可以保存当前的调试状态。

2. 单步调试

先单击“单步进入”按钮，或者按下F11，则堆栈视图中显示断点所在行函数的源码位置，下面直接单击“单步跳出”按钮回到原来的断点处。然后一直单击“单步跳过”按钮，单步执行程序并查看局部变量和表达式视图中相应值的变化情况。执行到最后一行代码时，单击“停止调试”按钮结束调试。
补充说明：
查看Qt类的源码，可以在编辑器中将鼠标光标定位到一个类名或者函数上，然后按下F2，或者右击，选择“跟踪光标位置的符号”，则编辑器就会跳转到其源码处。

3. 使用qDebug()函数

程序调试过程中常用的是qDebug()函数，它可以将调试信息直接输出到控制台，当然，Qt Creator中是输出到应用程序输出栏。
要使用qDebug()函数，就要添加#include 头文件。这里使用了两种输出方法，一种是直接将字符串作为参数传给qDebug()函数；另一种方法是使用输出流的方式一次输出多个值，它们的类型可以不同；需要说明的是，如果只使用第一种方法，就不需要添加头文件；如果使用第二种方法就必须添加该头文件。

qDebug("y: %d",y);
qDebug()<<"y"<<y<<endl; //endl是起换行作用。
1
2

3.2 对话框 QDialog

这一节主要讲述对话框类，先从对话框的介绍讲起，然后讲述两种不同类型的对话框，再讲解一个由多个窗口组成并且窗口间可以相互切换的程序，最后介绍Qt提供的几个标准对话框。讲解的过程中还会涉及信号和槽的初步知识。本节的内容可以在帮助索引中通过 QDialog和 Dialog Windows 关键字查看。

3.2.1 模态和非模态对话框

QDialog 类是所有对话框窗口类的基类。对话框窗口是一个经常用来完成短小任务或者和用户进行简单交互的顶层窗口。按照运行对话框时是否还可以和该程序的其他窗口进行交互，对话框常被分为两类：模态的(modal)和非模态的(modeless)。关于这两个概念，下面先看一个例子。（项目源码路径：src\03\3-3\mydialog1）
mywidget.cpp