QT的学习第三部分

一、QT的串口编程

1、串口通信的概念

串口通信：一种按位（bit）逐字节顺序传输数据的串行通信方式，通过 TX（发送）和 RX（接收） 两根数据线实现设备间的双向（全双工）数据传输，常用于工业控制、嵌入式设备等近距离低速通信场景。

2、串口设备的接线图

3、串口编程

（1）前置知识点

Qt串口模块提供了两个类：
    1、QSerialPort提供访问串口的函数
    2、QSerialPortInfo提供有关现有串行端口的信息。
如果要在你的项目中使用QSerialPort和QSerialPortInfo要包含下面两个头文件：
    #include <QSerialPort>
    #include <QSerialPortInfo>
编译的时候需要连接串口模块，可以在qmake.pro（项目工程文件中添加模块）
    QT += serialport

（2）串口编程中的QSerialPort

串口编程常用接口如下所示：
构造函数：
    QSerialPort(const QSerialPortInfo &serialPortInfo, QObject *parent = nullptr)
    QSerialPort(const QString &name, QObject *parent = nullptr)
    QSerialPort(QObject *parent = nullptr)
串口操作函数：
    1、open(QIODevice::OpenMode mode): 打开串口并指定打开模式。
    2、close(): 关闭串口。
    3、setBaudRate(qint32 baudRate, QSerialPort::Directions directions =             QSerialPort::AllDirections): 设置波特率。
    4、setDataBits(QSerialPort::DataBits dataBits): 设置数据位。
    5、setParity(QSerialPort::Parity parity): 设置校验位。
    6、setStopBits(QSerialPort::StopBits stopBits): 设置停止位。
    7、setFlowControl(QSerialPort::FlowControl flowControl): 设置流控制。
    8、clearError(): 清除错误状态。
    9、clear(): 清空输入输出缓冲区。
    10、read(char *data, qint64 maxSize): 从串口读取数据。
    11、write(const char *data, qint64 maxSize): 向串口写入数据。
    12、waitForReadyRead(int msecs): 等待串口有数据可读。

（3）具体的实例代码

①开发板下位机

widget.h：

#ifndef WIDGET_H
#define WIDGET_H
// ==================== 包含必要的头文件 ====================
#include <QWidget>          // Qt窗口基类
#include <QString>          // Qt字符串类
#include <QObject>          // Qt对象基类（信号槽机制）
#include <QDebug>           // Qt调试输出（qDebug()）
#include <QSerialPort>      // 串口通信类
#include <QSerialPortInfo>  // 串口信息类（获取可用串口列表）
#include <QLabel>           // 标签控件
#include <QComboBox>        // 下拉列表控件
#include <QPushButton>      // 按钮控件
#include <QTextEdit>        // 多行文本编辑框控件
#include <QFont>            // 字体类
// ==================== Qt命名空间宏 ====================
QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }  // 前向声明UI类（由Qt Designer生成）
QT_END_NAMESPACE
// ==================== Widget类定义 ====================
class Widget : public QWidget
{
    Q_OBJECT  // Qt元对象宏（支持信号槽）
public:
    Widget(QWidget *parent = nullptr);  // 构造函数
    ~Widget();                          // 析构函数
    void Serila_Init();                // 串口初始化函数
public slots:                          // 公共槽函数（响应信号）
    void open_serial();                // 打开串口的槽函数
    void close_serial();               // 关闭串口的槽函数
    void recv_serial_msg();            // 接收串口消息的槽函数
private:
    // ===== UI对象 =====
    Ui::Widget  * ui;                  // UI界面指针（由uic生成）
    // ===== 串口对象 =====
    QSerialPort * serial;              // 串口通信对象
    // ===== 字体对象 =====
    QFont       * font;                // 字体样式对象
    // ===== 串口信息列表 =====
    QList<QSerialPortInfo> * serial_inf;  // 存储可用串口信息的列表
    // ===== 端口信息文本框 =====
    QTextEdit   * com_inf;             // 显示串口参数信息的文本框
    // ===== 端口标签 =====
    QLabel      * com_port;            // "端口:" 标签
    // ===== 端口下拉列表 =====
    QComboBox   * com_port_cbox;       // 显示可用串口的下拉列表
    // ===== 选中的端口名 =====
    QString     * com_select_ack;      // 存储用户选中的端口名称
    // ===== 打开串口按钮 =====
    QPushButton * open_serial_btn;     // "打开串口"按钮
    // ===== 接收消息文本框 =====
    QTextEdit   * recv_msg_Text;       // 显示接收到的串口数据的文本框
};
#endif // WIDGET_H

widget.cpp

#include "widget.h"      // 包含头文件
#include "ui_widget.h"   // 包含自动生成的UI头文件
// ==================== 构造函数 ====================
Widget::Widget(QWidget *parent)
    : QWidget(parent)    // 调用父类构造函数
    , ui(new Ui::Widget) // 创建UI对象
{
    ui->setupUi(this);   // 设置UI界面（虽然本代码未使用UI文件）
    this->Serila_Init(); // 调用串口初始化函数
}
// ==================== 析构函数 ====================
Widget::~Widget()
{
    // 添加串口关闭
    if (this->serial && this->serial->isOpen())
        this->serial->close();
    delete this->serial;
    delete this->serial_inf;
    delete this->font;
    delete this->com_select_ack;
    delete ui;  // 释放UI对象内存
}
// ==================== 串口初始化函数 ====================
void Widget::Serila_Init()
{
    // ----- 设置窗口大小 -----
    this->setFixedWidth(800);   // 固定窗口宽度800像素
    this->setFixedHeight(480);  // 固定窗口高度480像素
    // ----- 创建串口信息列表对象 -----
    this->serial_inf = new QList<QSerialPortInfo>;
    // ----- 获取当前系统所有可用串口 -----
    // 使用解引用操作符(*)获取列表对象，然后赋值
    (*this->serial_inf) = QSerialPortInfo::availablePorts();
    // ----- 创建串口对象 -----
    this->serial = new QSerialPort;
    // ----- 设置串口参数（在打开前配置） -----
    this->serial->setBaudRate(QSerialPort::Baud115200);  // 波特率：115200
    this->serial->setDataBits(QSerialPort::Data8);       // 数据位：8位
    this->serial->setParity(QSerialPort::NoParity);      // 奇偶校验：无
    this->serial->setStopBits(QSerialPort::OneStop);     // 停止位：1位
    // ----- 创建字体对象 -----
    this->font = new QFont("Arial", 15);  // 字体：Arial，字号：15
    // ----- 创建"端口："标签 -----
    this->com_port = new QLabel("端口:", this);  // 显示文本"端口:"
    this->com_port->setFont(*this->font);        // 设置字体
    // 设置标签大小和位置
    this->com_port->setFixedWidth(60);   // 宽度60像素
    this->com_port->setFixedHeight(30);  // 高度30像素
    this->com_port->move(10, 10);        // 移动到坐标(10, 10)
    // ----- 创建端口下拉列表 -----
    this->com_port_cbox = new QComboBox(this);
    // 修改字体大小为10
    this->font->setPointSize(10);
    this->com_port_cbox->setFont(*this->font);
    // 遍历串口列表，将端口名称添加到下拉列表
    for(int com_num = 0; com_num < this->serial_inf->size(); com_num++)
    {
        // 获取第com_num个串口信息，取出端口名称添加到下拉列表
        this->com_port_cbox->addItem(this->serial_inf->at(com_num).portName());
    }
    // 设置下拉列表大小和位置
    this->com_port_cbox->setFixedWidth(110);   // 宽度110像素
    this->com_port_cbox->setFixedHeight(30);   // 高度30像素
    this->com_port_cbox->move(80, 10);         // 移动到坐标(80, 10)
    // ----- 创建存储选中端口的字符串对象 -----
    this->com_select_ack = new QString;
    // ----- 创建"打开串口"按钮 -----
    this->font->setPointSize(15);  // 字体大小改为15
    this->open_serial_btn = new QPushButton("打开串口", this);
    this->open_serial_btn->setFont(*this->font);
    this->open_serial_btn->move(30, 70);  // 移动到坐标(30, 70)
    // ----- 创建串口信息文本框（显示参数） -----
    this->com_inf = new QTextEdit(this);
    // 添加串口参数信息
    this->com_inf->append("波特率：115200");
    this->com_inf->append("数据位：8");
    this->com_inf->append("奇偶检验：无");
    this->com_inf->append("停止位：1");
    // 设置字体大小12
    this->font->setPointSize(12);
    this->com_inf->setFont(*this->font);
    // 设置文本框大小和位置
    this->com_inf->setFixedWidth(180);   // 宽度180像素
    this->com_inf->setFixedHeight(180);  // 高度180像素
    this->com_inf->move(10, 150);        // 移动到坐标(10, 150)
    // ----- 创建接收消息显示文本框 -----
    this->recv_msg_Text = new QTextEdit(this);
    this->recv_msg_Text->setFont(*this->font);  // 设置窗口字体
    // 设置接收消息文本框大小和位置
    this->recv_msg_Text->setFixedWidth(500);   // 宽度500像素
    this->recv_msg_Text->setFixedHeight(320);  // 高度320像素
    this->recv_msg_Text->move(250, 10);        // 移动到坐标(250, 10)
    // ===== 连接信号与槽 =====
    // 1. 点击"打开串口"按钮 → 执行open_serial()槽函数
    QObject::connect(this->open_serial_btn, &QPushButton::clicked,
                     this, &Widget::open_serial);
    // 2. 串口有数据可读 → 执行recv_serial_msg()槽函数
    QObject::connect(this->serial, &QSerialPort::readyRead,
                     this, &Widget::recv_serial_msg);
    return;  // 函数结束（可省略）
}
// ==================== 打开串口槽函数 ====================
void Widget::open_serial()
{
    // 判空：下拉列表是否为空
    if (this->com_port_cbox->count() == 0) 
    {
        qDebug() << "没有可用的串口";
        return;
    }
    // 判空：是否选中有效项
    if (this->com_port_cbox->currentIndex() == -1) 
    {
        qDebug() << "未选择串口";
        return;
    }
    // ----- 获取用户选中的端口名 -----
    // currentIndex()：获取当前选中项的索引
    // itemText()：根据索引获取显示的文本
    *this->com_select_ack = this->com_port_cbox->itemText(
        this->com_port_cbox->currentIndex()
    );
    // ----- 设置串口要打开的端口号 -----
    this->serial->setPortName(*this->com_select_ack);
    // ----- 尝试打开串口（读写模式） -----
    if(this->serial->open(QIODevice::ReadWrite) == false)
    {
        // 打开失败，输出错误信息
        qDebug() << "error";
        return;  // 退出函数
    }
    else
    {
        // 打开成功，输出成功信息
        qDebug() << *this->com_select_ack << "open success";
    }
}
// ==================== 关闭串口槽函数 ====================
void Widget::close_serial()
{
    if (this->serial && this->serial->isOpen())
    {
        this->serial->close();
        qDebug() << "串口已关闭";
    }
}
// ==================== 接收串口消息槽函数 ====================
void Widget::recv_serial_msg()
{
    // 调试输出：表示收到了消息
    qDebug() << "have a msg!!";
    // ----- 读取串口所有数据 -----
    QByteArray data = this->serial->readAll();
    // ----- 将数据显示到文本框 -----
    this->recv_msg_Text->append(data);  // append()自动将QByteArray转为QString
}

②Windows下位机

widget.h：

#ifndef WIDGET_H                      // 防止头文件重复包含
#define WIDGET_H
// ==================== 包含必要的头文件 ====================
#include <QWidget>          // Qt窗口基类
#include <QString>          // Qt字符串类
#include <QObject>          // Qt对象基类（支持信号槽机制）
#include <QDebug>           // Qt调试输出（qDebug()）
#include <QSerialPort>      // 串口通信类
#include <QSerialPortInfo>  // 串口信息类（获取可用串口列表）
#include <QLabel>           // 标签控件
#include <QComboBox>        // 下拉列表控件
#include <QPushButton>      // 按钮控件
#include <QTextEdit>        // 多行文本编辑框控件
#include <QFont>            // 字体类
// ==================== Qt命名空间宏 ====================
QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }  // 前向声明UI类（由Qt Designer生成）
QT_END_NAMESPACE
// ==================== Widget类定义 ====================
class Widget : public QWidget
{
    Q_OBJECT  // Qt元对象宏（支持信号槽功能）
public:
    // ----- 构造函数和析构函数 -----
    Widget(QWidget *parent = nullptr);  // 构造函数
    ~Widget();                          // 析构函数
    // ----- 公共成员函数 -----
    void Serila_Init();   // 串口初始化函数（创建UI控件和串口对象）
    void Serila_Free();   // 串口资源释放函数（释放动态分配的内存）
public slots:  // 公共槽函数（响应信号）
    void open_serial();      // 打开串口槽函数（点击"打开串口"按钮触发）
    void send_serial_msg();  // 发送串口消息槽函数（点击"发送"按钮触发）
    void recv_serial_msg();  // 接收串口消息槽函数
private:
    // ===== UI对象 =====
    Ui::Widget *ui;          // UI界面指针（由uic工具生成）
    // ===== 串口对象 =====
    QSerialPort * serial;    // 串口通信对象
    // ===== 字体对象 =====
    QFont * font;            // 字体样式对象
    // ===== 串口信息列表 =====
    QList<QSerialPortInfo> * serial_inf;  // 存储可用串口信息的列表
    // ===== 串口参数信息文本框 =====
    QTextEdit * com_inf;     // 显示串口参数信息的文本框
    // ===== 端口标签 =====
    QLabel * com_port;       // "端口:" 标签
    // ===== 端口下拉列表 =====
    QComboBox * com_port_cbox;  // 显示可用串口的下拉列表
    // ===== 选中的端口名 =====
    QString * com_select_ack;   // 存储用户选中的端口名称
    // ===== 打开串口按钮 =====
    QPushButton * open_serial_btn;  // "打开串口"按钮
    // ===== 发送消息按钮 =====
    QPushButton * send_msg_btn;  // "发送"按钮
    // ===== 发送消息文本框 =====
    QTextEdit * send_msg_Text;   // 用户输入要发送数据的文本框
};
#endif // WIDGET_H

widget.cpp：

#include "widget.h"      // 包含头文件
#include "ui_widget.h"   // 包含自动生成的UI头文件
// ==================== 构造函数 ====================
Widget::Widget(QWidget *parent)
    : QWidget(parent)    // 调用父类QWidget的构造函数
    , ui(new Ui::Widget) // 创建UI对象
{
    ui->setupUi(this);   // 设置UI界面（虽然本代码未使用UI文件）
    this->Serila_Init(); // 调用串口初始化函数
}
// ==================== 析构函数 ====================
Widget::~Widget()
{    
    this->Serila_Free(); // 释放动态分配的资源
    delete ui;           // 释放UI对象内存
}
// ==================== 串口初始化函数 ====================
void Widget::Serila_Init()
{
    // ----- 设置窗口属性 -----
    this->setFixedWidth(800);            // 固定窗口宽度800像素
    this->setFixedHeight(480);           // 固定窗口高度480像素
    this->setWindowTitle("windows窗口上位机");  // 设置窗口标题
    // ----- 创建串口信息列表对象 -----
    this->serial_inf = new QList<QSerialPortInfo>;
    // ----- 获取当前系统所有可用串口 -----
    // QSerialPortInfo::availablePorts()返回QList<QSerialPortInfo>
    // 使用解引用操作符(*)获取列表对象并赋值
    (*this->serial_inf) = QSerialPortInfo::availablePorts();
    // ----- 创建串口对象 -----
    this->serial = new QSerialPort;
    // ----- 设置串口参数（在打开前配置） -----
    this->serial->setBaudRate(QSerialPort::Baud115200);   // 波特率：115200
    this->serial->setDataBits(QSerialPort::Data8);        // 数据位：8位
    this->serial->setParity(QSerialPort::NoParity);       // 奇偶校验：无
    this->serial->setStopBits(QSerialPort::OneStop);      // 停止位：1位
    // ----- 创建字体对象 -----
    this->font = new QFont("Arial", 15);  // 字体：Arial，字号：15
    // ----- 创建"端口："标签 -----
    this->com_port = new QLabel("端口:", this);  // 显示文本"端口:"
    this->com_port->setFont(*this->font);        // 设置字体
    // 设置标签大小和位置
    this->com_port->setFixedWidth(60);   // 宽度60像素
    this->com_port->setFixedHeight(30);  // 高度30像素
    this->com_port->move(10, 10);        // 移动到坐标(10, 10)
    // ----- 创建端口下拉列表 -----
    this->com_port_cbox = new QComboBox(this);
    // 修改字体大小为10
    this->font->setPointSize(10);
    this->com_port_cbox->setFont(*this->font);
    // 遍历串口列表，将端口名称添加到下拉列表
    for(int com_num = 0; com_num < this->serial_inf->size(); com_num++)
    {
        // 获取第com_num个串口信息的端口名称，添加到下拉列表
        this->com_port_cbox->addItem(this->serial_inf->at(com_num).portName());
    }
    // 设置下拉列表大小和位置
    this->com_port_cbox->setFixedWidth(110);   // 宽度110像素
    this->com_port_cbox->setFixedHeight(30);   // 高度30像素
    this->com_port_cbox->move(80, 10);         // 移动到坐标(80, 10)
    // ----- 创建存储选中端口的字符串对象 -----
    this->com_select_ack = new QString;
    // ----- 创建"打开串口"按钮 -----
    this->font->setPointSize(15);  // 字体大小改为15
    this->open_serial_btn = new QPushButton("打开串口", this);
    this->open_serial_btn->setFont(*this->font);
    this->open_serial_btn->move(30, 70);  // 移动到坐标(30, 70)
    // ----- 创建串口参数信息文本框 -----
    this->com_inf = new QTextEdit(this);
    // 添加串口参数信息
    this->com_inf->append("波特率：115200");
    this->com_inf->append("数据位：8");
    this->com_inf->append("奇偶检验：无");
    this->com_inf->append("停止位：1");
    // 设置字体大小12
    this->font->setPointSize(12);
    this->com_inf->setFont(*this->font);
    // 设置文本框大小和位置
    this->com_inf->setFixedWidth(180);   // 宽度180像素
    this->com_inf->setFixedHeight(180);  // 高度180像素
    this->com_inf->move(10, 150);        // 移动到坐标(10, 150)
    // ----- 创建发送消息文本框（用户输入要发送的数据） -----
    this->send_msg_Text = new QTextEdit(this);
    this->send_msg_Text->setFont(*this->font);
    // 设置发送文本框大小和位置
    this->send_msg_Text->setFixedWidth(500);   // 宽度500像素
    this->send_msg_Text->setFixedHeight(320);  // 高度320像素
    this->send_msg_Text->move(250, 10);        // 移动到坐标(250, 10)
    // ----- 创建"发送"按钮 -----
    this->send_msg_btn = new QPushButton("发送", this);
    this->send_msg_btn->setFont(*this->font);
    this->send_msg_btn->move(650, 350);  // 移动到坐标(650, 350)
    // ===== 连接信号与槽 =====
    // 1. 点击"打开串口"按钮 → 执行open_serial()槽函数
    QObject::connect(this->open_serial_btn, &QPushButton::clicked,
                     this, &Widget::open_serial);
    // 2. 点击"发送"按钮 → 执行send_serial_msg()槽函数
    QObject::connect(this->send_msg_btn, &QPushButton::clicked,
                     this, &Widget::send_serial_msg);
    // 串口接收数据
    QObject::connect(this->serial, &QSerialPort::readyRead, 
                     this, &Widget::recv_serial_msg);
    return;  // 函数结束（可省略）
}
// ==================== 打开串口槽函数 ====================
void Widget::open_serial()
{
    // 判断下拉列表是否有选项
    if(this->com_port_cbox->count() == 0)
    {
        qDebug() << "没有可用的串口";
        return;
    }
    
    // 判断是否选中了有效项
    if(this->com_port_cbox->currentIndex() == -1)
    {
        qDebug() << "未选择串口";
        return;
    }
    // ----- 获取用户选中的端口名 -----
    // currentIndex()：获取当前选中项的索引
    // itemText()：根据索引获取显示的文本
    *this->com_select_ack = this->com_port_cbox->itemText(
        this->com_port_cbox->currentIndex()
    );
    // ----- 设置串口要打开的端口号 -----
    this->serial->setPortName(*this->com_select_ack);
    // 调试输出选中的端口名
    qDebug() << *this->com_select_ack;
    // ----- 尝试打开串口（读写模式） -----
    // QIODevice::ReadWrite：以读写方式打开
    if(this->serial->open(QIODevice::ReadWrite) == false)
    {
        // 打开失败，输出错误信息
        qDebug() << "error";
        return;  // 退出函数
    }
    else
    {
        // 打开成功，输出成功信息
        qDebug() << *this->com_select_ack << "open success";
    }
}
// ==================== 发送串口消息槽函数 ====================
void Widget::send_serial_msg()
{
    // 检查串口是否打开
    if(!this->serial || !this->serial->isOpen())
    {
        qDebug() << "串口未打开，无法发送";
        return;
    }
    // ----- 获取用户输入的消息文本 -----
    // toPlainText()：获取QTextEdit中的纯文本内容
    QString msg = this->send_msg_Text->toPlainText();
    if(msg.isEmpty())
    {
        qDebug() << "消息为空，不发送";
        return;
    }
    // ----- 发送数据到串口 -----
    // toUtf8()：将QString转换为QByteArray（UTF-8编码）
    // write()：向串口写入数据
    // 下位机使用QByteArray接收，所以发送时也需要以QByteArray格式发送
    this->serial->write(msg.toUtf8(), msg.toUtf8().size());
}
// ==================== 接收串口消息槽函数 ====================
// 实现接收槽函数
void Widget::recv_serial_msg()
{
    QByteArray data = this->serial->readAll();
    // 显示到接收文本框（需要添加接收文本框成员变量）
    this->recv_msg_Text->append(data);
}
// ==================== 串口资源释放函数 ====================
void Widget::Serila_Free()
{
    if(this->serial && this->serial->isOpen())
    {
        this->serial->close();  // 先关闭串口
    }
    // 释放所有动态分配的内存
    delete this->serial;          // 释放串口对象
    delete this->font;            // 释放字体对象
    delete this->serial_inf;      // 释放串口信息列表
    delete this->com_inf;         // 释放串口信息文本框
    delete this->com_port;        // 释放端口标签
    delete this->com_port_cbox;   // 释放端口下拉列表
    delete this->com_select_ack;  // 释放选中的端口名字符串
    delete this->open_serial_btn; // 释放打开串口按钮
    delete this->send_msg_btn;    // 释放发送按钮
}

二、QT的数据库编程

1、QT的数据库

Qt 框架提供的一套跨平台数据库访问模块，通过统一的 QSqlDatabase 接口支持多种主流数据库（如 SQLite、MySQL、PostgreSQL、ODBC 等），并提供 QSqlQuery 执行 SQL 语句和 QSqlTableModel 等数据模型直接与 Qt 的视图组件（如 QTableView）绑定，实现数据的高效读写和界面展示。

2、QT数据库开发中常见的组合

3、前置知识点

（1）编译配置

在.pro文件中添加数据库模块依赖： QT += sql

（2）常用的3种类类型

①SQL数据库类（QSqlDatabase）：负责连接数据库文件，管理数据的持久化存储（可存磁盘或内存），一个数据库文件可包含多个数据表。

②数据模型类（QSqlTableModel / QSqlQueryModel）：负责从数据库类中获取数据，处理后提交给视图类显示，充当数据库与界面之间的数据中转站。

③数据库视图类（QTableView）：一个Qt控件，负责将数据模型提供的数据以表格形式直观地展示给用户。

4、数据库的实现

（1）数据库的创建

调用数据库类的静态函数创建数据库对象：

结果：

（2）创建QSqlQuery对象

数据库表格QSqlQuery类：一个用于执行和处理数据库查询的类，提供了一系列函数来执行SQL语句、处理查询结果以及访问查询元数据等操作。
    QSqlQuery头文件：#include <QSqlQuery>
以下是类成员方法：
    prepare(const QString& query)：准备一个SQL查询，将查询语句作为参数传入。
    bindValue(const QString& placeholder, const QVariant& val)：绑定值到SQL查询中的占位符，可以使用冒号(:)或问号(?)作为占位符。
    exec()：执行SQL查询，如果是SELECT语句，则返回true表示查询成功；如果是其他类型的SQL语句（如INSERT、UPDATE、DELETE等），则返回true表示执行成功。
    next()：将查询结果的游标移到下一条记录，如果存在下一条记录，则返回true；否则返回false。
    value(int index)或value(const QString& name)：获取当前记录中指定列的值，可以通过列索引或列名进行访问。
    record()：返回当前记录的QSqlRecord对象，可以获取记录的详细信息，如字段数、字段名等。
    lastInsertId()：返回最后插入的记录的ID值，通常在插入数据后调用。
    size()或numRowsAffected()：返回受影响的行数，通常用于判断INSERT、UPDATE、DELETE等操作影响的行数。
    isValid()：检查查询结果是否有效，即是否执行了exec()方法并且有可用的结果。

结果：

（3）数据库添加数据

（4）数据库删除数据

结果：

（5）数据库查询数据

结果：

（6）数据库修改数据

结果：

5、数据模型和数据库视图的实现

（1）数据模型的创建

QSqlTableModel：
    Qt提供的关系型数据库表格数据模型类，继承自 QAbstractTableModel，
    主要用于在 Qt 的视图组件（如 QTableView）中直接显示、编辑和提交数据库表数据，
    支持双向同步（视图修改自动同步到数据库，数据库更新自动刷新视图）。
成员函数具体如下：
    setTable(const QString& tableName) : 设置要操作的数据库表格名称。
    select(): 执行查询操作，从数据库中检索数据，并将其存储在数据模型中。
    setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole): 设置指定索引位置的单元格数据。
    data(const QModelIndex& index, int role = Qt::DisplayRole): 获取指定索引位置的单元格数据。
    insertRecord(int row, const QSqlRecord& record): 在指定位置插入一条记录。
    removeRecord(int row): 删除指定位置的记录。
    submitAll(): 将对模型的所有修改提交到数据库中。
    revertAll(): 撤销对模型的所有修改，恢复到最近的提交状态。
    rowCount() : 获取模型中记录的行数。
    columnCount(): 获取模型中列数。
    numRowsAffected()：获取受影响的行的数量

（2）数据库视图的创建

QTableView：Qt框架中的一个类，用于显示二维表格数据的视图组件。
常用函数：
    设置模型: 使用setModel()方法将数据模型与QTableView关联起来。
    设置数据自动换行：void setWordWrap(bool on);
    获取行头对象：QHeaderView *verticalHeader()；
    QAbstractItemModel *model() const;

6、知识点扩充

（1）数据太多如何换行

QTableView中启用文本自动换行需要两个条件：

①设置setWordWrap(true)，默认已开启。

②通过verticalHeader()->setDefaultSectionSize()设置行高，否则行高固定无法显示换行后的多行文本。

// 行高 150px（垂直方向）
this->view->verticalHeader()->setDefaultSectionSize(150);
// 列宽 150px（水平方向）
this->view->horizontalHeader()->setDefaultSectionSize(150);

（2）QTableView中的列表宽度如何自适应视图的宽度

在QTableView中，列宽设置必须在setModel() 之后，且每次切换表格（模型数据变化）时，由于列数可能改变，需要重新调用列宽设置方法:

如setColumnWidth() 或 resizeColumnsToContents()。

//获取视图的总宽度
int total_width = sql_view->width();
// 计算每列应占的宽度（平均分配）
int num_columns = table_model->columnCount();
int column_width = total_width / num_columns;
// 设置每列的宽度
for(int n=0; n<num_columns; n++)
   this->sql_view->setColumnWidth(n, column_width);

（3）点击单元格删除该行

在数据库初始化时，将视图的点击信号（如clicked）连接到自定义槽函数，实现点击行后获取当前行数据并进行删除操作。

    QObject::connect(&view, &QTableView::clicked, [&](const QModelIndex &index) {
        int row = index.row(); // 获取被点击的行号0        、
    if(!sql_model.removeRow(row)) 
    {
        QMessageBox::warning(&view, "Error", "Failed to remove row!");
    }
    });

（4）暗黑风格的数据库

QWidget {
    background-color: #2d2d2d;
    color: #f0f0f0;

}
/* 按钮 */
QPushButton {
    background-color: #505050;
    border: 1px solid #707070;
    border-radius: 4px;
    padding: 5px;
}
QPushButton:hover {
    background-color: #606060;

}
QPushButton:pressed {
    background-color: #404040;

}
/* 表格视图 */
QTableView {
    background-color: #3a3a3a;
    alternate-background-color: #4a4a4a;
    gridline-color: #5a5a5a;
}
QHeaderView::section {
    background-color: #505050;
    color: white;
    padding: 4px;
    border: 1px solid #606060;
}

三、QT QSS（样式表）

1、基本概念

QT样式表：用于定制控件外观的样式机制，语法和用法类似于 CSS（层叠样式表），通过设置控件的 setStyleSheet() 方法或全局样式文件，可以灵活地改变界面颜色、字体、边框、背景、间距等视觉风格，而无需修改控件本身的代码。

选择器的分类：类型选择器、后代选择器、类选择器、ID选择器、子控件选择器、状态选择器
常见的属性：
    颜色相关：
        color: 文本颜色
        background-color: 背景颜色
        border-color: 边框颜色
    字体相关：
        font-family: 字体族
        font-size: 字体大小
        font-weight: 字体粗细
    边框相关：
        border-style: 边框样式（solid：实线边框, dashed：虚线边框, dotted：点线边框等）
        border-width: 边框宽度
        border-radius: 边框圆角半径
    布局相关：
        margin: 外边距
        padding: 内边距
    背景相关：
        background-image: 背景图片
        background-repeat: 背景重复方式
        background-position: 背景位置
    状态相关：
        hover: 鼠标悬停状态
        pressed: 鼠标按下状态
        checked: 选中状态（对于复选框和单选按钮）
    形状相关：
        border-radius: 边框圆角半径
        border-image: 边框图片 
    动画相关：
        animation: 动画效果
常见的值：
    颜色相关：
        color: 可以是预定义的颜色名称（如red, green, blue等）或十六进制RGB值（如#FF0000，#00FF00等）。
        background-color: 同color属性。
    字体相关：
        font-family: 可以是字体族名称（如Arial, Helvetica等）或字体文件路径。
        font-size: 可以是像素大小，也可以是相对大小（如smaller, larger等）。
        font-weight: 可以是预定义粗细（如bold, normal等）或数字值（如100，200等）。
    边框相关：
        border-style: 可以是预定义样式（如solid, dashed, dotted等）。
        border-width: 可以是像素大小，也可以是相对大小。
        border-radius: 可以是像素大小，也可以是相对大小。
    布局相关：
        margin: 可以是像素大小，也可以是相对大小。
        padding: 可以是像素大小，也可以是相对大小。
    背景相关：
        background-image: 可以是图片文件路径或线性渐变（如qlineargradient(x1, y1, x2, y2)）。
        background-repeat: 可以是预定义方式（如repeat, repeat-x, repeat-y, no-repeat等）。
        background-position: 可以是像素大小，也可以是相对大小。
    状态相关：
        hover, :pressed, :checked: 可以是其他样式表属性，用于指定不同状态下的样式。
    形状相关：
        border-radius: 可以是像素大小，也可以是相对大小。
        border-image: 可以是图片文件路径或线性渐变。
    动画相关：animation: 可以是动画名称，也可以是动画效果参数。

2、类型选择器和类选择器

类型选择器（Type Selector）：直接使用类名（如 QPushButton）作为选择器，用于匹配该类及其所有子类的控件实例，是最常用的基础选择器之一。

类选择器（Class Selector）：以 点号（.）开头（如 .QPushButton），用于匹配特定类的所有控件实例，但与类型选择器不同的是，它只匹配该类本身，不匹配其子类，可以更精确地控制样式作用范围。

设置按钮的字体颜色和背景颜色：

3

设置标签的字体颜色和背景颜色

类选择器和类型选择器的区别：

类型选择器会匹配QAbstractButton及其所有子类，btn1和btn2是QAbstractButton的子类QPushbutton，所以btn1和btn2都应用了样式。

类选择器只匹配QAbstractButton本身，btn1和btn2不属于QAbstractButton，是它的子类QPushbutton,所以btn1和btn2都没有应用样式。

3、后代选择器

后代选择器：QSS 中用空格分隔的选择器组合（如 QGroupBox QPushButton），用于匹配父控件内部所有层级的指定子控件（即所有后代，不限层级）。

4、ID选择器

ID选择器：QSS 中以 # 号开头的选择器（如 #btnSave），用于精确匹配设置了 setObjectName() 的特定控件，是优先级最高的选择器之一。

5、子控件选择器

子控件选择器：QSS 中以 :: 双冒号开头的选择器（如 QComboBox::drop-down、QSpinBox::up-arrow），用于精确匹配复杂控件内部的子组件（如按钮、箭头、滑块等），实现对控件局部区域的精细化样式定制。

6、状态选择器

状态选择器：QSS 中以 : 冒号开头的选择器（如 :hover、:pressed、:disabled），用于匹配控件在不同交互状态（悬停、按下、禁用、选中等）下的样式，实现动态的视觉反馈。

未按下的效果：

按下后的效果：

渐变颜色的示例

未按下的效果：

按下后的效果

四、QT事件

1、基本概念

QT事件：用于处理用户交互（如鼠标点击、键盘输入）和系统通知（如定时器、窗口重绘）的核心机制，通过 QEvent 类及其子类封装各种事件，并由 event() 或特定事件处理函数（如 mousePressEvent()）进行响应。该系统基于事件循环不断从事件队列中取出事件，并分发给对应控件处理，是 Qt 应用程序运行的核心驱动力。

2、常见的事件类型

常见事件类型，以下是一些常见的事件类型，它们继承自 QEvent 类：
    鼠标事件 (QMouseEvent)：例如，鼠标点击、按下、释放、移动等。
    键盘事件 (QKeyEvent)：例如，按键按下、释放等。
    窗口事件 (QWindowEvent)：窗口的改变（如大小调整、最小化、关闭等）。
    绘制事件 (QPaintEvent)：触发控件或窗口的重绘。
    定时器事件 (QTimerEvent)：定时器触发时发生的事件。
    拖放事件 (QDragEnterEvent, QDropEvent)：拖放操作相关的事件。
    聚焦事件 (QFocusEvent)：控件获得或失去焦点时发生的事件。

3、事件处理机制

事件处理机制分三步走：事件生成➔事件传递➔事件处理

① 事件生成（Event Generation）

• 触发条件：用户交互（点击、按键、拖拽）或系统通知（定时器、窗口重绘）

• 结果：Qt 自动创建对应的 QEvent 子类对象（如 QMouseEvent、QKeyEvent）

② 事件传递（Event Delivery）

• 路径：从事件源（产生事件的控件，如被点击的按钮）→ 放入事件队列 → 等待处理

• 关键点：事件源是事件发生的起点，事件队列保证按顺序（FIFO）传递

③ 事件处理（Event Handling）

• 方式：事件循环从队列取出事件，分发给目标控件

• 实现：通过重写 event()（通用入口）或专用函数（如 mousePressEvent()、keyPressEvent()）进行响应

4、鼠标事件应用：事件过滤器

事件过滤器机制：允许一个对象拦截另一个对象的事件，通过重载 eventFilter 函数来实现。

常见的用法：拦截和修改事件，例如监视控件的鼠标点击事件。

class MyEventFilter : public QObject 
{
    Q_OBJECT
public:
    // watched：被监视的对象（事件源）。
    // event：需要过滤的事件对象。
    bool eventFilter(QObject *watched, QEvent *event) override 
    {
        if (event->type() == QEvent::MouseButtonPress) 
        {
            qDebug() << "Mouse clicked!";
            return true; // 阻止事件进一步传播
        }
        //调用基类的事件过滤函数，继续事件标准传递
        return QObject::eventFilter(watched, event);
    }
};
MyEventFilter me; 创建过滤器对象。
w.installEventFilter(&me);  安装过滤器到目标对象。

五、自定义控件

1、自定义控件的概念

自定义控件：通过继承现有的 Qt 控件类或 QWidget 类，并重载相关的事件处理函数和绘制函数来实现你自己的控件。自定义控件使得你可以根据应用需求设计具有特定行为和外观的控件，它的本质是通过继承和重写来扩展 Qt 默认控件的功能。

通常自定义控件需要处理几个核心方面：
    绘制控件：通过重写控件的 paintEvent() 来绘制控件的外观。
    响应用户交互：通过重写事件处理函数（如 mousePressEvent()、keyPressEvent() 等）来处理用户输入。
    控件尺寸和布局：通过重写 sizeHint() 和 minimumSizeHint() 来设置控件的尺寸。
    信号和槽：通过定义自己的信号来与其他控件或类进行交互。

2、自定义控件的步骤

1、继承QWidget或者现有控件类
    大多数自定义控件都需要继承自QWidget类，或者继承一个已经实现的控件类（如 QPushButton、QLabel 等）。
    如果控件的行为较为复杂，还可以继承其他控件，如QFrame、QGroupBox等。
    
2、重载事件处理函数
    Qt提供了一些标准事件处理函数，可以通过重载它们来改变控件的行为。
    常用的事件处理函数包括：
        paintEvent(QPaintEvent *event)：用于绘制控件。
        mousePressEvent(QMouseEvent *event)：处理鼠标点击事件。
        mouseMoveEvent(QMouseEvent *event)：处理鼠标移动事件。
        mouseReleaseEvent(QMouseEvent *event)：处理鼠标释放事件。
        keyPressEvent(QKeyEvent *event)：处理键盘事件。
        resizeEvent(QResizeEvent *event)：处理控件大小改变的事件。
        
3、实现自定义控件的绘制逻辑
    在自定义控件中，最常见的事情之一是重写 paintEvent()，通过 QPainter 对象在控件上进行绘制。

3、绘制圆形按钮

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QDebug>
#include <QDragEnterEvent>
#include <QPushButton>
#include <QPainter>
#include <QWidget>
#include <QPoint>
#include <QMouseEvent>
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;
};
// ==================== 自定义按钮类 ====================
class my_btn : public QPushButton // 自定义按钮类，继承自 QPushButton
{
public:
    my_btn(const QString &text,QWidget * parent = nullptr)
        : QPushButton(text, parent)  // 调用父类构造函数，设置按钮文本和父对象
    {
        // 初始化圆心坐标（相对于按钮自身）
        x0 = width() / 2;    // 圆心的 X 坐标 = 按钮宽度的一半
        y0 = height() / 2;   // 圆心的 Y 坐标 = 按钮高度的一半
        qDebug() << "按钮文本：" << this->text();
    }
protected:
    // 重写了paintEvent，完全覆盖了父类的绘制逻辑,所以调用父类QPushButton的构造函数时文本效果未起作用
    // 重写绘制事件：将按钮绘制成圆形
    void paintEvent(QPaintEvent *event) override
    {
        // 创建 QPainter 对象，用于在按钮上绘制图形
        QPainter painter(this);
        // 开启抗锯齿（Antialiasing），使圆形边缘更平滑
        painter.setRenderHint(QPainter::Antialiasing);
        // 计算直径：取按钮宽度和高度的较小值（保证是正圆）
        int diameter = qMin(width(), height());
        // 计算半径 = 直径 / 2
        int radius = diameter / 2;
        // 计算圆心的坐标（按钮的中心点）
        int centerX = width() / 2;
        int centerY = height() / 2;
        qDebug()<<"圆心：("<<centerX<<","<<centerY<<") 半径："<<radius;
        // 计算圆形绘制的矩形区域
        // 左上角 = (centerX - radius, centerY - radius)
        // 宽高 = diameter
        QRect rect(centerX - radius, centerY - radius, diameter, diameter);
        // 设置画刷颜色（填充颜色）
        // isDown() 返回 true 表示按钮被按下 → 深灰色
        // 否则（正常状态）→ 浅灰色
        painter.setBrush(isDown() ? Qt::darkGray : Qt::lightGray);  // 按下状态为深色
        // 绘制圆形（椭圆，但矩形是正方形，所以画出来是正圆）
        painter.drawEllipse(rect);
        // ===== 手动绘制文本 =====
        painter.setPen(Qt::black);  // 文本颜色
        painter.setFont(font());    // 使用按钮的字体
        painter.drawText(rect, Qt::AlignCenter, text());  // 在圆形中心绘制文本
    }
    // 重写鼠标按下事件
    void mousePressEvent(QMouseEvent *event) override
    {
        // 记录鼠标按下时的位置（相对于按钮自身）
        dragStartPos = event->pos();
        // 计算鼠标按下点与圆心的距离（两点间距离公式）
        // (x - x0)² + (y - y0)² < 50²
        // 即：鼠标点击位置必须在以 (x0, y0) 为圆心，50 像素为半径的圆内
        if((dragStartPos.x() - x0) * (dragStartPos.x() - x0) +
           (dragStartPos.y() - y0) * (dragStartPos.y() - y0) < 50*50)
        {
            // 调试输出圆心坐标
            qDebug()<<x0<<","<<y0;
            // 调用父类的鼠标按下事件处理（保留 QPushButton 的默认行为）
             QPushButton::mousePressEvent(event);
        }
        // 如果点击在圆形区域外，则不触发父类事件（按钮不会响应）
    }
    // 重写鼠标移动事件（实现拖拽功能）
    void mouseMoveEvent(QMouseEvent  *event) override
    {
        // 检查是否为左键拖动
        if (event->buttons() == Qt::LeftButton)
        {
            // 再次检查鼠标位置是否在圆形区域内
            if((dragStartPos.x() - x0) * (dragStartPos.x() - x0) +
               (dragStartPos.y() - y0) * (dragStartPos.y() - y0) < 50*50)
            {
                // 获取当前鼠标位置（相对于按钮自身）
                QPoint tmp_dragStartPos = event->pos();
                // 计算鼠标移动的偏移量（当前 - 按下时）
                int dx = tmp_dragStartPos.x() - dragStartPos.x();
                int dy = tmp_dragStartPos.y() - dragStartPos.y();
                // 更新按钮的位置（相对于父窗口）
                // x() 和 y() 是按钮当前在父窗口中的位置
                // move() 将按钮移动到新位置
                move(x() + dx, y() + dy);
            }
        }
        // 调用父类的鼠标移动事件处理
        QPushButton::mouseMoveEvent(event);
    }
    // 重写鼠标释放事件
    void mouseReleaseEvent(QMouseEvent *event) override
    {
        // 记录鼠标释放时的位置（用于后续判断）
        dragStartPos = event->pos();
        // 调用父类的鼠标释放事件处理
        QPushButton::mouseReleaseEvent(event);
    }
    QPoint dragStartPos; // 鼠标按下时的位置（相对于按钮自身）
    int x0; // 圆心的 X 坐标（相对于按钮自身）
    int y0; // 圆心的 Y 坐标（相对于按钮自身）
};
#endif // MAINWINDOW_H

main.cpp

#include "mainwindow.h"
#include <QApplication>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    //自定义控件
    my_btn button("按钮",&w);
    w.show();
    return a.exec();
}

结果：