5-Qt系统相关

czxyvX2026-05-13 8:20

第五章 Qt系统相关

1. Qt事件

1.1 事件介绍

事件是应用程序内部或者外部产生的事情或者动作的统称。在 Qt 中使用一个对象来表示一个事件。所有的 Qt 事件均继承于抽象类 QEvent。事件是由系统或者 Qt 平台本身在不同的时刻发出的。当用户按下鼠标、敲下键盘，或者是窗口需要重新绘制的时候，都会发出一个相应的事件。一些事件是在用户操作时发出，如键盘事件、鼠标事件等，另一些事件则是由系统本身自动发出，如定时器事件。常见的 Qt 事件如下：

常见的事件描述：

事件名称 描述
鼠标事件 鼠标左键、鼠标右键、鼠标滚轮，鼠标的移动，鼠标按键的按下和松开
键盘事件 按键类型、按键按下、按键松开
定时器事件 定时时间到达
进入离开事件 鼠标的进入和离开
滚轮事件 鼠标滚轮滚动
绘屏事件 重绘屏幕的某些部分
显示隐藏事件 窗口的显示和隐藏
移动事件 窗口位置的变化
窗口事件 是否为当前窗口
大小改变事件 窗口大小改变
焦点事件 键盘焦点移动
拖拽事件 用鼠标进行拖拽

1.2 事件的处理

事件处理一般常用的方法为：重写相关的 Event 函数。

在 Qt 中，几乎所有的 Event 函数都是虚函数，所以可以重新实现。如：在实现鼠标的进入和离开事件时，直接重新实现 enterEvent() 和 leaveEvent() 即可。enterEvent() 和 leaveEvent() 函数原型如下：

1.2.1 示例1：当鼠标进入时，打印提示信息

  1. 新建 Qt 项目，基类选择 QWidget，同时勾选 UI 界面文件

  2. 设计 UI 文件

  3. 在项目中新添加一个类：MyLabel

    先选中项目名称 QEvent，点击鼠标右键，选择 add new ... ，弹出如下对话框：

    选择：Choose ... ，弹出如下界面：

    此时项目中会新添加以下两个文件：

  4. 在帮助文档中查找对应的内容

    点击 "显示" 之后，出现如下内容：

  5. 复制 enterEvent() ，粘贴在项目文件 "mylabel.h" 中

  6. 重写 enterEvent() 方法

  7. 在 UI 文件中选中 Label，右键 ------> 提升为...

  8. 当点击 "提升为... " 之后，弹出如下对话框：

  9. 修改基类

  10. 执行效果如下：当鼠标进入设计好的标签之后，就会在应用程序输出栏中打印：鼠标进入

1.2.2 示例2：当鼠标点击时，获取对应的坐标值

  1. 在上述示例的基础上，在 mylabel.h 中声明 mousePressEvent() 方法

  2. 在 mylabel.cpp 中重写 mousePressEvent() 方法

  3. 实现效果如下

1.2.3 示例3：鼠标左键点击时，打印对应的坐标值，鼠标右键点击时，打印基于屏幕的坐标

1.3 按键事件

Qt 中的按键事件是通过 QKeyEvent 类来实现的。当键盘上的按键被按下或者被释放时，键盘事件便会触发。在帮助文档中查找 QKeyEvent 类如下：

查找按键事件中所有的按键类型：在帮助文档中输入：Qt::Key，如下图：

1.3.1 单个按键

示例：当某个按键被按下时，输出某个按键被按下了

  1. 新建项目，在头文件 "widget.h" 中声明虚函数 keyPressEvent()；如下图

  2. 在 "widget.cpp" 文件中重写 keyPressEvent() 虚函数

1.3.2 组合按键

在 Qt 助手中搜索：Qt::KeyboardModifier，如下图示：

Qt::KeyboardModifier 中定义了在处理键盘事件时对应的修改键。在 Qt 中，键盘事件可以与修改键一起使用，以实现一些复杂的交互操作。KeyboardModifier 中修改键的具体描述如下：

修改键 说明
Qt::NoModifier 无修改键
Qt::ShiftModifier Shift 键
Qt::ControlModifier Ctrl 键
Qt::AltModifier Alt 键
Qt::MetaModifier Meta键（在Windows上指Windows键，在macOS上指Command键）
Qt::KeypadModifier 使用键盘上的数字键盘进行输入时，Num Lock键处于打开状态
Qt::GroupSwitchModifier 用于在输入法 组之间 切换

示例：

1.4 鼠标事件

在 Qt 中，鼠标事件是用 QMouseEvent 类来实现的。当在窗口中按下鼠标或者移动鼠标时，都会产生鼠标事件。

利用 QMouseEvent 类可以获取鼠标的哪个键被按下了以及鼠标的当前位置等信息。在 Qt 帮助文档中查QMouseEvent类 如下图示：

1.4.1 鼠标单击事件

在 Qt 中，鼠标按下是通过虚函数 mousePressEvent() 来捕获的。mousePressEvent() 函数原型如下：

cpp 复制代码 
[virtual protected] void QWidget::mousePressEvent(QMouseEvent *event)

鼠标左右键及滚轮被按下的表示如下：

Qt::LeftButton 鼠标左键
Qt::RightButton 鼠标右键
Qt::MidButton 鼠标滚轮

示例1：鼠标左键

  1. 在 "widget.h" 头文件中声明鼠标按下事件

  2. 在 "widget.cpp" 文件中重新实现 mousePressEvent() 函数

  3. 实现效果如下

右键和滚轮也是类似，这里不做演示。

1.4.2 鼠标释放事件

鼠标释放事件是通过虚函数 mouseReleaseEvent() 来捕获的。mouseReleaseEvent() 函数原型如下：

cpp 复制代码 
[virtual protected] void QWidget::mouseReleaseEvent(QMouseEvent *event)

示例：

执行效果如下：

1.4.3 鼠标双击事件

鼠标双击事件是通过虚函数：mouseDoubleClickEvent() 来实现的。mouseDoubleClickEvent() 函数原型如下：

cpp 复制代码 
[virtual protected] void QWidget::mouseDoubleClickEvent(QMouseEvent *event)

示例：鼠标左键双击

执行效果如下：

1.4.4 鼠标移动事件

鼠标移动事件是通过虚函数：mouseMoveEvent() 来实现的。同时为了实时捕获鼠标位置信息，需要通过函数 setMouseTracking() 来追踪鼠标的位置。

mouseMoveEvent()函数原型如下：

cpp 复制代码 
[virtual protected] void QWidget::mouseMoveEvent(QMouseEvent *event)

setMouseTracking()函数原型如下：

cpp 复制代码 
void setMouseTracking(bool enable)

说明：

setMouseTracking() 函数默认是 false，需要设置为 true，才能实时捕获鼠标位置信息。否则只有当鼠标按下时才能捕获其位置信息。

示例：

执行效果：

1.4.5 滚轮事件

在 Qt 中，鼠标滚轮事件是通过 QWheelEvent 类来实现的。滚轮滑动的距离可以通过 delta() 函数获取。delta() 函数原型如下：

cpp 复制代码 
int QGraphicsSceneWheelEvent::delta() const

其中返回值代表滚轮滑动的距离。正数表示滚轮相对于用户向前滑动，负数表示滚轮相对于用户向后滑动。

示例：

执行效果如下：

1.5 定时器

Qt 中在进行窗口程序的处理过程中，经常要周期性的执行某些操作，或者制作一些动画效果，使用定时器就可以实现。所谓定时器就是在间隔一定时间后，去执行某一个任务。定时器在很多场景下都会使用到，如弹窗自动关闭之类的功能等。

Qt中的定时器分为 QTimerEvent 和 QTimer 这2个类。

  • QTimerEvent类 用来描述一个定时器事件。在使用时需要通过 startTimer() 函数来开启一个定时器，这个函数需要输入一个以毫秒为单位的整数作为参数来表明设定的时间，它返回的整型值代表这个定时器。当定时器溢出时（即定时时间到达）就可以在 timerEvent() 函数中获取该定时器的编号来进行相关操作。
  • QTimer类 来实现一个定时器，它提供了更高层次的编程接口，如：可以使用信号和槽，还可以设置只运行一次的定时器。
1.5.1 QTimerEvent 类

示例1：在UI界面上放置两个 Label 控件，一个让其1秒数字累加一次，一个让其2秒数字累加一次。

  1. 新建项目，在UI界面文件放置两个 Label 控件

  2. 在 "widget.h" 头文件中声明 timerEvent() 函数，并定义两个整型变量

  3. 在 "widget.cpp" 文件中重写 timerEvent() 函数

  4. 实现效果如下

1.5.2 QTimer 类

示例：在UI界面放置一个 Label 标签，两个按钮，分别是 "开始" 和 "停止" ，当点击 "开始" 按钮时，开始每隔1秒计数一次，点击 "停止" 按钮时，暂停计数。

  1. 设计 UI 界面如下

  2. 在 "widget.cpp" 文件中实现对应功能

  3. 实现效果如下

1.5.3 获取系统日期及时间

在 Qt 中，获取系统的日期及实时时间可以通过 QTimer 类 和 QDateTime类。

QDateTime类 提供了字符串格式的时间。字符串形式的时间输出格式由 toString() 方法中的 format 参数列表决定，可用的参数列表如下：

示例：获取系统日期及实时时间。

  1. 设计UI界面文件；放置一个 Label控件，用来显示日期及时间，放置两个按钮："开始" 和 "停止"

  2. 在 "widget.h" 头文件中声明更新时间的槽函数

  3. 在 "widget.cpp" 文件中实现对应功能

  4. 实现效果如下

1.6 事件分发器

1.6.1 概述

在 Qt 中，事件分发器(Event Dispatcher) 是一个核心概念，用于处理 GUI 应用程序中的事件。事件分发器负责将事件从一个对象传递到另一个对象，直到事件被处理或被取消。每个继承自 QObject类 或QObject类 本身都可以在本类中重写 bool event(QEvent *e) 函数，来实现相关事件的捕获和拦截。

1.6.2 事件分发器和工作原理

在 Qt 中，我们发送的事件都是传给了 QObject 对象，更具体点是传给了 QObject 对象的 event() 函数。所有的事件都会进入到这个函数里面，那么我们处理事件就要重写这个 event() 函数。event() 函数本身不会去处理事件，而是根据 事件类型（type值）调用不同的事件处理函数。事件分发器就是工作在应用程序向下分发事件的过程中，如下图：

如上图，事件分发器用于分发事件。在此过程中，事件分发器也可以做拦截操作。事件分发器主要是通过 bool event(QEvent *e) 函数来实现。其返回值为布尔类型，若为 ture，代表拦截，不向下分发。

Qt 中的事件是封装在 QEvent类 中，在 Qt 助手中输入 QEvent 可以查看其所包括的事件类型，如下图示：

示例：

  1. 在 "widget.h" 头文件中声明 鼠标点击事件 和 事件分发器；如下图示

  2. 在 "widget.cpp" 文件中实现 鼠标点击事件 和 拦截事件

  3. 执行结果如下

1.7 事件过滤器

在 Qt 中，一个对象可能经常要查看或拦截另外一个对象的事件，如对话框想要拦截按键事件，不让别的组件接收到，或者修改按键的默认值等。通过上面的学习，我们已经知道，Qt 创建了 QEvent事件对象之后，会调用QObject 的 event()函数 处理事件的分发。显然，我们可以在 event()函数 中实现拦截的操作。由于 event()函数是 protected 的，因此，需要继承已有类。如果组件很多，就需要重写很多个event()函数。这当然相当麻烦，更不用说重写 event()函数还得小心一堆问题。好在 Qt 提供了另外一种机制来达到这一目的：事件过滤器。

事件过滤器是在应用程序分发到 event事件分发器 之前，再做一次更高级的拦截。如下图示：

事件过滤器的一般使用步骤：

  1. 安装事件过滤器
  2. 重写事件过滤器函数：eventfilter()

示例：

  1. 新建 Qt 项目，基类选择 QWidget，同时勾选 UI 界面文件，如下图示

  2. 设计 UI 文件，如下图示

  3. 在项目新添加一个类：MyLabel

  4. 在 "mylabel.h" 中声明 鼠标点击事件 和 事件分发器

  5. 在 "mylabel.cpp" 文件中实现鼠标点击事件和事件分发器

  6. 在 "widget.h" 头文件中声明事件过滤器函数

  7. 在 "widget.cpp" 文件中实现事件过滤器的两个步骤

  8. 执行结果如下所示

2. Qt文件

2.1 Qt文件概述

文件操作是应用程序必不可少的部分。Qt 作为一个通用开发库，提供了跨平台的文件操作能力。 Qt提供了很多关于文件的类，通过这些类能够对文件系统进行操作，如文件读写、文件信息获取、文件复制或重命名等。

2.2 输入输出设备类

在 Qt 中，文件读写的类为 QFile 。QFile 的父类为 QFileDevice ，QFileDevice 提供了文件交互操作的底层功能。 QFileDevice 的父类是 QIODevice，QIODevice 的父类为 QObject。

QIODevice 是 Qt 中所有输入输出设备（input/output device，简称 I/O 设备）的基础类，I/O 设备就是能进行数据输入和输出的设备，例如文件是一种 I/O 设备，网络通信中的 socket 是 I/O 设备， 串口、蓝牙等通信接口也是 I/O 设备，所以它们也是从 QIODevice 继承来的。Qt 中主要的一些 I/O 设备类的继承关系如下图所示:

上图中各类的说明如下：

类 说明
QFile 是用于文件操作和文件数据读写的类，使用 QFile 可以读写任意格式的文件。
QSaveFile 是用于安全保存文件的类。使用 QSaveFile 保存文件时，它会先把数据写入一个临时文件，成功提交后才将数据写入最终的文件。如果保存过程中出现错误，临时文件里的数据不会被写入最终文件，这样就能确保最终文件中不会丢失数据或被写入部分数据。 在保存比较大的文件或复杂格式的文件时可以使用这个类，例如从网络上下载文件等。
QTemporaryFile 是用于创建临时文件的类。使用函数 QTemporaryFile::open() 就能创建一个文件名唯一的临时文件，在 QTemporaryFile 对象被删除时，临时文件被自动删除。
QTcpSocket/QUdpSocket 是分别实现了 TCP 和 UDP 的类。
QSerialPort 是实现了串口通信的类，通过这个类可以实现计算机与串口设备的通信。
QBluetoothSocket 是用于蓝牙通信的类。手机和平板计算机等移动设备有蓝牙通信模块，笔记本电脑一般也有蓝牙通信模块。通过QBluetoothSocket类，就可以编写蓝牙通信程。如编程实现笔记本电脑与手机的蓝牙通信。
QProcess 类用于启动外部程序，并且可以给程序传递参数。
QBuffer 以一个 QByteArray 对象作为数据缓冲区，将 QByteArray 对象当作一个 I/O 设备来读写。

2.3 文件读写类

在 Qt 中，文件的读写主要是通过 QFile 类来实现。在 QFile 类中提供了一些用来读写文件的方法。对于文件的操作主要有：

  • 读数据：QFile 类中提供了多个方法用于读取文件内容；如 read()、readAll()、readLine()等。
  • 写数据：QFile 类中提供了多个方法用于往文件中写内容；如 write()、writeData()等。
  • 关闭文件：文件使用结束后必须用函数 close() 关闭文件。

访问一个设备之前，需要使用 open()函数 打开该设备，而且必须指定正确的打开模式，QIODevice 中所有的打开模式由 QIODevice::OpenMode 枚举变量定义，其取值如下：

打开模式 说明
QIODevice::NotOpen 没有打开设备
QIODevice::ReadOnly 以只读方式打开设备
QIODevice::WriteOnly 以只写方式打开设备
QIODevice::ReadWrite 以读写方式打开设备
QIODevice::Append 以追加方式打开设备，数据将写到文件末尾
QIODevice::Truncate 每次打开文件后重写文件内容，原内容将被删除
QIODevice::Text 在读文件时，行尾终止符会被转换为 '\n'；当写入文件时，行尾终止符会被转换为本地编码。如 Win32上为'\r\n'；
QIODevice::Unbuffered 无缓冲形式打开文件，绕过设备中的任何缓冲区
QIODevice::NewOnly 文件存在则打开失败，不存在则创建文件

示例1：读取文件内容

  1. 新建 Qt 项目，在 UI 文件中拖入一个 LineEdit，一个pushButton，一个 TextEdit。当点击按钮时，弹出窗口选择要读取的文件，并将读取到的内容在 TextEdit 中显示

  2. 在 "widget.cpp" 文件中实现对应功能

    cpp 复制代码 
    #include "widget.h"
#include "ui_widget.h"
#include <QFileDialog>
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    connect(ui->btn,&QPushButton::clicked,[=](){
        QString path = QFileDialog::getOpenFileName(this,"打开文件","C:\\Users\\Lenovo\\Desktop");
        ui->lineEdit->setText(path);
        QFile file(path); //path：代表文件路径this
        //打开文件
        file.open(QIODevice::ReadOnly); //以只读的方式打开文件
        QString str = file.readAll();
        ui->textEdit->setText(str);
        //关闭文件
        file.close();
    });
}

  3. 实现效果如下

示例2：写文件

在上述示例的基础上修改 "widget.cpp" 文件；

cpp 复制代码 
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    connect(ui->btn,&QPushButton::clicked,[=](){
        QString path = QFileDialog::getOpenFileName(this,"打开文件","C:\\Users\\Lenovo\\Desktop");
        ui->lineEdit->setText(path);
        QFile file(path); //path：代表文件路径
        //打开文件 进行写操作
        file.open(QIODevice::Append); //以追加的方式进行写
        file.write("【这是示例！！！】");
        //关闭文件
        file.close();
    });
}

实现效果如下：

2.4 文件和目录信息类

QFileInfo 是 Qt 提供的一个用于获取文件和目录信息的类，如获取文件名、文件大小、文件修改日期等。QFileInfo类中提供了很多的方法，常用的有：

方法 说明
isDir() 检查该文件是否是目录
isExecutable() 检查该文件是否是可执行文件
fileName() 获得文件名
completeBaseName() 获取完整的文件名
suffix() 获取文件后缀名
completeSuffix() 获取完整的文件后缀
size() 获取文件大小
isFile() 判断是否为文件
fileTime() 获取文件创建时间、修改时间、最近访问时间等

示例：

在 "widget.cpp" 文件中添加如下代码：

cpp 复制代码 
#include <QFileInfo>
#include <QFileDialog>
#include <QDebug>
#include <QDateTime>
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
	ui->setupUi(this);
	connect(ui->btn,&QPushButton::clicked,[=](){
        QString path = QFileDialog::getOpenFileName(this,"打开文件","C:\\Users\\Lenovo\\Desktop");
        //QFileInfo 文件信息类
        QFileInfo fileinfo(path);
        //文件名
        qDebug() << "文件名为：" << fileinfo.fileName().toUtf8().data();
        //文件后缀名
        qDebug() << "后缀名为：" << fileinfo.suffix().toUtf8().data();
        //文件大小
        qDebug() << "文件大小为：" << fileinfo.size();
        //文件路径
        qDebug() << "文件路径为：" << fileinfo.path().toUtf8().data();
        //判断是否为文件
        qDebug() << "是否为文件："<< fileinfo.isFile();
        //文件创建时间
        QDateTime time1 = fileinfo.fileTime(QFileDevice::FileBirthTime);
        qDebug() << "创建时间为：" << time1.toString("yyyy-MM-dd hh:mm:ss").toUtf8().data();
        //文件的最后修改日期
        QDateTime time2 = fileinfo.lastModified();
        qDebug() << "最后修改时间为："<< time2.toString("yyyy-MM-dd hh:mm:ss").toUtf8().data();
        //判断是否为文件夹
        qDebug() << "是否为目录：" << fileinfo.isDir();
	});
}

实现效果如下：

3. Qt 多线程

3.1 Qt 多线程概述

在 Qt 中，多线程的处理一般是通过 QThread类 来实现。

QThread 代表一个在应用程序中可以独立控制的线程，也可以和进程中的其他线程共享数据。

QThread 对象管理程序中的一个控制线程。

3.2 QThread 常用 API

API 说明
run() 线程的入口函数
start() 通过调用 run() 开始执行线程。操作系统将根据优先级参数调度线程。如果线程已经在运行，这个函数什么也不做。
currentThread() 返回一个指向管理当前执行线程的 QThread的指针。
isRunning() 如果线程正在运行则返回true;否则返回false。
sleep() / msleep() / usleep() 使线程休眠，单位为秒 / 毫秒 / 微秒
wait() 阻塞线程，直到满足以下任何一个条件: 与此 QThread 对象关联的线程已经完成执行(即当它从run()返回时)。如果线程已经完成，这个函数将返回 true。如果线程尚未启动，它也返回 true。 已经过了几毫秒。如果时间是 ULONG_MAX(默认值)，那么等待永远不会超时(线程必须从run()返回)。如果等待超时，此函数将返回 false。 这提供了与 POSIX pthread_join() 函数类似的功能。
terminate() 终止线程的执行。线程可以立即终止，也可以不立即终止，这取决于操作系统的调度策略。在terminate() 之后使用 QThread::wait() 来确保。
finished() 当线程结束时会发出该信号，可以通过该信号来实现线程的清理工作。

3.3 使用线程

创建线程的步骤：

  1. 自定义一个类，继承于 QThread，并且只有一个线程处理函数(和主线程不是同一个线程)，这个线程处理函数主要就是重写父类中的 run() 函数
  2. 线程处理函数里面写入需要执行的复杂数据处理
  3. 启动线程不能直接调用 run() 函数，需要使用对象来调用 start() 函数实现线程启动
  4. 线程处理函数执行结束后可以定义一个信号来告诉主线程
  5. 最后关闭线程

示例：

  1. 首先新建 Qt 项目，设计 UI界面如下

  2. 新建一个类，继承于 QThread类

  3. 代码如下

    cpp 复制代码 
    /*** timethread.h ***/
#ifndef TIMETHREAD_H
#define TIMETHREAD_H

#include <QThread> //添加头文件

class TimeThread : public QThread
{
    Q_OBJECT
public:
    TimeThread();
    void run(); //线程任务函数
signals:
    void sendTime(QString Time); //声明信号函数
};

#endif // TIMETHREAD_H

/*** widget.h ***/
#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <timethread.h> //添加头文件

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
	Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
private slots:
    void on_btn_clicked();
    void showTime(QString Time);
private:
    Ui::Widget *ui;
    TimeThread t; //定义线程对象
};

#endif // WIDGET_H

/*** timethread.cpp ***/
#include "timethread.h"
#include <QTime>
#include <QDebug>

TimeThread::TimeThread() {}
void TimeThread::run()
{
    while(1)
    {
        QString time = QTime::currentTime().toString("hh:mm:ss");
        qDebug() << time;
        emit sendTime(time); //发送信号
        sleep(1);
    }
}

/*** widget.cpp ***/
#include "widget.h"
#include "ui_widget.h"

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    connect(&t,&TimeThread::sendTime,this,&Widget::showTime);
}

Widget::~Widget()
{
	delete ui;
}

void Widget::on_btn_clicked()
{
	t.start(); //开启线程
}

void Widget::showTime(QString Time)
{
	ui->label->setText(Time);
}

  4. 执行效果

说明：

  1. 线程函数内部不允许操作 UI 图形界面，一般用数据处理
  2. connect() 函数第五个参数表示的为连接的方式，且只有在多线程的时候才意义

connect() 函数第五个参数为 Qt::ConnectionType，用于指定信号和槽的连接类型。同时影响信号的传递方式和槽函数的执行顺序。Qt::ConnectionType 提供了以下五种方式：

连接类型 说明
Qt::AutoConnection 在 Qt 中，会根据信号和槽函数所在的线程自动选择连接类型。如果信号和槽函数在同一线程中，那么使用 Qt:DirectConnection 类型；如果它们位于不同的线程中，那么使用Qt::QueuedConnection 类型。
Qt::DirectConnection 当信号发出时，槽函数会立即在同一线程中执行。这种连接类型适用于信号和槽函数在同一线程中的情况，可以实现直接的函数调用，但需要注意线程安全性。
Qt::QueuedConnection 当信号发出时，槽函数会被插入到接收对象所属的线程的事件队列中，等待下一次事件循环时执行。这种连接类型适用于信号和槽函数在不同线程中的情况，可以确保线程安全。
Qt::BlockingQueuedConnection 与 Qt:QueuedConnection 类似，但是发送信号的线程会被阻塞，直到槽函数执行完毕，这种连接类型适用于需要等待槽函数执行完毕再继续的场景，但需要注意可能引起线程死锁的风险。
Qt::UniqueConnection 这是一个标志，可以使用位或与上述任何一种连接类型组合使用。

3.4 线程安全

实现线程互斥和同步常用的类有：

  • 互斥锁：QMutex、QMutexLocker
  • 条件变量：QWaitCondition
  • 信号量：QSemaphore
  • 读写锁：QReadLocker、QWriteLocker、QReadWriteLock
3.4.1 互斥锁

互斥锁是一种保护和防止多个线程同时访问同一对象实例的方法，在 Qt 中，互斥锁主要是通过 QMutex 类来处理。

  • QMutex

    特点：QMutex 是 Qt 框架提供的互斥锁类，用于保护共享资源的访问，实现线程间的互斥操作。

    用途：在多线程环境下，通过互斥锁来控制对共享数据的访问，确保线程安全。

    cpp 复制代码 
    QMutex mutex;
mutex.lock(); //上锁
//访问共享资源
//...
mutex.unlock(); //解锁

  • QMutexLocker

    特点：QMutexLocker 是 QMutex 的辅助类，使用 RAII（Resource Acquisition Is Initialization）方式对互斥锁进行上锁和解锁操作。

    用途：简化对互斥锁的上锁和解锁操作，避免忘记解锁导致的死锁等问题。

    复制代码 
    QMutex mutex;
{
    QMutexLocker locker(&mutex); //在作用域内自动上锁
    //访问共享资源
    //...
} //在作用域结束时自动解锁

  • QReadWriteLocker、QReadLocker、QWriteLocker

    特点：

    QReadWriteLock 是读写锁类，用于控制读和写的并发访问。

    QReadLocker 用于读操作上锁，允许多个线程同时读取共享资源。

    QWriteLocker 用于写操作上锁，只允许一个线程写入共享资源。

    用途：在某些情况下，多个线程可以同时读取共享数据，但只有一个线程能够进行写操作。读写锁提供了更高效的并发访问方式。

    cpp 复制代码 
    QReadWriteLock rwLock;
//在读操作中使用读锁
{
    QReadLocker locker(&rwLock); //在作用域内自动上读锁
    //读取共享资源
    //...
} //在作用域结束时自动解读锁

//在写操作中使用写锁
{
    QWriteLocker locker(&rwLock); //在作用域内自动上写锁
    //修改共享资源
    //...
} //在作用域结束时自动解写锁

示例1：两个线程使用一把锁，操作一个数据，数据会被两个线程依次打印：0、1、2、3、4 ...

cpp 复制代码 
/*** myThread.h ***/
#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>
#include <QMutex>

class myThread : public QThread
{
	Q_OBJECT
public:
    explicit myThread(QObject *parent = nullptr);
    void run();
private:
    static QMutex mutex; //多个线程使用一把锁
    static int num; //多个线程访问一个数据
};

#endif // MYTHREAD_H

/*** myThread.cpp ***/
#include "mythread.h"
#include <QDebug>

QMutex myThread::mutex;
int myThread::num = 0;

myThread::myThread(QObject *parent) : QThread(parent) {}

void myThread::run()
{
    while(1)
    {
        this->mutex.lock(); //加锁
        qDebug() << "Current Thread: " << this << ", Value: " << this->num++;
        this->mutex.unlock(); //解锁
        QThread::sleep(1); //线程睡眠两秒
    }
}

/*** mainwindow.h ***/
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
private:
    Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H

/*** mainwindow.cpp ***/
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "mythread.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    myThread *t1 = new myThread(this);
    myThread *t2 = new myThread(this);
    t1->start();
    t2->start();
}

MainWindow::~MainWindow()
{
	delete ui;
}

执行效果

示例2：在上述示例的基础上使用 QMutexLocker 锁。

cpp 复制代码 
/*** myThread.cpp ***/
#include "mythread.h"
#include <QDebug>

QMutex myThread::mutex;
int myThread::num = 0;

myThread::myThread(QObject *parent) : QThread(parent) {}

void myThread::run()
{
    while (1)
    {
        //QMutexLocker:创建的时候加锁，当QMutexLocker局部销毁的时候解锁
        {
            QMutexLocker lock(&this->mutex);
            qDebug() << "Current Thread: " << this << ", Value: " << this-
            >num++;
        }
        QThread::sleep(1);// 线程睡眠两秒
    }
}
3.4.2 条件变量

在多线程编程中，假设除了等待操作系统正在执行的线程之外，某个线程还必须等待某些条件满足才能执行，这时就会出现问题。这种情况下，线程会很自然地使用锁的机制来阻塞其他线程，因为这只是线程的轮流使用，并且该线程等待某些特定条件，人们会认为需要等待条件的线程，在释放互斥锁或读写锁之后进入了睡眠状态，这样其他线程就可以继续运行。当条件满足时，等待条件的线程将被另一个线程唤醒。

在 Qt 中，专门提供了 QWaitCondition类 来解决像上述这样的问题。

特点：QWaitCondition 是 Qt 框架提供的条件变量类，用于线程之间的消息通信和同步。

用途：在某个条件满足时等待或唤醒线程，用于线程的同步和协调。

cpp 复制代码 
QMutex mutex;
QWaitCondition condition;

//在等待线程中
mutex.lock();

//检查条件是否满足，若不满足则等待
while (!conditionFullfilled())
{
	condition.wait(&mutex); //等待条件满足并释放锁
}

//条件满足后继续执行
//...

mutex.unlock();

//在改变条件的线程中
mutex.lock();

//改变条件
changeCondition();
condition.wakeAll(); //唤醒等待的线程

mutex.unlock();
3.4.3 信号量

有时在多线程编程中，需要确保多个线程可以相应的访问一个数量有限的相同资源。例如，运行程序的设备可能是非常有限的内存，因此我们更希望需要大量内存的线程将这一事实考虑在内，并根据可用的内存数量进行相关操作，多线程编程中类似问题通常用信号量来处理。信号量类似于增强的互斥锁，不仅能完成上锁和解锁操作，而且可以跟踪可用资源的数量。

特点：QSemaphore 是 Qt 框架提供的计数信号量类，用于控制同时访问共享资源的线程数量。

用途：限制并发线程数量，用于解决一些资源有限的问题。

cpp 复制代码 
QSemaphore semaphore(2); //同时允许两个线程访问共享资源
//在需要访问共享资源的线程中

semaphore.acquire(); //尝试获取信号量，若已满则阻塞
//访问共享资源
//...

semaphore.release(); //释放信号量
//在另一个线程中进行类似操作

4. Qt网络

和多线程类似, Qt 为了支持跨平台, 对网络编程的 API 也进行了重新封装.

下面重点讲解 Qt 的网络相关的 API 的使用，对于网络相关的概念与原理，可以参考之前写过的 Linux 网络相关的内容（Linux网络编程学习_czxyvX的博客-CSDN博客）。

在进行网络编程之前, 需要在项目中的.pro 文件中添加 network 模块. 添加之后要手动编译一下项目, 使 Qt Creator 能够加载对应模块的头文件.

4.1 UDP Socket

主要的类有两个. QUdpSocket 和 QNetworkDatagram

QUdpSocket 表示一个 UDP 的 socket 文件.

名称 类型 说明 对标原生API
bind(const QHostAddress&, quint16) 方法 绑定指定的端口号. bind
receiveDatagram() 方法 返回 QNetworkDatagram . 读取一个 UDP 数据报. recvfrom
writeDatagram(const QNetworkDatagram&) 方法 发送一个 UDP 数据报. sendto
readyRead 信号 在收到数据并准备就绪后触发. 无 (类似于 IO 多路复用的通知机制)

QNetworkDatagram 表示一个 UDP 数据报.

名称 类型 说明 对标原生 API
QNetworkDatagram(const QByteArray&, const QHostAddress& , quint16 ) 构造函数 通过 QByteArray , 目标 IP 地址, 目标端口号 构造一个 UDP 数据报. 通常用于发送数据时. 无
data() 方法 获取数据报内部持有的数据. 返回 QByteArray 无
senderAddress() 方法 获取数据报中包含的对端的 IP 地址. 无, recvfrom 包含了该功能.
senderPort() 方法 获取数据报中包含的对端的端口号. 无, recvfrom 包含了该功能.
4.1.2 回显服务器

  1. 创建界面, 包含一个 QListWidget 用来显示消息.

  2. 创建 QUdpSocket 成员

    修改 widget.h

    cpp 复制代码 
    class Widget : public QWidget
{
	Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
private:
    Ui::Widget *ui;
    QUdpSocket* socket;
};

    修改 widget.cpp, 完成 socket 后续的初始化

    • 一般来说, 要先连接信号槽, 再绑定端口.
    • 如果顺序反过来, 可能会出现端口绑定好了之后, 请求就过来了. 此时还没来得及连接信号槽. 那么这个请求就有可能错过了.
    cpp 复制代码 
    Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    
    // 1. 设置窗口标题
    this->setWindowTitle("服务器");
    
    // 2. 实例化 socket
    socket = new QUdpSocket(this);
    
    // 3. 连接信号槽, 处理收到的请求
    connect(socket, &QUdpSocket::readyRead, this, &Widget::processRequest);
    
    // 4. 绑定端口
    bool ret = socket->bind(QHostAddress::Any, 9090);
    if (!ret) {
        QMessageBox::critical(nullptr, "服务器启动出错", socket->errorString());
        return;
    }
}

  3. 实现 processRequest , 完成处理请求的过程

    • 读取请求并解析
    • 根据请求计算响应
    • 把响应写回到客户端
    cpp 复制代码 
    void Widget::processRequest()
{
    // 1. 读取请求
    const QNetworkDatagram& requestDatagram = socket->receiveDatagram();
    QString request = requestDatagram.data();
    
    // 2. 根据请求计算响应
    const QString& response = process(request);
    
    // 3. 把响应写回到客户端
    QNetworkDatagram responseDatagram(response.toUtf8(), requestDatagram.senderAddress(), requestDatagram.senderPort());
    socket->writeDatagram(responseDatagram);
    
    // 显示打印日志
    QString log = "[" + requestDatagram.senderAddress().toString() + ":" + QString::number(requestDatagram.senderPort()) + "] req: " + request + ", resp: " + response;
    ui->listWidget->addItem(log);
}

  4. 实现 process 函数

    由于我们此处是实现回显服务器. 所以 process 方法中并没有包含实质性的内容.

    cpp 复制代码 
    QString Widget::process(const QString& request)
{
	return request;
}

此时, 服务器程序编写完毕.

但是直接运行还看不出效果. 还需要搭配客户端来使用.

4.1.3 回显客户端

  1. 创建界面. 包含一个 QLineEdit , QPushButton , QListWidget

    • 先使用水平布局把 QLineEdit 和 QPushButton 放好, 并设置这两个控件的垂直方向的 sizePolicy 为 Expanding
    • 再使用垂直布局把 QListWidget 和上面的水平布局放好.
    • 设置垂直布局的 layoutStretch 为 5, 1 (当然这个尺寸比例根据个人喜好微调).

  2. 在 widget.cpp 中, 先创建两个全局常量, 表示服务器的 IP 和 端口

    cpp 复制代码 
    // 提前定义好服务器的 IP 和 端口
const QString& SERVER_IP = "127.0.0.1";
const quint16 SERVER_PORT = 9090;

  3. 创建 QUdpSocket 成员

    修改 widget.h, 定义成员

    cpp 复制代码 
    class Widget : public QWidget
{
	Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
private:
    Ui::Widget *ui;
    // 创建 socket 成员
    QUdpSocket* socket;
};

    修改 widget.cpp, 初始化 socket

    cpp 复制代码 
    Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    // 1. 设置窗口名字
    this->setWindowTitle("客户端");
    // 2. 实例化 socket
    socket = new QUdpSocket(this);
}

  4. 给发送按钮 slot 函数, 实现发送请求

    cpp 复制代码 
    void Widget::on_pushButton_clicked()
{
    // 1. 获取到输入框的内容
    const QString& text = ui->lineEdit->text();
    // 2. 构造请求数据
    QNetworkDatagram requestDatagram(text.toUtf8(), QHostAddress(SERVER_IP), SERVER_PORT);
    // 3. 发送请求
    socket->writeDatagram(requestDatagram);
    // 4. 消息添加到列表框中
    ui->listWidget->addItem("客户端说: " + text);
    // 5. 清空输入框
    ui->lineEdit->setText("");
}

  5. 再次修改 Widget 的构造函数, 通过信号槽, 来处理服务器的响应

    cpp 复制代码 
    connect(socket, &QUdpSocket::readyRead, this, [=]() {
    const QNetworkDatagram responseDatagram = socket->receiveDatagram();
    QString response = responseDatagram.data();
    ui->listWidget->addItem(QString("服务器说: ") + response);
});

  6. 最终执行效果

4.2 TCP Socket

4.2.1 核心 API 概览

核心类是两个: QTcpServer 和 QTcpSocket

QTcpServer 用于监听端口, 和获取客户端连接

名称 类型 说明 对标原生 API
listen(const QHostAddress&, quint16 port) 方法 绑定指定的地址和端口号, 并开始监听. bind 和 listen
nextPendingConnection() 方法 从系统中获取到一个已经建立好的tcp 连接. 返回一个 QTcpSocket , 表示这个客户端的连接. 通过这个 socket 对象完成和客户端之间的通信. accept
newConnection 信号 有新的客户端建立连接好之后触发. 无 (但是类似于 IO 多路复用中的通知机制)

QTcpSocket 用户客户端和服务器之间的数据交互

名称 类型 说明 对标原生 API
readAll() 方法 读取当前接收缓冲区中的所有数据. 返回 QByteArray 对象. read
write(const QByteArray& ) 方法 把数据写入 socket 中. write
deleteLater 方法 暂时把 socket 对象标记为无效. Qt会在下个事件循环中析构释放该对象. 无 (但是类似于 "半自动化的垃圾回收")
readyRead 信号 有数据到达并准备就绪时触发. 无 (但是类似于 IO 多路复用中的通知机制)
disconnected 信号 连接断开时触发. 无 (但是类似于 IO 多路复用中的通知机制)

QByteArray 用于表示一个字节数组. 可以很方便的和 QString 进行相互转换.

  • 使用 QString 的构造函数即可把 QByteArray 转成 QString.
  • 使用 QString 的 toUtf8 函数即可把 QString 转成 QByteArray.
4.2.2 回显服务器

  1. 创建界面. 包含一个 QListWidget , 用于显示收到的数据.

  2. 创建 QTcpServer 并初始化

    修改 widget.h, 添加 QTcpServer 指针成员.

    cpp 复制代码 
    class Widget : public QWidget
{
	Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
private:
    Ui::Widget *ui;
    // 创建 QTcpServer
    QTcpServer* tcpServer;
};

    修改 widget.cpp, 实例化 QTcpServer 并进行后续初始化操作.

    • 设置窗口标题
    • 实例化 TCP server. (父元素设为当前控件, 会在父元素销毁时被一起销毁).
    • 通过信号槽, 处理客户端建立的新连接.
    • 监听端口
    cpp 复制代码 
    Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    // 1. 设置窗口标题
    this->setWindowTitle("服务器");
    // 2. 实例化 TCP server
    tcpServer = new QTcpServer(this);
    // 3. 通过信号槽, 处理客户端建立的新连接.
    connect(tcpServer, &QTcpServer::newConnection, this, &Widget::processConnection);
    // 4. 监听端口
    bool ret = tcpServer->listen(QHostAddress::Any, 9090);
    if (!ret) {
        QMessageBox::critical(nullptr, "服务器启动失败!", tcpServer->errorString());
        exit(1);
    }
}

  3. 继续修改 widget.cpp, 实现处理连接的具体方法 processConnection

    • 获取到新的连接对应的 socket.
    • 通过信号槽, 处理收到请求的情况
    • 通过信号槽, 处理断开连接的情况
    cpp 复制代码 
    void Widget::processConnection()
{
    // 1. 获取到新的连接对应的 socket.
    QTcpSocket* clientSocket = tcpServer->nextPendingConnection();
    QString log = QString("[") + clientSocket->peerAddress().toString() + ":" + QString::number(clientSocket->peerPort()) + "] 客户端上线!";
    ui->listWidget->addItem(log);
    // 2. 通过信号槽, 处理收到请求的情况
    connect(clientSocket, &QTcpSocket::readyRead, this, [=](){
        // a) 读取请求
        QString request = clientSocket->readAll();
        // b) 根据请求处理响应
        const QString& response = process(request);
        // c) 把响应写回客户端
        clientSocket->write(response.toUtf8());
        QString log = QString("[") + clientSocket->peerAddress().toString() + ":" + QString::number(clientSocket->peerPort()) + "] req: " + request + ", resp: " + response;
        ui->listWidget->addItem(log);
    });
    // 3. 通过信号槽, 处理断开连接的情况
    connect(clientSocket, &QTcpSocket::disconnected, this, [=]() {
        QString log = QString("[") + clientSocket->peerAddress().toString() + ":" + QString::number(clientSocket->peerPort()) + "] 客户端下线!";
        ui->listWidget->addItem(log);
        // 删除 clientSocket
        clientSocket->deleteLater();
    });
}

  4. 实现 process 方法, 实现根据请求处理响应.

    由于我们此处是实现回显服务器. 所以 process 方法中并没有包含实质性的内容.

    cpp 复制代码 
    QString Widget::process(const QString &request)
{
	return request;
}

    此时, 服务器程序编写完毕.

    但是直接运行还看不出效果. 还需要搭配客户端来使用.

4.2.3 回显客户端

  1. 创建界面. 包含一个 QLineEdit , QPushButton , QListWidget

    • 先使用水平布局把 QLineEdit 和 QPushButton 放好, 并设置这两个控件的垂直方向的 sizePolicy 为 Expanding
    • 再使用垂直布局把 QListWidget 和上面的水平布局放好.
    • 设置垂直布局的 layoutStretch 为 5, 1 (当然这个尺寸比例根据个人喜好微调).

  2. 创建 QTcpSocket 并实例化

    修改 widget.h, 创建成员.

    cpp 复制代码 
    class Widget : public QWidget
{
	Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
private:
    Ui::Widget *ui;
    // 新增 QTcpSocket
    QTcpSocket* socket;
};

    修改 widget.cpp, 对 QTcpSocket 进行实例化.

    • 设置窗口标题
    • 实例化 socket 对象 (父元素设为当前控件, 会在父元素销毁时被一起销毁).
    • 和服务器建立连接.
    • 等待并确认连接是否出错.
    cpp 复制代码 
    Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    // 1. 设置窗口标题.
    this->setWindowTitle("客户端");
    // 2. 实例化 socket 对象.
    socket = new QTcpSocket(this);
    // 3. 和服务器建立连接.
    socket->connectToHost("127.0.0.1", 9090);
    // 4. 等待并确认连接是否出错.
    if (!socket->waitForConnected()) {
        QMessageBox::critical(nullptr, "连接服务器出错!", socket->errorString());
        exit(1);
    }
}

  3. 修改 widget.cpp, 给按钮增加点击的 slot 函数, 实现发送请求给服务器.

    cpp 复制代码 
    void Widget::on_pushButton_clicked()
{
    // 获取输入框的内容
    const QString& text = ui->lineEdit->text();
    // 清空输入框内容
    ui->lineEdit->setText("");
    // 把消息显示到界面上
    ui->listWidget->addItem(QString("客户端说: ") + text);
    // 发送消息给服务器
    socket->write(text.toUtf8());
}

  4. 修改 widget.cpp 中的 Widget 构造函数, 通过信号槽, 处理收到的服务器的响应.

    cpp 复制代码 
    // 处理服务器返回的响应.
connect(socket, &QTcpSocket::readyRead, this, [=]() {
    QString response = socket->readAll();
    qDebug() << response;
    ui->listWidget->addItem(QString("服务器说: ") + response);
});

  5. 最终执行结果

4.3 HTTP Client

进行 Qt 开发时, 和服务器之间的通信很多时候也会用到 HTTP 协议.

  • 通过 HTTP 从服务器获取数据.
  • 通过 HTTP 向服务器提交数据.
4.3.1 核心 API

关键类主要是三个. QNetworkAccessManager , QNetworkRequest , QNetworkReply .

QNetworkAccessManager 提供了 HTTP 的核心操作.

方法 说明
get(const QNetworkRequest& ) 发起一个 HTTP GET 请求. 返回 QNetworkReply 对象.
post(const QNetworkRequest& , const QByteArray& ) 发起一个 HTTP POST 请求. 返回 QNetworkReply 对象.

QNetworkRequest 表示一个 HTTP 请求(不含 body).

如果需要发送一个带有 body 的请求(比如 post), 会在 QNetworkAccessManager 的 post 方法中通过单独的参数来传入 body.

方法 说明
QNetworkRequest(const QUrl& ) 通过 URL 构造一个 HTTP 请求.
setHeader(QNetworkRequest::KnownHeaders header, const QVariant &value) 设置请求头.

其中的 QNetworkRequest::KnownHeaders 是一个枚举类型, 常用取值如下.

取值 说明
ContentTypeHeader 描述 body 的类型.
ContentLengthHeader 描述 body 的长度.
LocationHeader 用于重定向报文中指定重定向地址. (响应中使用, 请求用不到)
CookieHeader 设置 cookie
UserAgentHeader 设置 User-Agent

QNetworkReply 表示一个 HTTP 响应. 这个类同时也是 QIODevice 的子类.

方法 说明
error() 获取出错状态.
errorString() 获取出错原因的文本.
readAll() 读取响应 body.
header(QNetworkRequest::KnownHeaders header) 读取响应指定 header 的值.

此外, QNetworkReply 还有一个重要的信号 finished 会在客户端收到完整的响应数据之后触发.

4.3.2 代码示例

给服务器发送一个GET请求

  1. 创建界面. 包含一个 QLineEdit , QPushButton, QPlainTextEdit

    此处建议使用 QPlainTextEdit 而不是 QTextEdit . 主要因为 QTextEdit 要进行富文本解析, 如果得到的 HTTP 响应体积很大, 就会导致界面渲染缓慢甚至被卡住.

  2. 修改 widget.h, 创建 QNetworkAccessManager 属性

    cpp 复制代码 
    class Widget : public QWidget
{
	Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
private slots:
    void on_pushButton_clicked();
private:
    Ui::Widget *ui;
    // 新增属性
    QNetworkAccessManager* manager;
};

  3. 修改 widget.cpp, 创建实例

    cpp 复制代码 
    Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    // 实例化属性
    manager = new QNetworkAccessManager(this);
}

  4. 编写按钮的 slot 函数, 实现发送 HTTP 请求功能.

cpp 复制代码 
void Widget::on_pushButton_clicked()
{
  // 1. 获取到输入框中的 URL, 构造 QUrl 对象
  QUrl url(ui->lineEdit->text());
  // 2. 构造 HTTP 请求对象
  QNetworkRequest request(url);
  // 3. 发送 GET 请求
  QNetworkReply* response = manager->get(request);
  // 4. 通过信号槽来处理响应
  connect(response, &QNetworkReply::finished, this, [=]() {
      if (response->error() == QNetworkReply::NoError) {
          // 响应正确
          QString html(response->readAll());
          ui->plainTextEdit->setPlainText(html);
          // qDebug() << html;
      } else {
          // 响应出错
          ui->plainTextEdit->setPlainText(response->errorString());
      }
      response->deleteLater();
  });
}

  1. 执行程序, 观察效果

发送 POST 请求代码也是类似. 使用 manager->post() 即可. 此处不再演示.

4.4 其他模块

Qt 中还提供了 FTP, DNS, SSL 等网络相关的组件工具. 此处不再一一展开介绍. 有需要的可以自行翻阅官方文档学习相关 API 的使用.

5. Qt 音视频

5.1 Qt 音频

在 Qt 中，音频主要是通过 QSound 类来实现。但是需要注意的是 QSound 类只支持播放 wav 格式的音频文件。也就是说如果想要添加音频效果，那么首先需要将 非wav格式 的音频文件转换为 wav 格式。

通过帮助手册查看 QSound 类如下：

注意：使用 QSound 类时，需要添加模块：multimedia.

5.1.1 核心API概览
API 说明
play() 开始或继续播放当前源
5.1.2 示例
cpp 复制代码 
/*** SoundTest.pro ***/
QT += core gui multimedia //添加音频模块
    
/*** widget.cpp ***/
#include "widget.h"
#include "ui_widget.h"
#include <QSound> //添加音频头文件
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    //实例化对象
    QSound *sound = new QSound(":/1.wav",this);
    connect(ui->btn,&QPushButton::clicked,[=](){
    	sound->play(); //播放
    });
}
Widget::~Widget()
{
	delete ui;
}

5.2 Qt 视频

在 Qt 中，视频播放的功能主要是通过 QMediaPlayer类 和 QVideoWidget类 来实现。在使用这两个类时要添加对应的模块 multimedia 和 multimediawidgets 。

5.2.1 核心API概览
API 说明
setMedia() 设置当前媒体源。
setVideoOutput() 将QVideoWidget视频输出附加到媒体播放器。 如果媒体播放器已经附加了视频输出，将更换一个新的。
5.2.2 示例
cpp 复制代码 
/*** Video.pro ***/
//添加视频模块
QT += multimedia
QT += multimediawidgets

/*** widget.h ***/
#ifndef WIDGET_H
#define WIDGET_H
#include <QWidget>
#include <QHBoxLayout> //水平布局
#include <QVBoxLayout> //垂直布局
#include <QVideoWidget> //显示视频
#include <QMediaPlayer> //播放声音
#include <QPushButton> //按钮
#include <QStyle> //设置图标
#include <QFileDialog> //选择文件/文件夹

class Widget : public QWidget
{
	Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
public slots:
	void chooseVideo();
private:
    QMediaPlayer *mediaPlayer;
    QVideoWidget *videoWidget;
    QVBoxLayout *vbox;
    //创建两个按钮：选择视频按钮和开播放按钮
    QPushButton *chooseBtn,*playBtn;
};

#endif // WIDGET_H

/*** widget.cpp ***/
#include "widget.h"
#include <QMediaPlayer>
#include <QSlider>

Widget::Widget(QWidget *parent)
	: QWidget(parent)
{
    //对象实例化
    mediaPlayer = new QMediaPlayer(this);
    videoWidget = new QVideoWidget(this);
    //设置播放画面的窗口
    videoWidget->setMinimumSize(600,600);
    //实例化窗口布局---垂直布局
    this->vbox = new QVBoxLayout(this);
    this->setLayout(this->vbox);
    //实例化选择视频按钮
    chooseBtn = new QPushButton("选择视频",this);
    //实例化播放按钮
    playBtn = new QPushButton(this);
    //设置图标代替文件
    playBtn->setIcon(this->style()->standardIcon(QStyle::SP_MediaPlay));
    //实例化一个水平布局，将以上控件放入水平布局中
    QHBoxLayout *hbox = new QHBoxLayout;
    //添加控件
    hbox->addWidget(chooseBtn);
    hbox->addWidget(playBtn);
    //将播放窗口和水平布局都添加到垂直布局中
    vbox->addWidget(videoWidget);
    //布局中添加布局
    vbox->addLayout(hbox);
    //将选择视频对应的按钮和槽函数进行关联
    connect(chooseBtn,&QPushButton::clicked,this,&Widget::chooseVideo);
}
void Widget::chooseVideo()
{
    //选择视频，返回一个播放视频的名字
    QString name = QFileDialog::getSaveFileName(this,"选择视
    频",".","WMV(*.wmv)");
    //设置媒体声音
    mediaPlayer->setMedia(QUrl(name));
    //输出视频画面
    mediaPlayer->setVideoOutput(videoWidget);
    //播放
    mediaPlayer->play();
}
Widget::~Widget() {}
相关推荐
茉莉玫瑰花茶1 小时前
C++ 17 详细特性解析（6）
开发语言·c++
froginwe111 小时前
Bootstrap 标签页
开发语言
小短腿的代码世界1 小时前
Qt libQGLViewer 深度解析：高性能OpenGL 3D交互查看器的架构设计与性能优化
qt·3d·交互
东方.既白1 小时前
QML与C++炫酷界面交互DEMO
开发语言·c++·交互
小短腿的代码世界1 小时前
Qt SSH2 深度解析：安全远程通信架构与源码级实现
qt·安全·架构
脆皮炸鸡7551 小时前
大山之二：文件系统（Ext系列）
linux·开发语言·经验分享·学习方法
少司府1 小时前
C++基础入门：vector深度解析（七千字深度剖析）
c语言·开发语言·数据结构·c++·容器·vector·顺序表
yqcoder1 小时前
突破性能瓶颈：深入理解 JavaScript TypedArray
java·开发语言·javascript
yqcoder1 小时前
JS 中的“空”之双雄：null vs undefined
开发语言·前端·javascript
热门推荐
01GitHub 镜像站点02Codex 接入 DeepSeek API 完整配置文档03【AI】2026 年具身智能模型和世界模型总结04零基础教你claude code 接入 deepseek V405CC-Switch & Claude 基于 Linux 服务器安装使用指南06Windows端Codex接入第三方模型（DeekSeek，BaiLian)07Cursor 接入 DeepSeek‑V4‑Pro 完整指南（2026 实测）08codex app每次打开重连5次Reconnecting问题解决09要裂开了！ChatGPT要手机号验证了？注册Codex要求验证电话号码怎么办？2026年登陆Codex要手机号验证的解决办法10裂开！ChatGPT 居然开始要手机号验证，附详细解决方法