QT中常用类的成员(2024.8.20更新)

标签：const QT 2024.8 void int bool QString 20 Qt

QT中常用类的成员
1. QObject类是 Qt 框架中所有对象的基类，提供了信号和槽机制、事件处理、对象树和内存管理等功能
2. QMetaObject类是 Qt 框架中用于描述对象的元数据的类，提供了元数据查询、类信息、属性信息、方法信息等功能
QWidget 类是 Qt 框架中所有图形用户界面组件的基类，提供了窗口的基本功能和属性设置等功能
QMainWindow 类是 Qt 框架中用于创建主窗口的类，继承自 QWidget 类
QDialog 类是 Qt 框架中用于创建对话框的类，继承自 QWidget 类
基本数据类型
1. QString类是 Qt 框架中用于处理字符串的类，提供了字符串的各种操作和处理功能
2. QByteArray 类用于存储二进制数据。
3. QVariant 类用于存储任意数据类型。类似于 C++ 的 std::any。
容器
1. QMap 类是 Qt 框架中用于存储键值对的类，提供了对键值对的各种操作和处理功能
2. QHash 类是 Qt 框架中用于存储键值对的类，提供了对键值对的各种操作和处理功能
3. QVector 类是 Qt 框架中用于存储一系列数据元素的类，提供了对元素的各种操作和处理功能
4. QList 类用于动态列表存储的重要类。
日期和时间类
1. QDate 类用于表示日期。
2. QTime 类用于表示时间。
3. QDateTime 类用于表示日期和时间。
文件和流类
1. QFile 类用于文件操作。
QDir 类用于目录操作。
QFileInfo 类用于文件信息操作。
2. QTextStream 类用于文本流操作。
3. QDataStream 类用于数据流操作。
图形和坐标
QPoint：表示二维平面上的点。
QSize：表示二维平面上的大小。
QRect：表示二维平面上的矩形。
QColor：表示颜色。
QPixmap：用于处理图像。
QImage：用于处理图像，支持直接像素访问。
QBitmap 是 QImage 的一个子类，用于表示位图。
QPicture 提供了在 Qt 绘图系统中绘制复杂图形的能力。
QTransform 二维变换矩阵 QTransform 类提供了丰富的功能来处理二维变换，包括平移、旋转、缩放和剪切等操作。
图形视图框架
QGraphicsItem：图形视图框架中的基本图形项。
QGraphicsScene：用于管理大量的图形项。
QGraphicsView：用于显示图形场景。
模型/视图框架
QAbstractItemModel：模型/视图框架中的抽象模型类。
QStandardItemModel：标准项模型，用于简单的模型/视图编程。
QTableView：用于显示表格数据的视图。
QTreeView：用于显示树形数据的视图。
网络
QUrl：用于处理 URL。
QTcpSocket：用于 TCP 通信。
QUdpSocket：用于 UDP 通信。
XML(空)
QDomDocument：用于处理 XML 文档。
QXmlStreamReader：用于快速解析 XML。
QXmlStreamWriter：用于快速生成 XML。
数据库
QSqlDatabase：用于连接数据库。
QSqlQuery：用于执行 SQL 查询。
QSqlTableModel：用于处理数据库表的模型。
多媒体(空)
QMediaPlayer：用于播放音频和视频。
QMediaPlaylist：用于管理多媒体播放列表。
WEB(空)
WebEngineView：用于显示 Web 内容（基于 Chromium）。
QWebChannel：用于与 Web 页面进行通信。
国际化和本地化(空)
QLocale：用于处理本地化设置，如日期格式、数字格式等。
QTranslator：用于应用程序的国际化翻译。
其他实用工具
QSettings：用于持久化应用程序设置。
QFileSystemWatcher：用于监控文件和目录的变化。
QProcess：用于启动外部进程并与它们进行通信。
QTimer：用于定时器操作。
QEvent：用于事件处理。
QThread：用于多线程编程。
基础控件：
QWidget：所有用户界面元素的基类。
QPushButton：按钮控件。
QLabel：标签控件，用于显示文本或图像。
QLineEdit：单行文本输入框。
QTextEdit：多行文本输入框。
QCheckBox：复选框控件。
QRadioButton：单选按钮控件。
QComboBox：下拉框控件。
QSlider：滑动条控件。
QSpinBox：数字微调框控件。
布局管理：
QHBoxLayout：水平布局管理器。
QVBoxLayout：垂直布局管理器。
QGridLayout：网格布局管理器。
QFormLayout：表单布局管理器。
容器控件：
QGroupBox：分组框控件。
QTabWidget：选项卡控件。
QStackedWidget：堆叠控件，一次只显示一个子控件。
QScrollArea：滚动区域控件。
高级控件：
QTreeWidget：树形控件。
QTableWidget：表格控件。
QListView：列表视图控件。
QProgressBar：进度条控件。
QDialog：对话框控件。
QMessageBox：消息框控件。
主窗口和菜单：
QMainWindow：主窗口控件。
QMenuBar：菜单栏控件。
QToolBar：工具栏控件。
QStatusBar：状态栏控件。
鼠标和键盘
QMouseEvent：鼠标事件。
QKeyEvent：键盘事件。
QWheelEvent：滚轮事件。

QT中常用类的成员

1. QObject类是 Qt 框架中所有对象的基类，提供了信号和槽机制、事件处理、对象树和内存管理等功能

QObject 是 Qt 框架中的一个核心类，用于提供对象间通信的信号和槽机制、对象树的内存管理以及运行时类型信息等功能。

QObject 是所有 Qt 对象的基类，许多 Qt 类都直接或间接继承自 QObject。

以下是一些常见的 QObject 继承关系示例：

直接继承：
QWidget：所有 Qt 图形用户界面组件的基类。
QTimer：提供定时器功能。
QThread：用于多线程编程。
QNetworkAccessManager：用于网络请求。

间接继承：
QPushButton：继承自 QAbstractButton，而 QAbstractButton 继承自 QWidget。
QLineEdit：继承自 QWidget。
QMainWindow：继承自 QWidget。
QDialog：继承自 QWidget。

// QObject 类是 Qt 框架中所有对象的基类，提供了信号和槽机制、事件处理、对象树和内存管理等功能。以下是 QObject 类的所有成员函数和枚举类型的详细列表：
QObject
├── QWidget
│    ├── QPushButton
│    ├── QLineEdit
│    ├── QMainWindow
│    └── QDialog
├── QTimer
├── QThread
└── QNetworkAccessManager

// 枚举类型
enum QObject::ConnectionType {
    AutoConnection,       // 自动连接（默认）
    DirectConnection,     // 直接连接
    QueuedConnection,     // 队列连接
    BlockingQueuedConnection, // 阻塞队列连接
    UniqueConnection      // 唯一连接
};

enum QObject::TimerType {
    PreciseTimer,         // 精确计时器
    CoarseTimer,          // 粗略计时器
    VeryCoarseTimer       // 非常粗略计时器
};

// 构造函数
QObject(QObject *parent = nullptr);

// 析构函数
~QObject();

// 公共成员函数
bool blockSignals(bool block); // 阻塞或解除阻塞信号
const QObjectList &children() const; // 返回子对象列表
bool connect(const QObject *sender, const char *signal, const char *method, Qt::ConnectionType type = Qt::AutoConnection) const; // 连接信号和槽
void deleteLater(); // 延迟删除对象
bool disconnect(const char *signal = nullptr, const QObject *receiver = nullptr, const char *method = nullptr); // 断开信号和槽的连接
bool disconnect(const QObject *receiver, const char *method = nullptr); // 断开信号和槽的连接
void dumpObjectInfo(); // 打印对象信息
void dumpObjectTree(); // 打印对象树
QList<QByteArray> dynamicPropertyNames() const; // 返回动态属性名称列表
virtual bool event(QEvent *e); // 事件处理
virtual bool eventFilter(QObject *watched, QEvent *event); // 事件过滤器
T findChild(const QString &name = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const; // 查找子对象
QList<T> findChildren(const QString &name = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const; // 查找子对象列表
QList<T> findChildren(const QRegExp &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const; // 查找子对象列表
QList<T> findChildren(const QRegularExpression &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const; // 查找子对象列表
bool inherits(const char *className) const; // 检查是否继承自某个类
void installEventFilter(QObject *filterObj); // 安装事件过滤器
bool isWidgetType() const; // 检查是否是窗口部件类型
bool isWindowType() const; // 检查是否是窗口类型
void killTimer(int id); // 终止计时器
virtual const QMetaObject *metaObject() const; // 返回元对象
void moveToThread(QThread *targetThread); // 移动对象到另一个线程
QString objectName() const; // 返回对象名称
QObject *parent() const; // 返回父对象
QVariant property(const char *name) const; // 返回属性值
void removeEventFilter(QObject *obj); // 移除事件过滤器
void setObjectName(const QString &name); // 设置对象名称
void setParent(QObject *parent); // 设置父对象
bool setProperty(const char *name, const QVariant &value); // 设置属性值
bool signalsBlocked() const; // 检查信号是否被阻塞
int startTimer(int interval, Qt::TimerType timerType = Qt::CoarseTimer); // 启动计时器
QThread *thread() const; // 返回对象所在的线程

2. QMetaObject类是 Qt 框架中用于描述对象的元数据的类，提供了元数据查询、类信息、属性信息、方法信息等功能

QMetaObject 本身并不直接继承自 QObject，而是通过 Q_OBJECT 宏在编译时自动生成并关联到每个继承自 QObject 的类。

以下是 QMetaObject 的一些关键点和继承关系：

QMetaObject 的生成：
当一个类使用 Q_OBJECT 宏时，Qt 的元对象编译器（MOC）会为该类生成一个 QMetaObject 实例，
并将其关联到该类的静态成员变量 staticMetaObject。

QMetaObject 的使用：
QMetaObject 提供了许多静态方法和成员函数，用于查询和操作对象的元信息，例如：
className()：返回类的名称。
superClass()：返回父类的 QMetaObject。
method() 和 methodCount()：用于访问类的信号和槽方法。
property() 和 propertyCount()：用于访问类的属性。

继承关系：
QMetaObject 本身并不直接继承自 QObject，但它与 QObject 紧密相关，每个 QObject 实例都有一个指向其 QMetaObject 的指针。

Q_OBJECT 宏：

Q_OBJECT 宏是 Qt 框架中的一个重要宏，用于启用 Qt 的元对象系统（Meta-Object System）。元对象系统提供了信号和槽机制、运行时类型信息（RTTI）和动态属性系统等功能。
通过使用 Q_OBJECT 宏，Qt 的元对象编译器（MOC）会为类生成必要的代码，以便支持这些功能。

以下是 Q_OBJECT 宏的主要作用和使用方法：

启用信号和槽机制：
信号和槽是 Qt 中用于对象间通信的机制。通过 Q_OBJECT 宏，类可以定义信号和槽，并使用 connect 函数将信号与槽连接起来。

启用运行时类型信息（RTTI）：
Q_OBJECT 宏使得类可以在运行时获取其类型信息，包括类名、父类、信号、槽和属性等。

启用动态属性系统：
通过 Q_OBJECT 宏，类可以定义和使用动态属性，这些属性可以在运行时添加和访问。

生成必要的代码：
当类使用 Q_OBJECT 宏时，MOC 会为该类生成额外的 C++ 代码，包括 QMetaObject 实例和一些内部函数，以便支持上述功能。


#include <QObject>
#include <QDebug>

class MyClass : public QObject {
    Q_OBJECT

signals:
    void mySignal();

public slots:
    void mySlot() {
        qDebug() << "Slot called";
    }

};

int main() {
    MyClass obj;
    QObject::connect(&obj, &MyClass::mySignal, &obj, &MyClass::mySlot);
    emit obj.mySignal();  // 这将触发 mySlot
    return 0;
}

在这个示例中，MyClass 继承自 QObject 并使用 Q_OBJECT 宏。
这使得 MyClass 可以定义信号 mySignal 和槽 mySlot，
并通过 connect 函数将信号与槽连接起来。
当 emit obj.mySignal() 被调用时，mySlot 会被触发并输出 "Slot called"。

// QMetaObject 类是 Qt 框架中用于元对象系统的重要类。元对象系统提供了信号和槽机制、运行时类型信息和动态属性系统。以下是 QMetaObject 类的所有成员函数和枚举类型的详细列表：

// 公共成员函数
const QMetaObject *superClass() const; // 返回父类的元对象
QObject *cast(QObject *obj) const; // 将对象转换为当前类的实例
bool inherits(const QMetaObject *metaObject) const; // 检查是否继承自某个元对象
int methodCount() const; // 返回方法数量
int methodOffset() const; // 返回方法偏移量
int indexOfMethod(const char *method) const; // 返回方法的索引
int indexOfSignal(const char *signal) const; // 返回信号的索引
int indexOfSlot(const char *slot) const; // 返回槽的索引
int indexOfEnumerator(const char *name) const; // 返回枚举器的索引
int indexOfClassInfo(const char *name) const; // 返回类信息的索引
int indexOfProperty(const char *name) const; // 返回属性的索引
int indexOfConstructor(const char *constructor) const; // 返回构造函数的索引
QMetaMethod method(int index) const; // 返回指定索引的方法
QMetaEnum enumerator(int index) const; // 返回指定索引的枚举器
QMetaClassInfo classInfo(int index) const; // 返回指定索引的类信息
QMetaProperty property(int index) const; // 返回指定索引的属性
QMetaProperty userProperty() const; // 返回用户属性
QMetaConstructor constructor(int index) const; // 返回指定索引的构造函数
int propertyCount() const; // 返回属性数量
int propertyOffset() const; // 返回属性偏移量
int enumeratorCount() const; // 返回枚举器数量
int enumeratorOffset() const; // 返回枚举器偏移量
int classInfoCount() const; // 返回类信息数量
int classInfoOffset() const; // 返回类信息偏移量
int constructorCount() const; // 返回构造函数数量
bool staticMetacall(QMetaObject::Call call, int id, void **arguments); // 静态元调用
void *extension(QMetaObject::Extension extension, void **arguments = nullptr) const; // 扩展
void activate(QObject *sender, int from_signal_index, int to_signal_index, void **argv); // 激活信号
void activate(QObject *sender, const QMetaObject *, int local_signal_index, void **argv); // 激活信号
void activate(QObject *sender, const QMetaObject *, int from_signal_index, int to_signal_index, void **argv); // 激活信号
void connectSlotsByName(QObject *o); // 按名称连接槽
void connect(const QObject *sender, int signal_index, const QObject *receiver, int method_index, int type = 0, int *types = nullptr); // 连接信号和槽
void disconnect(const QObject *sender, int signal_index, const QObject *receiver, int method_index); // 断开信号和槽的连接
QString className() const; // 返回类名
QString classInfo(const char *name) const; // 返回类信息
QMetaProperty property(const char *name) const; // 返回属性
QMetaMethod method(const char *signature) const; // 返回方法
QMetaEnum enumerator(const char *name) const; // 返回枚举器
QMetaProperty userProperty(); // 返回用户属性

// 静态公共成员函数
static bool checkConnectArgs(const char *signal, const char *method); // 检查连接参数
static QByteArray normalizedSignature(const char *method); // 规范化签名
static QByteArray normalizedType(const char *type); // 规范化类型

// 相关非成员函数
bool operator==(const QMetaObject &lhs, const QMetaObject &rhs); // 比较两个元对象
bool operator!=(const QMetaObject &lhs, const QMetaObject &rhs); // 比较两个元对象

QWidget 类是 Qt 框架中所有图形用户界面组件的基类，提供了窗口的基本功能和属性设置等功能

以下是一些常见的 QWidget 子类：

QPushButton：按钮控件。
QLabel：标签控件，用于显示文本或图像。
QLineEdit：单行文本输入框。
QTextEdit：多行文本输入框。
QCheckBox：复选框控件。
QRadioButton：单选按钮控件。
QComboBox：下拉框控件。
QSlider：滑动条控件。
QSpinBox：数字微调框控件。
QGroupBox：分组框控件。
QTabWidget：选项卡控件。
QStackedWidget：堆叠控件，一次只显示一个子控件。
QScrollArea：滚动区域控件。
QTreeWidget：树形控件。
QTableWidget：表格控件。
QListView：列表视图控件。
QProgressBar：进度条控件。
QDialog：对话框控件。
QMessageBox：消息框控件。
QMainWindow：主窗口控件。

// QWidget 类是 Qt 框架中用于创建用户界面的基类。以下是 QWidget 类的所有成员函数和枚举类型的详细列表：

// 继承自 QObject 和 QPaintDevice
class QWidget : public QObject, public QPaintDevice {
    Q_OBJECT

public:
    // 构造函数
    QWidget(QWidget *parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags()); // 默认构造函数

    // 析构函数
    ~QWidget(); // 析构函数

    // 公共成员函数
    QSize size() const; // 返回窗口部件的大小
    QSize minimumSize() const; // 返回窗口部件的最小大小
    QSize maximumSize() const; // 返回窗口部件的最大大小
    void setMinimumSize(const QSize &size); // 设置窗口部件的最小大小
    void setMinimumSize(int minw, int minh); // 设置窗口部件的最小大小
    void setMaximumSize(const QSize &size); // 设置窗口部件的最大大小
    void setMaximumSize(int maxw, int maxh); // 设置窗口部件的最大大小
    QSizePolicy sizePolicy() const; // 返回窗口部件的大小策略
    void setSizePolicy(QSizePolicy policy); // 设置窗口部件的大小策略
    void setSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical); // 设置窗口部件的大小策略
    int heightForWidth(int w) const; // 返回给定宽度下的高度
    QRect geometry() const; // 返回窗口部件的几何形状
    void setGeometry(const QRect &rect); // 设置窗口部件的几何形状
    void setGeometry(int x, int y, int w, int h); // 设置窗口部件的几何形状
    QRect frameGeometry() const; // 返回窗口部件的框架几何形状
    QRect rect() const; // 返回窗口部件的矩形区域
    QRect childrenRect() const; // 返回子窗口部件的矩形区域
    QRect childrenRegion() const; // 返回子窗口部件的区域
    QMargins contentsMargins() const; // 返回内容边距
    void setContentsMargins(const QMargins &margins); // 设置内容边距
    void setContentsMargins(int left, int top, int right, int bottom); // 设置内容边距
    QRect contentsRect() const; // 返回内容矩形区域
    QSize sizeHint() const; // 返回窗口部件的推荐大小
    QSize minimumSizeHint() const; // 返回窗口部件的最小推荐大小
    QSizePolicy::ControlType controlType() const; // 返回窗口部件的控件类型
    void setControlType(QSizePolicy::ControlType type); // 设置窗口部件的控件类型
    Qt::FocusPolicy focusPolicy() const; // 返回焦点策略
    void setFocusPolicy(Qt::FocusPolicy policy); // 设置焦点策略
    bool isActiveWindow() const; // 检查窗口部件是否在活动窗口中
    void activateWindow(); // 激活窗口
    void clearFocus(); // 清除焦点
    void setFocus(); // 设置焦点
    bool isFullScreen() const; // 检查窗口部件是否全屏
    void showFullScreen(); // 显示全屏
    void showNormal(); // 显示正常
    bool isMaximized() const; // 检查窗口部件是否最大化
    void showMaximized(); // 显示最大化
    bool isMinimized() const; // 检查窗口部件是否最小化
    void showMinimized(); // 显示最小化
    bool isHidden() const; // 检查窗口部件是否隐藏
    void hide(); // 隐藏窗口部件
    void show(); // 显示窗口部件
    void raise(); // 提升窗口部件
    void lower(); // 降低窗口部件
    QLayout *layout() const; // 返回布局
    void setLayout(QLayout *layout); // 设置布局
    void update(); // 更新窗口部件
    void update(const QRect &rect); // 更新窗口部件的指定区域
    void update(const QRegion &region); // 更新窗口部件的指定区域
    void repaint(); // 重绘窗口部件
    void repaint(const QRect &rect); // 重绘窗口部件的指定区域
    void repaint(const QRegion &region); // 重绘窗口部件的指定区域
    QPixmap grab(const QRect &rectangle = QRect(QPoint(0, 0), QSize(-1, -1))); // 抓取窗口部件的图像
    void setWindowTitle(const QString &title); // 设置窗口标题
    QString windowTitle() const; // 返回窗口标题
    void setWindowIcon(const QIcon &icon); // 设置窗口图标
    QIcon windowIcon() const; // 返回窗口图标
    void setWindowIconText(const QString &iconText); // 设置窗口图标文本
    QString windowIconText() const; // 返回窗口图标文本
    void setWindowOpacity(qreal level); // 设置窗口透明度
    qreal windowOpacity() const; // 返回窗口透明度
    bool isWindowModified() const; // 检查窗口是否被修改
    void setWindowModified(bool modified); // 设置窗口修改状态
    QPoint pos() const; // 返回窗口部件的位置
    void move(const QPoint &point); // 移动窗口部件
    void move(int x, int y); // 移动窗口部件
    QSize size() const; // 返回窗口部件的大小
    void resize(const QSize &size); // 调整窗口部件的大小
    void resize(int w, int h); // 调整窗口部件的大小
    void setFixedSize(const QSize &size); // 设置固定大小
    void setFixedSize(int w, int h); // 设置固定大小
    void setFixedWidth(int w); // 设置固定宽度
    void setFixedHeight(int h); // 设置固定高度
    QFont font() const; // 返回窗口部件的字体
    void setFont(const QFont &font); // 设置窗口部件的字体
    QPalette palette() const; // 返回窗口部件的调色板
    void setPalette(const QPalette &palette); // 设置窗口部件的调色板
    bool isEnabled() const; // 检查窗口部件是否启用
    void setEnabled(bool enabled); // 设置窗口部件的启用状态
    bool isVisible() const; // 检查窗口部件是否可见
    void setVisible(bool visible); // 设置窗口部件的可见状态
    void setWindowState(Qt::WindowStates state); // 设置窗口状态
    Qt::WindowStates windowState() const; // 返回窗口状态
    void setWindowFlags(Qt::WindowFlags type); // 设置窗口标志
    Qt::WindowFlags windowFlags() const; // 返回窗口标志
    QWindow *windowHandle() const; // 返回窗口句柄
    QWidget *nativeParentWidget() const; // 返回本地父窗口部件
    QWidget *topLevelWidget() const; // 返回顶级窗口部件
    QWidget *parentWidget() const; // 返回父窗口部件
    void setParent(QWidget *parent); // 设置父窗口部件
    void setParent(QWidget *parent, Qt::WindowFlags f); // 设置父窗口部件和窗口标志
    QWidget *focusWidget() const; // 返回焦点窗口部件
    QWidget *nextInFocusChain() const; // 返回焦点链中的下一个窗口部件
    QWidget *previousInFocusChain() const; // 返回焦点链中的上一个窗口部件
    QWidget *childAt(const QPoint &p) const; // 返回指定位置的子窗口部件
    QWidget *childAt(int x, int y) const; // 返回指定位置的子窗口部件
    QWidget *findChild(const QString &name = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const; // 查找子窗口部件
    QList<QWidget *> findChildren(const QString &name = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const; // 查找子窗口部件
    QList<QWidget *> findChildren(const QRegExp &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const; // 查找子窗口部件
    QList<QWidget *> findChildren(const QRegularExpression &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const; // 查找子窗口部件
    QWidget *window() const; // 返回窗口部件的窗口
    QWidget *transientParentWidget() const; // 返回临时父窗口部件
    QWidget *effectiveWinId() const; // 返回有效的窗口标识符
    WId winId() const; // 返回窗口标识符
    void setAttribute(Qt::WidgetAttribute attribute, bool on = true); // 设置窗口部件属性
    bool testAttribute(Qt::WidgetAttribute attribute) const; // 测试窗口部件属性
    void setContextMenuPolicy(Qt::ContextMenuPolicy policy); // 设置上下文菜单策略
    Qt::ContextMenuPolicy contextMenuPolicy() const; // 返回上下文菜单策略
    void setCursor(const QCursor &cursor); // 设置光标
    QCursor cursor() const; // 返回光标
    void unsetCursor(); // 取消设置光标
    void setMouseTracking(bool enable); // 设置鼠标跟踪
    bool hasMouseTracking() const; // 返回鼠标跟踪状态
    bool underMouse() const; // 检查鼠标是否在窗口部件上
    void setTabletTracking(bool enable); // 设置平板跟踪
    bool hasTabletTracking() const; // 返回平板跟踪状态
    void setToolTip(const QString &toolTip); // 设置工具提示
    QString toolTip() const; // 返回工具提示
    void setToolTipDuration(int msec); // 设置工具提示持续时间
    int toolTipDuration() const; // 返回工具提示持续时间
    void setStatusTip(const QString &statusTip); // 设置状态提示
    QString statusTip() const; // 返回状态提示
    void setWhatsThis(const QString &whatsThis); // 设置“这是什么”提示
    QString whatsThis() const; // 返回“这是什么”提示
    void setAccessibleName(const QString &name); // 设置可访问名称
    QString accessibleName() const; // 返回可访问名称
    void setAccessibleDescription(const QString &description); // 设置可访问描述
    QString accessibleDescription() const; // 返回可访问描述
    void setLayoutDirection(Qt::LayoutDirection direction); // 设置布局方向
    Qt::LayoutDirection layoutDirection() const; // 返回布局方向
    void unsetLayoutDirection(); // 取消设置布局方向
    void setLocale(const QLocale &locale); // 设置区域设置
    QLocale locale() const; // 返回区域设置
    void unsetLocale(); // 取消设置区域设置
    void setFocusProxy(QWidget *widget); // 设置焦点代理
    QWidget *focusProxy() const; // 返回焦点代理
    void setInputMethodHints(Qt::InputMethodHints hints); // 设置输入法提示
    Qt::InputMethodHints inputMethodHints() const; // 返回输入法提示
    QVariant inputMethodQuery(Qt::InputMethodQuery query) const; // 返回输入法查询结果
    void inputMethodEvent(QInputMethodEvent *event); // 处理输入法事件
    QSize sizeHint() const; // 返回大小提示
    QSize minimumSizeHint() const; // 返回最小大小提示
    QSizePolicy sizePolicy() const; // 返回大小策略
    void setSizePolicy(QSizePolicy policy); // 设置大小策略
    void setSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical); // 设置大小策略
    int heightForWidth(int w) const; // 返回给定宽度的高度
    QRegion visibleRegion() const; // 返回可见区域
    QPainter *painter() const; // 返回绘制器
    void update(const QRect &rect); // 更新指定区域
    void update(const QRegion &region); // 更新指定区域
    void update(); // 更新窗口部件
    void repaint(const QRect &rect); // 重绘指定区域
    void repaint(const QRegion &region); // 重绘指定区域
    void repaint(); // 重绘窗口部件
    void setMask(const QBitmap &bitmap); // 设置掩码
    void setMask(const QRegion &region); // 设置掩码
    void clearMask(); // 清除掩码
    void render(QPaintDevice *target, const QPoint &targetOffset = QPoint(), const QRegion &sourceRegion = QRegion(), QWidget::RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren)); // 渲染窗口部件
    void render(QPainter *painter, const QPoint &targetOffset = QPoint(), const QRegion &sourceRegion = QRegion(), QWidget::RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren)); // 使用绘制器渲染窗口部件
    bool event(QEvent *event) override; // 事件处理
    bool eventFilter(QObject *watched, QEvent *event) override; // 事件过滤器
    void mousePressEvent(QMouseEvent *event) override; // 鼠标按下事件
    void mouseReleaseEvent(QMouseEvent *event) override; // 鼠标释放事件
    void mouseDoubleClickEvent(QMouseEvent *event) override; // 鼠标双击事件
    void mouseMoveEvent(QMouseEvent *event) override; // 鼠标移动事件
    void wheelEvent(QWheelEvent *event) override; // 滚轮事件
    void keyPressEvent(QKeyEvent *event) override; // 按键按下事件
    void keyReleaseEvent(QKeyEvent *event) override; // 按键释放事件
    void focusInEvent(QFocusEvent *event) override; // 焦点进入事件
    void focusOutEvent(QFocusEvent *event) override; // 焦点离开事件
    void enterEvent(QEvent *event) override; // 进入事件
    void leaveEvent(QEvent *event) override; // 离开事件
    void paintEvent(QPaintEvent *event) override; // 绘制事件
    void moveEvent(QMoveEvent *event) override; // 移动事件
    void resizeEvent(QResizeEvent *event) override; // 调整大小事件
    void closeEvent(QCloseEvent *event) override; // 关闭事件
    void contextMenuEvent(QContextMenuEvent *event) override; // 上下文菜单事件
    void tabletEvent(QTabletEvent *event) override; // 平板事件
    void actionEvent(QActionEvent *event) override; // 动作事件
    void dragEnterEvent(QDragEnterEvent *event) override; // 拖放进入事件
    void dragMoveEvent(QDragMoveEvent *event) override; // 拖放移动事件
    void dragLeaveEvent(QDragLeaveEvent *event) override; // 拖放离开事件
    void dropEvent(QDropEvent *event) override; // 拖放释放事件
    void showEvent(QShowEvent *event) override; // 显示事件
    void hideEvent(QHideEvent *event) override; // 隐藏事件
    void changeEvent(QEvent *event) override; // 改变事件
    bool nativeEvent(const QByteArray &eventType, void *message, long *result) override; // 本地事件

    // 信号
signals:
    void customContextMenuRequested(const QPoint &pos); // 自定义上下文菜单请求信号

    // 枚举类型
    enum RenderFlag {
        DrawWindowBackground = 0x1, // 绘制窗口背景
        DrawChildren = 0x2, // 绘制子窗口部件
        IgnoreMask = 0x4 // 忽略掩码
    };

    Q_DECLARE_FLAGS(RenderFlags, RenderFlag)
    Q_DECLARE_OPERATORS_FOR_FLAGS(QWidget::RenderFlags)
};

QMainWindow 类是 Qt 框架中用于创建主窗口的类，继承自 QWidget 类

// QMainWindow 类是 Qt 框架中用于创建主窗口应用程序的核心类之一。它提供了许多成员函数和特性，用于管理菜单栏、工具栏、状态栏和中央窗口部件等。以下是 QMainWindow 类的所有成员函数和信号的详细列表：

// 构造函数和析构函数
QMainWindow(QWidget *parent = nullptr, Qt::WindowFlags flags = Qt::WindowFlags());
virtual ~QMainWindow();

// 公共函数
QMenuBar *menuBar() const; // 获取菜单栏
QToolBar *addToolBar(const QString &title); // 添加工具栏
QToolBar *addToolBar(Qt::ToolBarArea area, QToolBar *toolbar); // 在指定区域添加工具栏
void addToolBar(QToolBar *toolbar); // 添加工具栏
void addToolBarBreak(Qt::ToolBarArea area = Qt::TopToolBarArea); // 在指定区域添加工具栏分隔符
void insertToolBar(QToolBar *before, QToolBar *toolbar); // 在指定工具栏前插入工具栏
void insertToolBarBreak(QToolBar *before); // 在指定工具栏前插入工具栏分隔符
void removeToolBar(QToolBar *toolbar); // 移除工具栏
void removeToolBarBreak(QToolBar *before); // 移除工具栏分隔符
QStatusBar *statusBar() const; // 获取状态栏
QWidget *centralWidget() const; // 获取中央窗口部件
void setCentralWidget(QWidget *widget); // 设置中央窗口部件
void setDockNestingEnabled(bool enabled); // 设置停靠窗口嵌套启用状态
void setDockOptions(QMainWindow::DockOptions options); // 设置停靠选项
void setDocumentMode(bool enabled); // 设置文档模式
void setUnifiedTitleAndToolBarOnMac(bool set); // 设置 macOS 上的统一标题和工具栏
QMainWindow::DockOptions dockOptions() const; // 获取停靠选项
bool dockNestingEnabled() const; // 获取停靠窗口嵌套启用状态
bool documentMode() const; // 获取文档模式
bool unifiedTitleAndToolBarOnMac() const; // 获取 macOS 上的统一标题和工具栏状态

// 保护函数
virtual void contextMenuEvent(QContextMenuEvent *event); // 上下文菜单事件
virtual bool event(QEvent *event); // 事件处理
virtual void paintEvent(QPaintEvent *event); // 绘制事件

// 信号
void iconSizeChanged(const QSize &iconSize); // 图标大小改变信号
void toolButtonStyleChanged(Qt::ToolButtonStyle toolButtonStyle); // 工具按钮样式改变信号

QDialog 类是 Qt 框架中用于创建对话框的类，继承自 QWidget 类

// QDialog 类是 Qt 框架中用于创建对话框窗口的基类。对话框窗口通常用于与用户进行短期交互，例如显示消息、获取输入或进行配置设置。以下是 QDialog 类的所有成员函数和信号的详细列表：

// 构造函数和析构函数
QDialog(QWidget *parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags());
virtual ~QDialog();

// 公共函数
void setOrientation(Qt::Orientation orientation); // 设置对话框的方向
Qt::Orientation orientation() const; // 获取对话框的方向
void setExtension(QWidget *extension); // 设置扩展窗口部件
QWidget *extension() const; // 获取扩展窗口部件
QSize sizeHint() const; // 获取推荐大小
QSize minimumSizeHint() const; // 获取最小推荐大小
void setVisible(bool visible); // 设置可见性

// 公共槽
void accept(); // 接受对话框
void reject(); // 拒绝对话框
virtual void done(int r); // 完成对话框
virtual void accept(); // 接受对话框（重载）
virtual void reject(); // 拒绝对话框（重载）
int exec(); // 执行模态对话框
void open(); // 打开非模态对话框
void showExtension(bool show); // 显示或隐藏扩展窗口部件

// 保护函数
virtual void closeEvent(QCloseEvent *event); // 关闭事件
virtual void contextMenuEvent(QContextMenuEvent *event); // 上下文菜单事件
virtual bool event(QEvent *event); // 事件处理
virtual bool eventFilter(QObject *o, QEvent *e); // 事件过滤器
virtual void keyPressEvent(QKeyEvent *event); // 按键按下事件
virtual void resizeEvent(QResizeEvent *event); // 调整大小事件
virtual void showEvent(QShowEvent *event); // 显示事件

// 信号
void accepted(); // 对话框被接受信号
void rejected(); // 对话框被拒绝信号

基本数据类型

1. QString类是 Qt 框架中用于处理字符串的类，提供了字符串的各种操作和处理功能

// QString 类是 Qt 框架中用于处理字符串的重要类。以下是 QString 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QString();
QString(const QChar *unicode, int size = -1);
QString(QChar ch);
QString(int size, QChar ch);
QString(QLatin1String str);
QString(const QString &other);
QString(QString &&other) noexcept;
QString(const char *str);
QString(const QByteArray &ba);

// 析构函数
~QString();

// 公共成员函数
int capacity() const; // 返回字符串的容量
void clear(); // 清空字符串
int count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; // 计算子字符串出现的次数
int count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; // 计算字符出现的次数
int count() const; // 返回字符串的长度
bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; // 检查字符串是否以某个子字符串结尾
bool endsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; // 检查字符串是否以某个字符结尾
bool endsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; // 检查字符串是否以某个子字符串结尾
QString &fill(QChar ch, int size = -1); // 填充字符串
int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; // 查找子字符串的位置
int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; // 查找字符的位置
int indexOf(const QStringRef &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; // 查找子字符串的位置
int indexOf(const QRegExp &rx, int from = 0) const; // 使用正则表达式查找位置
int indexOf(QRegExp &rx, int from = 0) const; // 使用正则表达式查找位置
int indexOf(const QRegularExpression &re, int from = 0) const; // 使用正则表达式查找位置
QString left(int n) const; // 返回左边n个字符
QString leftJustified(int width, QChar fill = QChar(' '), bool truncate = false) const; // 左对齐字符串
int length() const; // 返回字符串的长度
int localeAwareCompare(const QString &s) const; // 本地化比较字符串
int localeAwareCompare(const QStringRef &s) const; // 本地化比较字符串
QString &mid(int position, int n = -1) const; // 返回中间部分字符串
QString normalized(NormalizationForm mode) const; // 返回规范化字符串
QString normalized(NormalizationForm mode, QChar::UnicodeVersion version) const; // 返回规范化字符串
QString &prepend(const QString &str); // 在字符串前添加子字符串
QString &prepend(QChar ch); // 在字符串前添加字符
QString &prepend(const QByteArray &ba); // 在字符串前添加字节数组
QString &prepend(const QStringRef &str); // 在字符串前添加子字符串
QString &push_back(const QString &other); // 在字符串后添加子字符串
QString &push_back(QChar ch); // 在字符串后添加字符
QString &push_front(const QString &other); // 在字符串前添加子字符串
QString &push_front(QChar ch); // 在字符串前添加字符
QString &remove(int position, int n); // 移除部分字符串
QString &remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive); // 移除子字符串
QString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive); // 移除字符
QString &remove(const QRegExp &rx); // 使用正则表达式移除
QString &remove(const QRegularExpression &re); // 使用正则表达式移除
QString &replace(int position, int n, const QString &after); // 替换部分字符串
QString &replace(int position, int n, const QChar *unicode, int size); // 替换部分字符串
QString &replace(int position, int n, QChar after); // 替换部分字符串
QString &replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); // 替换子字符串
QString &replace(QChar ch, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); // 替换字符
QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive); // 替换字符
QString &replace(const QRegExp &rx, const QString &after); // 使用正则表达式替换
QString &replace(const QRegularExpression &re, const QString &after); // 使用正则表达式替换
void reserve(int size); // 预留容量
void resize(int size); // 调整大小
QString right(int n) const; // 返回右边n个字符
QString rightJustified(int width, QChar fill = QChar(' '), bool truncate = false) const; // 右对齐字符串
QString &setNum(int n, int base = 10); // 设置数字
QString &setNum(uint n, int base = 10); // 设置数字
QString &setNum(long n, int base = 10); // 设置数字
QString &setNum(ulong n, int base = 10); // 设置数字
QString &setNum(qlonglong n, int base = 10); // 设置数字
QString &setNum(qulonglong n, int base = 10); // 设置数字
QString &setNum(short n, int base = 10); // 设置数字
QString &setNum(ushort n, int base = 10); // 设置数字
QString &setNum(double n, char format = 'g', int precision = 6); // 设置数字
QString &setNum(float n, char format = 'g', int precision = 6); // 设置数字
QString &setRawData(const QChar *unicode, int size); // 设置原始数据
QString &setUnicode(const QChar *unicode, int size); // 设置Unicode数据
QString &setUtf16(const ushort *unicode, int size); // 设置UTF-16数据
QString simplified() const; // 返回简化字符串
int size() const; // 返回字符串的大小
QStringList split(const QString &sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; // 分割字符串
QStringList split(const QChar &sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; // 分割字符串
QStringList split(const QRegExp &rx, Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const; // 使用正则表达式分割
QStringList split(const QRegularExpression &re, Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const; // 使用正则表达式分割
void squeeze(); // 压缩字符串
bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; // 检查字符串是否以某个子字符串开头
bool startsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; // 检查字符串是否以某个字符开头
bool startsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; // 检查字符串是否以某个子字符串开头
void swap(QString &other); // 交换字符串
QByteArray toLatin1() const; // 转换为Latin-1字节数组
QByteArray toLocal8Bit() const; // 转换为本地8位字节数组
QString toLower() const; // 转换为小写
QString toUpper() const; // 转换为大写
QString trimmed() const; // 返回修剪字符串
void truncate(int position); // 截断字符串
const QChar *unicode() const; // 返回Unicode数据
const ushort *utf16() const; // 返回UTF-16数据

2. QByteArray 类用于存储二进制数据。

// QByteArray 类是 Qt 框架中用于字节数组存储的重要类。以下是 QByteArray 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QByteArray();
QByteArray(const char *data, int size = -1);
QByteArray(int size, char ch);
QByteArray(const QByteArray &other);
QByteArray(QByteArray &&other) noexcept;

// 析构函数
~QByteArray();

// 公共成员函数
QByteArray &operator=(const QByteArray &other);
QByteArray &operator=(QByteArray &&other) noexcept;
void swap(QByteArray &other) noexcept;
bool operator==(const QByteArray &other) const;
bool operator!=(const QByteArray &other) const;
bool operator<(const QByteArray &other) const;
bool operator<=(const QByteArray &other) const;
bool operator>(const QByteArray &other) const;
bool operator>=(const QByteArray &other) const;
char &operator[](int i);
const char &operator[](int i) const;
char &operator[](uint i);
const char &operator[](uint i) const;
QByteArray &operator+=(const QByteArray &ba);
QByteArray &operator+=(char ch);
QByteArray &operator+=(const char *str);
int size() const; // 返回字节数组的大小
bool isEmpty() const; // 检查字节数组是否为空
void resize(int size); // 调整字节数组的大小
int capacity() const; // 返回字节数组的容量
void reserve(int size); // 预留容量
void squeeze(); // 压缩字节数组
void detach(); // 分离数据
bool isDetached() const; // 检查数据是否分离
void setSharable(bool sharable); // 设置是否共享
bool isSharedWith(const QByteArray &other) const; // 检查是否共享数据
void clear(); // 清空字节数组
char at(int i) const; // 返回指定位置的字符
char front() const; // 返回第一个字符
char back() const; // 返回最后一个字符
char &front(); // 返回第一个字符
char &back(); // 返回最后一个字符
void push_back(const QByteArray &other); // 在后面添加字节数组
void push_back(const char *str); // 在后面添加字符串
void push_back(char ch); // 在后面添加字符
void push_front(const QByteArray &other); // 在前面添加字节数组
void push_front(const char *str); // 在前面添加字符串
void push_front(char ch); // 在前面添加字符
QByteArray &insert(int i, const QByteArray &ba); // 插入字节数组
QByteArray &insert(int i, const char *str); // 插入字符串
QByteArray &insert(int i, const char *str, int len); // 插入字符串的一部分
QByteArray &insert(int i, char ch); // 插入字符
QByteArray &append(const QByteArray &ba); // 在后面添加字节数组
QByteArray &append(const char *str); // 在后面添加字符串
QByteArray &append(const char *str, int len); // 在后面添加字符串的一部分
QByteArray &append(char ch); // 在后面添加字符
QByteArray &prepend(const QByteArray &ba); // 在前面添加字节数组
QByteArray &prepend(const char *str); // 在前面添加字符串
QByteArray &prepend(const char *str, int len); // 在前面添加字符串的一部分
QByteArray &prepend(char ch); // 在前面添加字符
QByteArray &remove(int pos, int len); // 移除部分字节数组
QByteArray &replace(int pos, int len, const QByteArray &after); // 替换部分字节数组
QByteArray &replace(int pos, int len, const char *after, int alen); // 替换部分字节数组
QByteArray &replace(const QByteArray &before, const QByteArray &after); // 替换字节数组
QByteArray &replace(const char *before, int bsize, const char *after, int asize); // 替换字节数组
QByteArray &replace(char before, const QByteArray &after); // 替换字符
QByteArray &replace(char before, const char *after); // 替换字符
QByteArray &replace(char before, const char *after, int size); // 替换字符
QByteArray &replace(char before, char after); // 替换字符
QList<QByteArray> split(char sep) const; // 分割字节数组
bool startsWith(const QByteArray &ba) const; // 检查是否以指定字节数组开始
bool startsWith(const char *str) const; // 检查是否以指定字符串开始
bool startsWith(char ch) const; // 检查是否以指定字符开始
bool endsWith(const QByteArray &ba) const; // 检查是否以指定字节数组结束
bool endsWith(const char *str) const; // 检查是否以指定字符串结束
bool endsWith(char ch) const; // 检查是否以指定字符结束
QByteArray left(int len) const; // 返回左边部分字节数组
QByteArray right(int len) const; // 返回右边部分字节数组
QByteArray mid(int pos, int len = -1) const; // 返回中间部分字节数组
QByteArray chopped(int len) const; // 返回去掉末尾部分的字节数组
void chop(int n); // 去掉末尾部分
QByteArray trimmed() const; // 返回修剪后的字节数组
QByteArray simplified() const; // 返回简化后的字节数组
int indexOf(const QByteArray &ba, int from = 0) const; // 查找字节数组的索引
int indexOf(const char *str, int from = 0) const; // 查找字符串的索引
int indexOf(char ch, int from = 0) const; // 查找字符的索引
int lastIndexOf(const QByteArray &ba, int from = -1) const; // 查找字节数组的最后一个索引
int lastIndexOf(const char *str, int from = -1) const; // 查找字符串的最后一个索引
int lastIndexOf(char ch, int from = -1) const; // 查找字符的最后一个索引
bool contains(const QByteArray &ba) const; // 检查是否包含字节数组
bool contains(const char *str) const; // 检查是否包含字符串
bool contains(char ch) const; // 检查是否包含字符
int count(const QByteArray &ba) const; // 返回字节数组的数量
int count(const char *str) const; // 返回字符串的数量
int count(char ch) const; // 返回字符的数量
int count() const; // 返回字节数组的大小
QByteArray toLower() const; // 转换为小写
QByteArray toUpper() const; // 转换为大写
QByteArray trimmed() const; // 返回修剪后的字节数组
QByteArray simplified() const; // 返回简化后的字节数组
QByteArray leftJustified(int width, char fill = ' ', bool truncate = false) const; // 左对齐字节数组
QByteArray rightJustified(int width, char fill = ' ', bool truncate = false) const; // 右对齐字节数组
QByteArray &fill(char ch, int size = -1); // 填充字节数组
char *data(); // 返回数据指针
const char *data() const; // 返回数据指针
const char *constData() const; // 返回常量数据指针
void detach(); // 分离数据
bool isDetached() const; // 检查数据是否分离
void truncate(int pos); // 截断字节数组
void chop(int n); // 去掉末尾部分
int length() const; // 返回字节数组的长度
int size() const; // 返回字节数组的大小
bool isEmpty() const; // 检查字节数组是否为空
bool isNull() const; // 检查字节数组是否为空
QByteArray &append(const QByteArray &ba); // 在后面添加字节数组
QByteArray &append(const char *str); // 在后面添加字符串
QByteArray &append(const char *str, int len); // 在后面添加字符串的一部分
QByteArray &append(char ch); // 在后面添加字符
QByteArray &prepend(const QByteArray &ba); // 在前面添加字节数组
QByteArray &prepend(const char *str); // 在前面添加字符串
QByteArray &prepend(const char *str, int len); // 在前面添加字符串的一部分
QByteArray &prepend(char ch); // 在前面添加字符
QByteArray &insert(int i, const QByteArray &ba); // 插入字节数组
QByteArray &insert(int i, const char *str); // 插入字符串
QByteArray &insert(int i, const char *str, int len); // 插入字符串的一部分
QByteArray &insert(int i, char ch); // 插入字符
QByteArray &remove(int pos, int len); // 移除部分字节数组
QByteArray &replace(int pos, int len, const QByteArray &after); // 替换部分字节数组
QByteArray &replace(int pos, int len, const char *after, int alen); // 替换部分字节数组
QByteArray &replace(const QByteArray &before, const QByteArray &after); // 替换字节数组
QByteArray &replace(const char *before, int bsize, const char *after, int asize); // 替换字节数组
QByteArray &replace(char before, const QByteArray &after); // 替换字符
QByteArray &replace(char before, const char *after); // 替换字符
QByteArray &replace(char before, const char *after, int size); // 替换字符
QByteArray &replace(char before, char after); // 替换字符
QList<QByteArray> split(char sep) const; // 分割字节数组
bool startsWith(const QByteArray &ba) const; // 检查是否以指定字节数组开始
bool startsWith(const char *str) const; // 检查是否以指定字符串开始
bool startsWith(char ch) const; // 检查是否以指定字符开始
bool endsWith(const QByteArray &ba) const; // 检查是否以指定字节数组结束
bool endsWith(const char *str) const; // 检查是否以指定字符串结束
bool endsWith(char ch) const; // 检查是否以指定字符结束
QByteArray left(int len) const; // 返回左边部分字节数组
QByteArray right(int len) const; // 返回右边部分字节数组
QByteArray mid(int pos, int len = -1) const; // 返回中间部分字节数组
QByteArray chopped(int len) const; // 返回去掉末尾部分的字节数组
void chop(int n); // 去掉末尾部分
QByteArray trimmed() const; // 返回修剪后的字节数组
QByteArray simplified() const; // 返回简化后的字节数组
int indexOf(const QByteArray &ba, int from = 0) const; // 查找字节数组的索引
int indexOf(const char *str, int from = 0) const; // 查找字符串的索引
int indexOf(char ch, int from = 0) const; // 查找字符的索引
int lastIndexOf(const QByteArray &ba, int from = -1) const; // 查找字节数组的最后一个索引
int lastIndexOf(const char *str, int from = -1) const; // 查找字符串的最后一个索引
int lastIndexOf(char ch, int from = -1) const; // 查找字符的最后一个索引
bool contains(const QByteArray &ba) const; // 检查是否包含字节数组
bool contains(const char *str) const; // 检查是否包含字符串
bool contains(char ch) const; // 检查是否包含字符
int count(const QByteArray &ba) const; // 返回字节数组的数量
int count(const char *str) const; // 返回字符串的数量
int count(char ch) const; // 返回字符的数量
int count() const; // 返回字节数组的大小
QByteArray toLower() const; // 转换为小写
QByteArray toUpper() const; // 转换为大写
QByteArray trimmed() const; // 返回修剪后的字节数组
QByteArray simplified() const; // 返回简化后的字节数组
QByteArray leftJustified(int width, char fill = ' ', bool truncate = false) const; // 左对齐字节数组
QByteArray rightJustified(int width, char fill = ' ', bool truncate = false) const; // 右对齐字节数组
QByteArray &fill(char ch, int size = -1); // 填充字节数组
char *data(); // 返回数据指针
const char *data() const; // 返回数据指针
const char *constData() const; // 返回常量数据指针
void detach(); // 分离数据
bool isDetached() const; // 检查数据是否分离
void truncate(int pos); // 截断字节数组
void chop(int n); // 去掉末尾部分
int length() const; // 返回字节数组的长度
int size() const; // 返回字节数组的大小
bool isEmpty() const; // 检查字节数组是否为空
bool isNull() const; // 检查字节数组是否为空
QByteArray &append(const QByteArray &ba); // 在后面添加字节数组
QByteArray &append(const char *str); // 在后面添加字符串
QByteArray &append(const char *str, int len); // 在后面添加字符串的一部分
QByteArray &append(char ch); // 在后面添加字符
QByteArray &prepend(const QByteArray &ba); // 在前面添加字节数组
QByteArray &prepend(const char *str); // 在前面添加字符串
QByteArray &prepend(const char *str, int len); // 在前面添加字符串的一部分
QByteArray &prepend(char ch); // 在前面添加字符
QByteArray &insert(int i, const QByteArray &ba); // 插入字节数组
QByteArray &insert(int i, const char *str); // 插入字符串
QByteArray &insert(int i, const char *str, int len); // 插入字符串的一部分
QByteArray &insert(int i, char ch); // 插入字符
QByteArray &remove(int pos, int len); // 移除部分字节数组
QByteArray &replace(int pos, int len, const QByteArray &after); // 替换部分字节数组
QByteArray &replace(int pos, int len, const char *after, int alen); // 替换部分字节数组
QByteArray &replace(const QByteArray &before, const QByteArray &after); // 替换字节数组
QByteArray &replace(const char *before, int bsize, const char *after, int asize); // 替换字节数组
QByteArray &replace(char before, const QByteArray &after); // 替换字符
QByteArray &replace(char before, const char *after); // 替换字符
QByteArray &replace(char before, const char *after, int size); // 替换字符
QByteArray &replace(char before, char after); // 替换字符
QList<QByteArray> split(char sep) const; // 分割字节数组
bool startsWith(const QByteArray &ba) const; // 检查是否以指定字节数组开始
bool startsWith(const char *str) const; // 检查是否以指定字符串开始
bool startsWith(char ch) const; // 检查是否以指定字符开始
bool endsWith(const QByteArray &ba) const; // 检查是否以指定字节数组结束
bool endsWith(const char *str) const; // 检查是否以指定字符串结束
bool endsWith(char ch) const; // 检查是否以指定字符结束
QByteArray left(int len) const; // 返回左边部分字节数组
QByteArray right(int len) const; // 返回右边部分字节数组
QByteArray mid(int pos, int len = -1) const; // 返回中间部分字节数组
QByteArray chopped(int len) const; // 返回去掉末尾部分的字节数组
void chop(int n); // 去掉末尾部分
QByteArray trimmed() const; // 返回修剪后的字节数组
QByteArray simplified() const; // 返回简化后的字节数组
int indexOf(const QByteArray &ba, int from = 0) const; // 查找字节数组的索引
int indexOf(const char *str, int from = 0) const; // 查找字符串的索引
int indexOf(char ch, int from = 0) const; // 查找字符的索引
int lastIndexOf(const QByteArray &ba, int from = -1) const; // 查找字节数组的最后一个索引

3. QVariant 类用于存储任意数据类型。类似于 C++ 的 std::any。

// QVariant 类是 Qt 框架中用于存储不同类型数据的重要类。以下是 QVariant 类的所有成员函数和枚举类型的详细列表：

// 枚举类型
enum Type {
    Invalid,       // 无效类型
    Bool,          // 布尔类型
    Int,           // 整型
    UInt,          // 无符号整型
    LongLong,      // 长整型
    ULongLong,     // 无符号长整型
    Double,        // 双精度浮点型
    Char,          // 字符类型
    Map,           // 映射类型
    List,          // 列表类型
    String,        // 字符串类型
    StringList,    // 字符串列表类型
    ByteArray,     // 字节数组类型
    BitArray,      // 位数组类型
    Date,          // 日期类型
    Time,          // 时间类型
    DateTime,      // 日期时间类型
    Url,           // URL类型
    Locale,        // 本地化类型
    Rect,          // 矩形类型
    RectF,         // 浮点矩形类型
    Size,          // 尺寸类型
    SizeF,         // 浮点尺寸类型
    Line,          // 线段类型
    LineF,         // 浮点线段类型
    Point,         // 点类型
    PointF,        // 浮点点类型
    RegExp,        // 正则表达式类型
    RegularExpression, // 正则表达式类型
    Hash,          // 哈希类型
    EasingCurve,   // 缓和曲线类型
    Uuid,          // UUID类型
    ModelIndex,    // 模型索引类型
    LastType = ModelIndex // 最后一个类型
};

// 构造函数
QVariant(); // 默认构造函数
QVariant(Type type); // 指定类型的构造函数
QVariant(int typeOrUserType, const void *copy); // 指定类型或用户类型的构造函数
QVariant(const QVariant &other); // 拷贝构造函数
QVariant(QVariant &&other) noexcept; // 移动构造函数
QVariant(bool val); // 布尔类型构造函数
QVariant(int val); // 整型构造函数
QVariant(uint val); // 无符号整型构造函数
QVariant(qlonglong val); // 长整型构造函数
QVariant(qulonglong val); // 无符号长整型构造函数
QVariant(double val); // 双精度浮点型构造函数
QVariant(const char *val); // 字符串构造函数
QVariant(const QByteArray &val); // 字节数组构造函数
QVariant(const QBitArray &val); // 位数组构造函数
QVariant(const QString &val); // 字符串构造函数
QVariant(const QStringList &val); // 字符串列表构造函数
QVariant(const QChar &val); // 字符构造函数
QVariant(const QDate &val); // 日期构造函数
QVariant(const QTime &val); // 时间构造函数
QVariant(const QDateTime &val); // 日期时间构造函数
QVariant(const QList<QVariant> &val); // 变体列表构造函数
QVariant(const QMap<QString, QVariant> &val); // 变体映射构造函数
QVariant(const QHash<QString, QVariant> &val); // 变体哈希构造函数
QVariant(const QSize &val); // 尺寸构造函数
QVariant(const QSizeF &val); // 浮点尺寸构造函数
QVariant(const QPoint &val); // 点构造函数
QVariant(const QPointF &val); // 浮点点构造函数
QVariant(const QRect &val); // 矩形构造函数
QVariant(const QRectF &val); // 浮点矩形构造函数
QVariant(const QLine &val); // 线段构造函数
QVariant(const QLineF &val); // 浮点线段构造函数
QVariant(const QUrl &val); // URL构造函数
QVariant(const QLocale &val); // 本地化构造函数
QVariant(const QRegExp &val); // 正则表达式构造函数
QVariant(const QRegularExpression &val); // 正则表达式构造函数
QVariant(const QJsonValue &val); // JSON值构造函数
QVariant(const QJsonObject &val); // JSON对象构造函数
QVariant(const QJsonArray &val); // JSON数组构造函数
QVariant(const QJsonDocument &val); // JSON文档构造函数
QVariant(const QEasingCurve &val); // 缓和曲线构造函数
QVariant(const QUuid &val); // UUID构造函数
QVariant(const QModelIndex &val); // 模型索引构造函数

// 析构函数
~QVariant(); // 析构函数

// 公共成员函数
QVariant &operator=(const QVariant &other); // 赋值运算符
QVariant &operator=(QVariant &&other) noexcept; // 移动赋值运算符
void swap(QVariant &other) noexcept; // 交换函数
bool operator==(const QVariant &other) const; // 相等运算符
bool operator!=(const QVariant &other) const; // 不等运算符
bool isValid() const; // 检查变体是否有效
bool isNull() const; // 检查变体是否为空
Type type() const; // 返回变体类型
const char *typeName() const; // 返回类型名称
int userType() const; // 返回用户类型
void clear(); // 清空变体
bool convert(int targetTypeId); // 转换变体类型
bool canConvert(int targetTypeId) const; // 检查是否可以转换为目标类型
bool canConvert(Type targetType) const; // 检查是否可以转换为目标类型
template <typename T> bool canConvert() const; // 检查是否可以转换为指定类型
template <typename T> T value() const; // 获取变体值
template <typename T> T to() const; // 转换为指定类型
bool toBool() const; // 转换为布尔类型
int toInt() const; // 转换为整型
uint toUInt() const; // 转换为无符号整型
qlonglong toLongLong() const; // 转换为长整型
qulonglong toULongLong() const; // 转换为无符号长整型
double toDouble() const; // 转换为双精度浮点型
QChar toChar() const; // 转换为字符类型
QByteArray toByteArray() const; // 转换为字节数组类型
QBitArray toBitArray() const; // 转换为位数组类型
QString toString() const; // 转换为字符串类型
QStringList toStringList() const; // 转换为字符串列表类型
QDate toDate() const; // 转换为日期类型
QTime toTime() const; // 转换为时间类型
QDateTime toDateTime() const; // 转换为日期时间类型
QList<QVariant> toList() const; // 转换为变体列表类型
QMap<QString, QVariant> toMap() const; // 转换为变体映射类型
QHash<QString, QVariant> toHash() const; // 转换为变体哈希类型
QSize toSize() const; // 转换为尺寸类型
QSizeF toSizeF() const; // 转换为浮点尺寸类型
QPoint toPoint() const; // 转换为点类型
QPointF toPointF() const; // 转换为浮点点类型
QRect toRect() const; // 转换为矩形类型
QRectF toRectF() const; // 转换为浮点矩形类型
QLine toLine() const; // 转换为线段类型
QLineF toLineF() const; // 转换为浮点线段类型
QUrl toUrl() const; // 转换为URL类型
QLocale toLocale() const; // 转换为本地化类型
QRegExp toRegExp() const; // 转换为正则表达式类型
QRegularExpression toRegularExpression() const; // 转换为正则表达式类型
QJsonValue toJsonValue() const; // 转换为JSON值类型
QJsonObject toJsonObject() const; // 转换为JSON对象类型
QJsonArray toJsonArray() const; // 转换为JSON数组类型
QJsonDocument toJsonDocument() const; // 转换为JSON文档类型
QEasingCurve toEasingCurve() const; // 转换为缓和曲线类型
QUuid toUuid() const; // 转换为UUID类型
QModelIndex toModelIndex() const; // 转换为模型索引类型
QVariant fromValue(const T &value); // 从指定值创建变体
template <typename T> QVariant fromValue(const T &value); // 从指定值创建变体

容器

1. QMap 类是 Qt 框架中用于存储键值对的类，提供了对键值对的各种操作和处理功能

// QMap 类是 Qt 框架中用于键值对存储的重要类。以下是 QMap 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QMap();
QMap(const QMap<Key, T> &other);
QMap(QMap<Key, T> &&other) noexcept;
QMap(std::initializer_list<std::pair<Key, T>> list);

// 析构函数
~QMap();

// 公共成员函数
QMap<Key, T> &operator=(const QMap<Key, T> &other);
QMap<Key, T> &operator=(QMap<Key, T> &&other) noexcept;
void swap(QMap<Key, T> &other) noexcept;
bool operator==(const QMap<Key, T> &other) const;
bool operator!=(const QMap<Key, T> &other) const;
int size() const; // 返回映射的大小
bool isEmpty() const; // 检查映射是否为空
void detach(); // 分离数据
bool isDetached() const; // 检查数据是否分离
void setSharable(bool sharable); // 设置是否共享
bool isSharedWith(const QMap<Key, T> &other) const; // 检查是否共享数据
void clear(); // 清空映射
int remove(const Key &key); // 移除键对应的值
T take(const Key &key); // 获取并移除键对应的值
bool contains(const Key &key) const; // 检查是否包含某个键
const Key key(const T &value) const; // 返回值对应的键
const T value(const Key &key) const; // 返回键对应的值
const T value(const Key &key, const T &defaultValue) const; // 返回键对应的值，如果不存在则返回默认值
QList<Key> keys() const; // 返回所有键的列表
QList<T> values() const; // 返回所有值的列表
int count(const Key &key) const; // 返回键的数量
bool isEmpty() const; // 检查映射是否为空
QMap::iterator find(const Key &key); // 查找键
QMap::const_iterator find(const Key &key) const; // 查找键
QMap::iterator constFind(const Key &key) const; // 查找键
QMap::iterator begin(); // 返回开始迭代器
QMap::const_iterator begin() const; // 返回开始迭代器
QMap::const_iterator cbegin() const; // 返回开始迭代器
QMap::iterator end(); // 返回结束迭代器
QMap::const_iterator end() const; // 返回结束迭代器
QMap::const_iterator cend() const; // 返回结束迭代器
QMap::iterator insert(const Key &key, const T &value); // 插入键值对
QMap::iterator insertMulti(const Key &key, const T &value); // 插入多个键值对
QMap<Key, T> &unite(const QMap<Key, T> &other); // 合并映射
QMap::iterator erase(QMap::iterator pos); // 移除迭代器位置的元素
QMap::iterator insert(QMap::const_iterator pos, const Key &key, const T &value); // 在指定位置插入键值对
QMap::const_iterator lowerBound(const Key &key) const; // 返回键的下界
QMap::iterator lowerBound(const Key &key); // 返回键的下界
QMap::const_iterator upperBound(const Key &key) const; // 返回键的上界
QMap::iterator upperBound(const Key &key); // 返回键的上界
const T &operator[](const Key &key) const; // 返回键对应的值
T &operator[](const Key &key); // 返回键对应的值
QList<Key> uniqueKeys() const; // 返回唯一键的列表
QList<T> values(const Key &key) const; // 返回键对应的所有值的列表
QMap<Key, T> &operator+=(const QMap<Key, T> &other); // 合并映射
QMap<Key, T> operator+(const QMap<Key, T> &other) const; // 合并映射

// 迭代器类
class iterator {
public:
    iterator();
    iterator(const iterator &other);
    ~iterator();
    iterator &operator=(const iterator &other);
    bool operator==(const iterator &other) const;
    bool operator!=(const iterator &other) const;
    bool operator<(const iterator &other) const;
    bool operator<=(const iterator &other) const;
    bool operator>(const iterator &other) const;
    bool operator>=(const iterator &other) const;
    std::pair<Key, T> &operator*() const;
    std::pair<Key, T> *operator->() const;
    iterator &operator++();
    iterator operator++(int);
    iterator &operator--();
    iterator operator--(int);
    iterator &operator+=(int j);
    iterator &operator-=(int j);
    iterator operator+(int j) const;
    iterator operator-(int j) const;
    int operator-(iterator other) const;
};

class const_iterator {
public:
    const_iterator();
    const_iterator(const const_iterator &other);
    const_iterator(const iterator &other);
    ~const_iterator();
    const_iterator &operator=(const const_iterator &other);
    bool operator==(const const_iterator &other) const;
    bool operator!=(const const_iterator &other) const;
    bool operator<(const const_iterator &other) const;
    bool operator<=(const const_iterator &other) const;
    bool operator>(const const_iterator &other) const;
    bool operator>=(const const_iterator &other) const;
    const std::pair<Key, T> &operator*() const;
    const std::pair<Key, T> *operator->() const;
    const_iterator &operator++();
    const_iterator operator++(int);
    const_iterator &operator--();
    const_iterator operator--(int);
    const_iterator &operator+=(int j);
    const_iterator &operator-=(int j);
    const_iterator operator+(int j) const;
    const_iterator operator-(int j) const;
    int operator-(const_iterator other) const;
};

2. QHash 类是 Qt 框架中用于存储键值对的类，提供了对键值对的各种操作和处理功能

// QHash 类是 Qt 框架中用于哈希表存储的重要类。以下是 QHash 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QHash();
QHash(const QHash<Key, T> &other);
QHash(QHash<Key, T> &&other) noexcept;
QHash(std::initializer_list<std::pair<Key, T>> list);

// 析构函数
~QHash();

// 公共成员函数
QHash<Key, T> &operator=(const QHash<Key, T> &other);
QHash<Key, T> &operator=(QHash<Key, T> &&other) noexcept;
void swap(QHash<Key, T> &other) noexcept;
bool operator==(const QHash<Key, T> &other) const;
bool operator!=(const QHash<Key, T> &other) const;
int size() const; // 返回哈希表的大小
bool isEmpty() const; // 检查哈希表是否为空
void detach(); // 分离数据
bool isDetached() const; // 检查数据是否分离
void setSharable(bool sharable); // 设置是否共享
bool isSharedWith(const QHash<Key, T> &other) const; // 检查是否共享数据
void clear(); // 清空哈希表
int remove(const Key &key); // 移除键对应的值
T take(const Key &key); // 获取并移除键对应的值
bool contains(const Key &key) const; // 检查是否包含某个键
const Key key(const T &value) const; // 返回值对应的键
const T value(const Key &key) const; // 返回键对应的值
const T value(const Key &key, const T &defaultValue) const; // 返回键对应的值，如果不存在则返回默认值
QList<Key> keys() const; // 返回所有键的列表
QList<T> values() const; // 返回所有值的列表
int count(const Key &key) const; // 返回键的数量
bool isEmpty() const; // 检查哈希表是否为空
QHash::iterator find(const Key &key); // 查找键
QHash::const_iterator find(const Key &key) const; // 查找键
QHash::iterator constFind(const Key &key) const; // 查找键
QHash::iterator begin(); // 返回开始迭代器
QHash::const_iterator begin() const; // 返回开始迭代器
QHash::const_iterator cbegin() const; // 返回开始迭代器
QHash::iterator end(); // 返回结束迭代器
QHash::const_iterator end() const; // 返回结束迭代器
QHash::const_iterator cend() const; // 返回结束迭代器
QHash::iterator insert(const Key &key, const T &value); // 插入键值对
QHash::iterator insertMulti(const Key &key, const T &value); // 插入多个键值对
QHash<Key, T> &unite(const QHash<Key, T> &other); // 合并哈希表
QHash::iterator erase(QHash::iterator pos); // 移除迭代器位置的元素
QHash::iterator insert(QHash::const_iterator pos, const Key &key, const T &value); // 在指定位置插入键值对
QHash::const_iterator lowerBound(const Key &key) const; // 返回键的下界
QHash::iterator lowerBound(const Key &key); // 返回键的下界
QHash::const_iterator upperBound(const Key &key) const; // 返回键的上界
QHash::iterator upperBound(const Key &key); // 返回键的上界
const T &operator[](const Key &key) const; // 返回键对应的值
T &operator[](const Key &key); // 返回键对应的值
QList<Key> uniqueKeys() const; // 返回唯一键的列表
QList<T> values(const Key &key) const; // 返回键对应的所有值的列表
QHash<Key, T> &operator+=(const QHash<Key, T> &other); // 合并哈希表
QHash<Key, T> operator+(const QHash<Key, T> &other) const; // 合并哈希表

// 迭代器类
class iterator {
public:
    iterator();
    iterator(const iterator &other);
    ~iterator();
    iterator &operator=(const iterator &other);
    bool operator==(const iterator &other) const;
    bool operator!=(const iterator &other) const;
    std::pair<Key, T> &operator*() const;
    std::pair<Key, T> *operator->() const;
    iterator &operator++();
    iterator operator++(int);
    iterator &operator--();
    iterator operator--(int);
    iterator &operator+=(int j);
    iterator &operator-=(int j);
    iterator operator+(int j) const;
    iterator operator-(int j) const;
    int operator-(iterator other) const;
};

class const_iterator {
public:
    const_iterator();
    const_iterator(const const_iterator &other);
    const_iterator(const iterator &other);
    ~const_iterator();
    const_iterator &operator=(const const_iterator &other);
    bool operator==(const const_iterator &other) const;
    bool operator!=(const const_iterator &other) const;
    const std::pair<Key, T> &operator*() const;
    const std::pair<Key, T> *operator->() const;
    const_iterator &operator++();
    const_iterator operator++(int);
    const_iterator &operator--();
    const_iterator operator--(int);
    const_iterator &operator+=(int j);
    const_iterator &operator-=(int j);
    const_iterator operator+(int j) const;
    const_iterator operator-(int j) const;
    int operator-(const_iterator other) const;
};

3. QVector 类是 Qt 框架中用于存储一系列数据元素的类，提供了对元素的各种操作和处理功能

// QVector 类是 Qt 框架中用于动态数组存储的重要类。以下是 QVector 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QVector();
QVector(int size);
QVector(int size, const T &value);
QVector(const QVector<T> &other);
QVector(QVector<T> &&other) noexcept;
QVector(std::initializer_list<T> args);
QVector(const QList<T> &list);

// 析构函数
~QVector();

// 公共成员函数
QVector<T> &operator=(const QVector<T> &other);
QVector<T> &operator=(QVector<T> &&other) noexcept;
void swap(QVector<T> &other) noexcept;
bool operator==(const QVector<T> &other) const;
bool operator!=(const QVector<T> &other) const;
int size() const; // 返回向量的大小
bool isEmpty() const; // 检查向量是否为空
void resize(int size); // 调整向量的大小
int capacity() const; // 返回向量的容量
void reserve(int size); // 预留容量
void squeeze(); // 压缩向量
void detach(); // 分离数据
bool isDetached() const; // 检查数据是否分离
void setSharable(bool sharable); // 设置是否共享
bool isSharedWith(const QVector<T> &other) const; // 检查是否共享数据
void clear(); // 清空向量
const T &at(int i) const; // 返回指定位置的元素
T &operator[](int i); // 返回指定位置的元素
const T &operator[](int i) const; // 返回指定位置的元素
QVector<T> &operator+=(const QVector<T> &other); // 合并向量
QVector<T> operator+(const QVector<T> &other) const; // 合并向量
QVector<T> &operator+=(const T &value); // 添加元素
QVector<T> &append(const T &value); // 添加元素
QVector<T> &append(const QVector<T> &value); // 添加向量
QVector<T> &prepend(const T &value); // 在前面添加元素
QVector<T> &insert(int i, const T &value); // 插入元素
QVector<T> &insert(int i, int count, const T &value); // 插入多个元素
QVector<T>::iterator insert(QVector<T>::iterator before, const T &value); // 插入元素
QVector<T>::iterator insert(QVector<T>::iterator before, int count, const T &value); // 插入多个元素
void replace(int i, const T &value); // 替换元素
void remove(int i); // 移除元素
void remove(int i, int count); // 移除多个元素
int removeAll(const T &value); // 移除所有指定元素
bool removeOne(const T &value); // 移除第一个指定元素
T takeAt(int i); // 获取并移除元素
T takeFirst(); // 获取并移除第一个元素
T takeLast(); // 获取并移除最后一个元素
void move(int from, int to); // 移动元素
void swap(int i, int j); // 交换元素
int indexOf(const T &value, int from = 0) const; // 查找元素的索引
int lastIndexOf(const T &value, int from = -1) const; // 查找元素的最后一个索引
bool contains(const T &value) const; // 检查是否包含元素
int count(const T &value) const; // 返回元素的数量
QVector<T> mid(int pos, int length = -1) const; // 返回中间部分向量
T value(int i) const; // 返回指定位置的元素
T value(int i, const T &defaultValue) const; // 返回指定位置的元素，如果不存在则返回默认值
void push_back(const T &value); // 在后面添加元素
void push_front(const T &value); // 在前面添加元素
T &first(); // 返回第一个元素
const T &first() const; // 返回第一个元素
T &last(); // 返回最后一个元素
const T &last() const; // 返回最后一个元素
void pop_front(); // 移除第一个元素
void pop_back(); // 移除最后一个元素
bool startsWith(const T &value) const; // 检查是否以指定元素开始
bool endsWith(const T &value) const; // 检查是否以指定元素结束
QVector<T> &fill(const T &value, int size = -1); // 填充向量
QVector<T> fromList(const QList<T> &list); // 从列表创建向量
QList<T> toList() const; // 转换为列表
QVector<T> fromStdVector(const std::vector<T> &vector); // 从标准向量创建向量
std::vector<T> toStdVector() const; // 转换为标准向量

// 迭代器类
class iterator {
public:
    iterator();
    iterator(const iterator &other);
    ~iterator();
    iterator &operator=(const iterator &other);
    bool operator==(const iterator &other) const;
    bool operator!=(const iterator &other) const;
    bool operator<(const iterator &other) const;
    bool operator<=(const iterator &other) const;
    bool operator>(const iterator &other) const;
    bool operator>=(const iterator &other) const;
    T &operator*() const;
    T *operator->() const;
    iterator &operator++();
    iterator operator++(int);
    iterator &operator--();
    iterator operator--(int);
    iterator &operator+=(int j);
    iterator &operator-=(int j);
    iterator operator+(int j) const;
    iterator operator-(int j) const;
    int operator-(iterator other) const;
};

class const_iterator {
public:
    const_iterator();
    const_iterator(const const_iterator &other);
    const_iterator(const iterator &other);
    ~const_iterator();
    const_iterator &operator=(const const_iterator &other);
    bool operator==(const const_iterator &other) const;
    bool operator!=(const const_iterator &other) const;
    bool operator<(const const_iterator &other) const;
    bool operator<=(const const_iterator &other) const;
    bool operator>(const const_iterator &other) const;
    bool operator>=(const const_iterator &other) const;
    const T &operator*() const;
    const T *operator->() const;
    const_iterator &operator++();
    const_iterator operator++(int);
    const_iterator &operator--();
    const_iterator operator--(int);
    const_iterator &operator+=(int j);
    const_iterator &operator-=(int j);
    const_iterator operator+(int j) const;
    const_iterator operator-(int j) const;
    int operator-(const_iterator other) const;
};

4. QList 类用于动态列表存储的重要类。

// QList 类是 Qt 框架中用于动态列表存储的重要类。以下是 QList 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QList();
QList(const QList<T> &other);
QList(QList<T> &&other) noexcept;
QList(std::initializer_list<T> args);
QList(const QVector<T> &vector);

// 析构函数
~QList();

// 公共成员函数
QList<T> &operator=(const QList<T> &other);
QList<T> &operator=(QList<T> &&other) noexcept;
void swap(QList<T> &other) noexcept;
bool operator==(const QList<T> &other) const;
bool operator!=(const QList<T> &other) const;
int size() const; // 返回列表的大小
bool isEmpty() const; // 检查列表是否为空
void resize(int size); // 调整列表的大小
int capacity() const; // 返回列表的容量
void reserve(int size); // 预留容量
void squeeze(); // 压缩列表
void detach(); // 分离数据
bool isDetached() const; // 检查数据是否分离
void setSharable(bool sharable); // 设置是否共享
bool isSharedWith(const QList<T> &other) const; // 检查是否共享数据
void clear(); // 清空列表
const T &at(int i) const; // 返回指定位置的元素
T &operator[](int i); // 返回指定位置的元素
const T &operator[](int i) const; // 返回指定位置的元素
QList<T> &operator+=(const QList<T> &other); // 合并列表
QList<T> operator+(const QList<T> &other) const; // 合并列表
QList<T> &operator+=(const T &value); // 添加元素
QList<T> &append(const T &value); // 添加元素
QList<T> &append(const QList<T> &value); // 添加列表
QList<T> &prepend(const T &value); // 在前面添加元素
QList<T> &insert(int i, const T &value); // 插入元素
QList<T> &insert(int i, int count, const T &value); // 插入多个元素
QList<T>::iterator insert(QList<T>::iterator before, const T &value); // 插入元素
QList<T>::iterator insert(QList<T>::iterator before, int count, const T &value); // 插入多个元素
void replace(int i, const T &value); // 替换元素
void remove(int i); // 移除元素
void remove(int i, int count); // 移除多个元素
int removeAll(const T &value); // 移除所有指定元素
bool removeOne(const T &value); // 移除第一个指定元素
T takeAt(int i); // 获取并移除元素
T takeFirst(); // 获取并移除第一个元素
T takeLast(); // 获取并移除最后一个元素
void move(int from, int to); // 移动元素
void swap(int i, int j); // 交换元素
int indexOf(const T &value, int from = 0) const; // 查找元素的索引
int lastIndexOf(const T &value, int from = -1) const; // 查找元素的最后一个索引
bool contains(const T &value) const; // 检查是否包含元素
int count(const T &value) const; // 返回元素的数量
QList<T> mid(int pos, int length = -1) const; // 返回中间部分列表
T value(int i) const; // 返回指定位置的元素
T value(int i, const T &defaultValue) const; // 返回指定位置的元素，如果不存在则返回默认值
void push_back(const T &value); // 在后面添加元素
void push_front(const T &value); // 在前面添加元素
T &first(); // 返回第一个元素
const T &first() const; // 返回第一个元素
T &last(); // 返回最后一个元素
const T &last() const; // 返回最后一个元素
void pop_front(); // 移除第一个元素
void pop_back(); // 移除最后一个元素
bool startsWith(const T &value) const; // 检查是否以指定元素开始
bool endsWith(const T &value) const; // 检查是否以指定元素结束
QList<T> &fill(const T &value, int size = -1); // 填充列表
QList<T> fromVector(const QVector<T> &vector); // 从向量创建列表
QVector<T> toVector() const; // 转换为向量
QList<T> fromSet(const QSet<T> &set); // 从集合创建列表
QSet<T> toSet() const; // 转换为集合
QList<T> fromStdList(const std::list<T> &list); // 从标准列表创建列表
std::list<T> toStdList() const; // 转换为标准列表

// 迭代器类
class iterator {
public:
    iterator();
    iterator(const iterator &other);
    ~iterator();
    iterator &operator=(const iterator &other);
    bool operator==(const iterator &other) const;
    bool operator!=(const iterator &other) const;
    bool operator<(const iterator &other) const;
    bool operator<=(const iterator &other) const;
    bool operator>(const iterator &other) const;
    bool operator>=(const iterator &other) const;
    T &operator*() const;
    T *operator->() const;
    iterator &operator++();
    iterator operator++(int);
    iterator &operator--();
    iterator operator--(int);
    iterator &operator+=(int j);
    iterator &operator-=(int j);
    iterator operator+(int j) const;
    iterator operator-(int j) const;
    int operator-(iterator other) const;
};

class const_iterator {
public:
    const_iterator();
    const_iterator(const const_iterator &other);
    const_iterator(const iterator &other);
    ~const_iterator();
    const_iterator &operator=(const const_iterator &other);
    bool operator==(const const_iterator &other) const;
    bool operator!=(const const_iterator &other) const;
    bool operator<(const const_iterator &other) const;
    bool operator<=(const const_iterator &other) const;
    bool operator>(const const_iterator &other) const;
    bool operator>=(const const_iterator &other) const;
    const T &operator*() const;
    const T *operator->() const;
    const_iterator &operator++();
    const_iterator operator++(int);
    const_iterator &operator--();
    const_iterator operator--(int);
    const_iterator &operator+=(int j);
    const_iterator &operator-=(int j);
    const_iterator operator+(int j) const;
    const_iterator operator-(int j) const;
    int operator-(const_iterator other) const;
};

日期和时间类

1. QDate 类用于表示日期。

// QDate 类是 Qt 框架中用于日期操作的重要类。以下是 QDate 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QDate(); // 默认构造函数，创建一个无效的日期
QDate(int year, int month, int day); // 指定年、月、日的构造函数

// 析构函数
~QDate(); // 析构函数

// 公共成员函数
QDate &operator=(const QDate &other); // 赋值运算符
void swap(QDate &other) noexcept; // 交换函数
bool operator==(const QDate &other) const; // 相等运算符
bool operator!=(const QDate &other) const; // 不等运算符
bool operator<(const QDate &other) const; // 小于运算符
bool operator<=(const QDate &other) const; // 小于等于运算符
bool operator>(const QDate &other) const; // 大于运算符
bool operator>=(const QDate &other) const; // 大于等于运算符
bool isNull() const; // 检查日期是否为空
bool isValid() const; // 检查日期是否有效
int year() const; // 返回年份
int month() const; // 返回月份
int day() const; // 返回日
int dayOfWeek() const; // 返回星期几
int dayOfYear() const; // 返回一年中的第几天
int daysInMonth() const; // 返回一个月中的天数
int daysInYear() const; // 返回一年中的天数
QString toString(const QString &format) const; // 按指定格式返回日期字符串
QString toString(Qt::DateFormat format = Qt::TextDate) const; // 按指定格式返回日期字符串
bool setDate(int year, int month, int day); // 设置日期
QDate addDays(qint64 days) const; // 增加天数
QDate addMonths(int months) const; // 增加月数
QDate addYears(int years) const; // 增加年数
qint64 daysTo(const QDate &d) const; // 返回两个日期之间的天数
bool isLeapYear(int year) const; // 检查是否为闰年
static QDate currentDate(); // 返回当前日期
static QDate fromString(const QString &string, Qt::DateFormat format = Qt::TextDate); // 从字符串创建日期
static QDate fromString(const QString &string, const QString &format); // 从字符串和格式创建日期
static bool isValid(int year, int month, int day); // 检查日期是否有效
static QString shortMonthName(int month, QDate::MonthNameType type = QDate::DateFormat); // 返回短月份名称
static QString shortDayName(int weekday, QDate::MonthNameType type = QDate::DateFormat); // 返回短星期名称
static QString longMonthName(int month, QDate::MonthNameType type = QDate::DateFormat); // 返回长月份名称
static QString longDayName(int weekday, QDate::MonthNameType type = QDate::DateFormat); // 返回长星期名称

// 枚举类型
enum MonthNameType {
    DateFormat, // 日期格式
    StandaloneFormat // 独立格式
};

2. QTime 类用于表示时间。

// QTime 类是 Qt 框架中用于时间操作的重要类。以下是 QTime 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QTime(); // 默认构造函数，创建一个无效的时间
QTime(int hour, int minute, int second = 0, int msec = 0); // 指定时、分、秒和毫秒的构造函数

// 析构函数
~QTime(); // 析构函数

// 公共成员函数
QTime &operator=(const QTime &other); // 赋值运算符
void swap(QTime &other) noexcept; // 交换函数
bool operator==(const QTime &other) const; // 相等运算符
bool operator!=(const QTime &other) const; // 不等运算符
bool operator<(const QTime &other) const; // 小于运算符
bool operator<=(const QTime &other) const; // 小于等于运算符
bool operator>(const QTime &other) const; // 大于运算符
bool operator>=(const QTime &other) const; // 大于等于运算符
bool isNull() const; // 检查时间是否为空
bool isValid() const; // 检查时间是否有效
int hour() const; // 返回小时
int minute() const; // 返回分钟
int second() const; // 返回秒
int msec() const; // 返回毫秒
QString toString(const QString &format) const; // 按指定格式返回时间字符串
QString toString(Qt::DateFormat format = Qt::TextDate) const; // 按指定格式返回时间字符串
bool setHMS(int hour, int minute, int second, int msec = 0); // 设置时间
QTime addSecs(int secs) const; // 增加秒数
int secsTo(const QTime &t) const; // 返回两个时间之间的秒数
QTime addMSecs(int msecs) const; // 增加毫秒数
int msecsTo(const QTime &t) const; // 返回两个时间之间的毫秒数
bool start(); // 开始计时
bool restart(); // 重新开始计时
int elapsed() const; // 返回自开始计时以来的毫秒数
static QTime currentTime(); // 返回当前时间
static QTime fromString(const QString &string, Qt::DateFormat format = Qt::TextDate); // 从字符串创建时间
static QTime fromString(const QString &string, const QString &format); // 从字符串和格式创建时间
static bool isValid(int hour, int minute, int second, int msec = 0); // 检查时间是否有效

// 枚举类型
enum TimeFlag {
    NoFlag // 无标志
};

3. QDateTime 类用于表示日期和时间。

// QDateTime 类是 Qt 框架中用于日期和时间操作的重要类。以下是 QDateTime 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QDateTime(); // 默认构造函数，创建一个无效的日期时间
QDateTime(const QDate &date, const QTime &time, Qt::TimeSpec spec = Qt::LocalTime); // 指定日期和时间的构造函数
QDateTime(const QDate &date, const QTime &time, Qt::TimeSpec spec, int offsetSeconds); // 指定日期、时间和偏移秒数的构造函数
QDateTime(const QDate &date, const QTime &time, const QTimeZone &timeZone); // 指定日期、时间和时区的构造函数
QDateTime(const QDateTime &other); // 拷贝构造函数
QDateTime(QDateTime &&other) noexcept; // 移动构造函数

// 析构函数
~QDateTime(); // 析构函数

// 公共成员函数
QDateTime &operator=(const QDateTime &other); // 赋值运算符
QDateTime &operator=(QDateTime &&other) noexcept; // 移动赋值运算符
void swap(QDateTime &other) noexcept; // 交换函数
bool operator==(const QDateTime &other) const; // 相等运算符
bool operator!=(const QDateTime &other) const; // 不等运算符
bool operator<(const QDateTime &other) const; // 小于运算符
bool operator<=(const QDateTime &other) const; // 小于等于运算符
bool operator>(const QDateTime &other) const; // 大于运算符
bool operator>=(const QDateTime &other) const; // 大于等于运算符
bool isNull() const; // 检查日期时间是否为空
bool isValid() const; // 检查日期时间是否有效
QDate date() const; // 返回日期部分
QTime time() const; // 返回时间部分
Qt::TimeSpec timeSpec() const; // 返回时间规范
int offsetFromUtc() const; // 返回UTC偏移秒数
QTimeZone timeZone() const; // 返回时区
QString toString(const QString &format) const; // 按指定格式返回日期时间字符串
QString toString(Qt::DateFormat format = Qt::TextDate) const; // 按指定格式返回日期时间字符串
bool setDate(const QDate &date); // 设置日期
bool setTime(const QTime &time); // 设置时间
bool setTimeSpec(Qt::TimeSpec spec); // 设置时间规范
bool setOffsetFromUtc(int offsetSeconds); // 设置UTC偏移秒数
bool setTimeZone(const QTimeZone &toZone); // 设置时区
QDateTime addDays(qint64 days) const; // 增加天数
QDateTime addMonths(int months) const; // 增加月数
QDateTime addYears(int years) const; // 增加年数
QDateTime addSecs(qint64 secs) const; // 增加秒数
QDateTime addMSecs(qint64 msecs) const; // 增加毫秒数
qint64 daysTo(const QDateTime &dt) const; // 返回两个日期时间之间的天数
qint64 secsTo(const QDateTime &dt) const; // 返回两个日期时间之间的秒数
qint64 msecsTo(const QDateTime &dt) const; // 返回两个日期时间之间的毫秒数
bool isDaylightTime() const; // 检查是否为夏令时
QDateTime toTimeSpec(Qt::TimeSpec spec) const; // 转换为指定时间规范
QDateTime toLocalTime() const; // 转换为本地时间
QDateTime toUTC() const; // 转换为UTC时间
QDateTime toOffsetFromUtc(int offsetSeconds) const; // 转换为指定UTC偏移时间
QDateTime toTimeZone(const QTimeZone &timeZone) const; // 转换为指定时区时间
static QDateTime currentDateTime(); // 返回当前日期时间
static QDateTime currentDateTimeUtc(); // 返回当前UTC日期时间
static QDateTime fromString(const QString &string, Qt::DateFormat format = Qt::TextDate); // 从字符串创建日期时间
static QDateTime fromString(const QString &string, const QString &format); // 从字符串和格式创建日期时间
static QDateTime fromMSecsSinceEpoch(qint64 msecs); // 从自纪元以来的毫秒数创建日期时间
static QDateTime fromSecsSinceEpoch(qint64 secs); // 从自纪元以来的秒数创建日期时间
static bool isValid(const QDate &date, const QTime &time); // 检查日期时间是否有效
static qint64 currentMSecsSinceEpoch(); // 返回自纪元以来的当前毫秒数
static qint64 currentSecsSinceEpoch(); // 返回自纪元以来的当前秒数

// 枚举类型
enum TimeSpec {
    LocalTime, // 本地时间
    UTC, // UTC时间
    OffsetFromUTC, // UTC偏移时间
    TimeZone // 时区时间
};

文件和流类

1. QFile 类用于文件操作。

// QFile 类是 Qt 框架中用于文件操作的重要类。以下是 QFile 类的所有成员函数和枚举类型的详细列表：

// 枚举类型
enum FileError {
    NoError, // 没有错误
    ReadError, // 读取错误
    WriteError, // 写入错误
    FatalError, // 致命错误
    ResourceError, // 资源错误
    OpenError, // 打开错误
    AbortError, // 中止错误
    TimeOutError, // 超时错误
    UnspecifiedError, // 未指定错误
    RemoveError, // 删除错误
    RenameError, // 重命名错误
    PositionError, // 位置错误
    ResizeError, // 调整大小错误
    PermissionsError, // 权限错误
    CopyError // 复制错误
};

enum FileHandleFlag {
    AutoCloseHandle, // 自动关闭文件句柄
    DontCloseHandle // 不关闭文件句柄
};

enum MemoryMapFlags {
    NoOptions // 无选项
};

// 构造函数
QFile(); // 默认构造函数
QFile(const QString &name); // 指定文件名的构造函数
QFile(QObject *parent); // 指定父对象的构造函数
QFile(const QString &name, QObject *parent); // 指定文件名和父对象的构造函数

// 析构函数
~QFile(); // 析构函数

// 公共成员函数
bool atEnd() const; // 检查是否在文件末尾
bool copy(const QString &newName); // 复制文件到新名称
bool exists() const; // 检查文件是否存在
bool flush(); // 刷新文件缓冲区
int handle() const; // 返回文件句柄
bool isOpen() const; // 检查文件是否打开
bool isReadable() const; // 检查文件是否可读
bool isSequential() const; // 检查文件是否是顺序访问的
bool isTextModeEnabled() const; // 检查文件是否在文本模式下打开
bool isWritable() const; // 检查文件是否可写
bool link(const QString &linkName); // 创建文件的链接
bool open(OpenMode mode); // 以指定模式打开文件
bool open(FILE *f, OpenMode mode, FileHandleFlags handleFlags = DontCloseHandle); // 使用现有文件指针打开文件
bool open(int fd, OpenMode mode, FileHandleFlags handleFlags = DontCloseHandle); // 使用现有文件描述符打开文件
qint64 pos() const; // 返回文件当前位置
bool remove(); // 删除文件
bool rename(const QString &newName); // 重命名文件
bool resize(qint64 sz); // 调整文件大小
void setFileName(const QString &name); // 设置文件名
void setTextModeEnabled(bool enabled); // 设置文件的文本模式
qint64 size() const; // 返回文件大小
bool unmap(uchar *address); // 解除内存映射
uchar *map(qint64 offset, qint64 size, MemoryMapFlags flags = NoOptions); // 内存映射文件
QFileDevice::FileError error() const; // 返回文件错误
void unsetError(); // 清除文件错误
bool close(); // 关闭文件
QByteArray readAll(); // 读取所有数据
qint64 read(char *data, qint64 maxSize); // 读取数据
QByteArray read(qint64 maxSize); // 读取数据
qint64 write(const char *data, qint64 maxSize); // 写入数据
qint64 write(const QByteArray &data); // 写入数据
bool seek(qint64 pos); // 定位到指定位置
bool waitForBytesWritten(int msecs); // 等待数据写入
bool waitForReadyRead(int msecs); // 等待数据可读
QFile::Permissions permissions() const; // 返回文件权限
bool setPermissions(QFile::Permissions permissions); // 设置文件权限

// 静态公共成员函数
static bool copy(const QString &fileName, const QString &newName); // 复制文件
static bool remove(const QString &fileName); // 删除文件
static bool rename(const QString &oldName, const QString &newName); // 重命名文件
static bool resize(const QString &fileName, qint64 sz); // 调整文件大小
static bool exists(const QString &fileName); // 检查文件是否存在
static bool setPermissions(const QString &fileName, QFile::Permissions permissions); // 设置文件权限
static QFile::Permissions permissions(const QString &fileName); // 返回文件权限

// 枚举类型
enum Permission {
    ReadOwner = 0x4000, // 读取所有者权限
    WriteOwner = 0x2000, // 写入所有者权限
    ExeOwner = 0x1000, // 执行所有者权限
    ReadUser = 0x0400, // 读取用户权限
    WriteUser = 0x0200, // 写入用户权限
    ExeUser = 0x0100, // 执行用户权限
    ReadGroup = 0x0040, // 读取组权限
    WriteGroup = 0x0020, // 写入组权限
    ExeGroup = 0x0010, // 执行组权限
    ReadOther = 0x0004, // 读取其他权限
    WriteOther = 0x0002, // 写入其他权限
    ExeOther = 0x0001 // 执行其他权限
};

enum OpenModeFlag {
    NotOpen = 0x0000, // 不打开
    ReadOnly = 0x0001, // 只读
    WriteOnly = 0x0002, // 只写
    ReadWrite = ReadOnly | WriteOnly, // 读写
    Append = 0x0004, // 追加
    Truncate = 0x0008, // 截断
    Text = 0x0010, // 文本模式
    Unbuffered = 0x0020 // 无缓冲
};

Q_DECLARE_FLAGS(OpenMode, OpenModeFlag)
Q_DECLARE_OPERATORS_FOR_FLAGS(QFile::OpenMode)

QDir 类用于目录操作。

class QDir {
public:
    // 构造函数
    QDir(); // 默认构造函数，创建一个空的 QDir 对象
    QDir(const QString &path); // 根据给定的路径创建一个 QDir 对象
    QDir(const QDir &other); // 拷贝构造函数，创建一个与 other 相同的 QDir 对象

    // 析构函数
    ~QDir(); // 析构函数

    // 公共成员函数
    QDir &operator=(const QDir &other); // 赋值运算符
    QDir &operator=(QDir &&other) noexcept; // 移动赋值运算符
    void swap(QDir &other) noexcept; // 交换函数
    bool operator==(const QDir &other) const; // 相等运算符
    bool operator!=(const QDir &other) const; // 不等运算符

    // 路径操作
    void setPath(const QString &path); // 设置目录路径
    QString path() const; // 返回当前目录的路径
    QString absolutePath() const; // 返回当前目录的绝对路径
    QString canonicalPath() const; // 返回当前目录的规范路径（去除符号链接和冗余的`.`和`..`）
    QString dirName() const; // 返回目录的名称
    QString filePath(const QString &fileName) const; // 返回文件的完整路径
    QString absoluteFilePath(const QString &fileName) const; // 返回文件的绝对路径
    QString relativeFilePath(const QString &fileName) const; // 返回相对于当前目录的文件路径

    // 目录操作
    bool exists() const; // 检查目录是否存在
    bool mkdir(const QString &dirName) const; // 创建一个名为 dirName 的目录
    bool rmdir(const QString &dirName) const; // 删除一个名为 dirName 的目录
    bool mkpath(const QString &dirPath) const; // 创建路径中所有不存在的目录
    bool rmpath(const QString &dirPath) const; // 删除路径中所有的目录
    bool removeRecursively(); // 递归删除目录及其内容
    bool rename(const QString &oldName, const QString &newName); // 将目录从 oldName 重命名为 newName
    bool exists(const QString &name) const; // 检查名为 name 的文件或目录是否存在

    // 文件操作
    QStringList entryList(const QStringList &nameFilters = QStringList(), QDir::Filters filters = QDir::NoFilter, QDir::SortFlags sort = QDir::NoSort) const; // 列出目录内容
    QFileInfoList entryInfoList(const QStringList &nameFilters = QStringList(), QDir::Filters filters = QDir::NoFilter, QDir::SortFlags sort = QDir::NoSort) const; // 列出目录内容的文件信息
    bool remove(const QString &fileName); // 删除名为 fileName 的文件
    bool rename(const QString &oldName, const QString &newName); // 将文件从 oldName 重命名为 newName
    bool exists(const QString &name) const; // 检查名为 name 的文件或目录是否存在

    // 静态成员函数
    static QDir current(); // 返回当前工作目录
    static QDir home(); // 返回用户的主目录
    static QDir root(); // 返回根目录
    static QDir temp(); // 返回临时目录
    static bool setCurrent(const QString &path); // 设置当前工作目录
    static QString currentPath(); // 返回当前工作目录的路径
    static QString homePath(); // 返回用户的主目录路径
    static QString rootPath(); // 返回根目录路径
    static QString tempPath(); // 返回临时目录路径

    // 枚举类型
    enum Filter {
        Dirs = 0x001, // 列出目录
        Files = 0x002, // 列出文件
        Drives = 0x004, // 列出驱动器
        NoSymLinks = 0x008, // 不列出符号链接
        AllDirs = 0x010, // 列出所有目录
        CaseSensitive = 0x020, // 区分大小写
        NoDotAndDotDot = 0x040, // 不列出`.`和`..`
        NoDot = 0x080, // 不列出`.`
        NoDotDot = 0x100, // 不列出`..`
        AllEntries = Dirs | Files | Drives, // 列出所有条目
        NoFilter = -1 // 无过滤器
    };

    enum SortFlag {
        Name = 0x00, // 按名称排序
        Time = 0x01, // 按时间排序
        Size = 0x02, // 按大小排序
        Type = 0x03, // 按类型排序
        Unsorted = 0x04, // 不排序
        SortByMask = 0x0F, // 排序掩码
        DirsFirst = 0x10, // 目录优先
        Reversed = 0x20, // 反向排序
        IgnoreCase = 0x40, // 忽略大小写
        DirsLast = 0x80, // 目录最后
        LocaleAware = 0x100, // 本地化感知排序
        NoSort = -1 // 不排序
    };
};

QFileInfo 类用于文件信息操作。

class QFileInfo {
public:
    // 构造函数
    QFileInfo(); // 默认构造函数，创建一个无效的 QFileInfo 对象
    QFileInfo(const QString &file); // 根据给定的文件路径创建一个 QFileInfo 对象
    QFileInfo(const QFile &file); // 根据给定的 QFile 对象创建一个 QFileInfo 对象
    QFileInfo(const QDir &dir, const QString &file); // 根据给定的目录和文件名创建一个 QFileInfo 对象
    QFileInfo(const QFileInfo &fileinfo); // 拷贝构造函数，创建一个与 fileinfo 相同的 QFileInfo 对象

    // 析构函数
    ~QFileInfo(); // 析构函数

    // 公共成员函数
    QFileInfo &operator=(const QFileInfo &fileinfo); // 赋值运算符
    QFileInfo &operator=(QFileInfo &&other) noexcept; // 移动赋值运算符
    void swap(QFileInfo &other) noexcept; // 交换函数

    // 文件路径操作
    void setFile(const QString &file); // 设置文件路径
    void setFile(const QFile &file); // 设置文件路径
    void setFile(const QDir &dir, const QString &file); // 设置文件路径
    QString filePath() const; // 返回文件的完整路径
    QString absoluteFilePath() const; // 返回文件的绝对路径
    QString canonicalFilePath() const; // 返回文件的规范路径（去除符号链接和冗余的`.`和`..`）
    QString fileName() const; // 返回文件名
    QString baseName() const; // 返回文件的基本名称（不包括扩展名）
    QString completeBaseName() const; // 返回文件的完整基本名称（不包括扩展名）
    QString suffix() const; // 返回文件的扩展名
    QString completeSuffix() const; // 返回文件的完整扩展名
    QString path() const; // 返回文件路径（不包括文件名）
    QString absolutePath() const; // 返回文件的绝对路径（不包括文件名）
    QString canonicalPath() const; // 返回文件的规范路径（不包括文件名）

    // 目录操作
    QDir dir() const; // 返回文件所在的目录
    QDir absoluteDir() const; // 返回文件所在的绝对目录

    // 文件属性
    bool exists() const; // 检查文件是否存在
    void refresh(); // 刷新文件信息
    QDateTime created() const; // 返回文件的创建时间
    QDateTime lastModified() const; // 返回文件的最后修改时间
    QDateTime lastRead() const; // 返回文件的最后读取时间
    bool isFile() const; // 检查是否为文件
    bool isDir() const; // 检查是否为目录
    bool isSymLink() const; // 检查是否为符号链接
    bool isShortcut() const; // 检查是否为快捷方式
    bool isRoot() const; // 检查是否为根目录
    bool isHidden() const; // 检查是否为隐藏文件
    bool isReadable() const; // 检查文件是否可读
    bool isWritable() const; // 检查文件是否可写
    bool isExecutable() const; // 检查文件是否可执行
    bool isRelative() const; // 检查路径是否为相对路径
    bool isAbsolute() const; // 检查路径是否为绝对路径
    bool makeAbsolute(); // 将路径转换为绝对路径
    bool permission(QFile::Permissions permissions) const; // 检查文件权限
    QFile::Permissions permissions() const; // 返回文件权限
    qint64 size() const; // 返回文件大小

    // 符号链接操作
    QString symLinkTarget() const; // 返回符号链接的目标路径

    // 静态成员函数
    static QString currentPath(); // 返回当前工作目录路径
    static QString homePath(); // 返回用户主目录路径
    static QString rootPath(); // 返回根目录路径
    static QString tempPath(); // 返回临时目录路径
    static QFileInfo fromNativeSeparators(const QString &pathName); // 将路径中的反斜杠转换为斜杠
    static QString toNativeSeparators(const QString &pathName); // 将路径中的斜杠转换为反斜杠

    // 枚举类型
    enum Permission {
        ReadOwner = 0x4000, // 读取所有者权限
        WriteOwner = 0x2000, // 写入所有者权限
        ExeOwner = 0x1000, // 执行所有者权限
        ReadUser = 0x0400, // 读取用户权限
        WriteUser = 0x0200, // 写入用户权限
        ExeUser = 0x0100, // 执行用户权限
        ReadGroup = 0x0040, // 读取组权限
        WriteGroup = 0x0020, // 写入组权限
        ExeGroup = 0x0010, // 执行组权限
        ReadOther = 0x0004, // 读取其他权限
        WriteOther = 0x0002, // 写入其他权限
        ExeOther = 0x0001 // 执行其他权限
    };
};

2. QTextStream 类用于文本流操作。

// QTextStream 类是 Qt 框架中用于文本流操作的重要类。以下是 QTextStream 类的所有成员函数和枚举类型的详细列表：

// 枚举类型
enum NumberFlag {
    ShowBase = 0x1, // 显示基数前缀
    ForcePoint = 0x2, // 强制显示小数点
    ForceSign = 0x4, // 强制显示符号
    UppercaseBase = 0x8, // 基数前缀大写
    UppercaseDigits = 0x10 // 数字大写
};

enum RealNumberNotation {
    ScientificNotation, // 科学计数法
    FixedNotation, // 固定小数点表示法
    SmartNotation // 智能表示法
};

enum FieldAlignment {
    AlignLeft, // 左对齐
    AlignRight, // 右对齐
    AlignCenter, // 居中对齐
    AlignAccountingStyle // 会计样式对齐
};

enum Status {
    Ok, // 状态正常
    ReadPastEnd, // 读取超过末尾
    ReadCorruptData, // 读取损坏数据
    WriteFailed // 写入失败
};

// 构造函数
QTextStream(); // 默认构造函数
QTextStream(QIODevice *device); // 指定设备的构造函数
QTextStream(FILE *fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite); // 指定文件指针的构造函数
QTextStream(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite); // 指定字符串的构造函数
QTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite); // 指定字节数组的构造函数
QTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly); // 指定常量字节数组的构造函数

// 析构函数
~QTextStream(); // 析构函数

// 公共成员函数
bool atEnd() const; // 检查是否在流的末尾
void flush(); // 刷新流
bool generateByteOrderMark() const; // 检查是否生成字节顺序标记
QTextCodec *codec() const; // 返回当前编码
int integerBase() const; // 返回整数基数
QTextStream::NumberFlags numberFlags() const; // 返回数字格式标志
QChar padChar() const; // 返回填充字符
QString readAll(); // 读取所有数据
QString readLine(qint64 maxlen = 0); // 读取一行数据
bool readLineInto(QString *line, qint64 maxlen = 0); // 读取一行数据到指定字符串
QTextStream::RealNumberNotation realNumberNotation() const; // 返回实数表示法
int realNumberPrecision() const; // 返回实数精度
void reset(); // 重置流
void resetStatus(); // 重置状态
bool seek(qint64 pos); // 定位到指定位置
void setByteOrder(QDataStream::ByteOrder bo); // 设置字节顺序
void setCodec(QTextCodec *codec); // 设置编码
void setCodec(const char *codecName); // 设置编码
void setGenerateByteOrderMark(bool generate); // 设置是否生成字节顺序标记
void setIntegerBase(int base); // 设置整数基数
void setNumberFlags(QTextStream::NumberFlags flags); // 设置数字格式标志
void setPadChar(QChar ch); // 设置填充字符
void setFieldAlignment(QTextStream::FieldAlignment alignment); // 设置字段对齐方式
void setFieldWidth(int width); // 设置字段宽度
void setRealNumberNotation(QTextStream::RealNumberNotation notation); // 设置实数表示法
void setRealNumberPrecision(int precision); // 设置实数精度
void setStatus(QTextStream::Status status); // 设置状态
void setString(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite); // 设置字符串
void skipWhiteSpace(); // 跳过空白字符
QTextStream::Status status() const; // 返回状态
QString *string() const; // 返回当前字符串
QIODevice *device() const; // 返回当前设备
void setDevice(QIODevice *device); // 设置设备
bool isDeviceNull() const; // 检查设备是否为空
bool isNull() const; // 检查流是否为空
bool isOpen() const; // 检查流是否打开
bool isReadable() const; // 检查流是否可读
bool isWritable() const; // 检查流是否可写
QTextStream &operator>>(QChar &ch); // 读取字符
QTextStream &operator>>(char &ch); // 读取字符
QTextStream &operator>>(signed short &i); // 读取短整型
QTextStream &operator>>(unsigned short &i); // 读取无符号短整型
QTextStream &operator>>(signed int &i); // 读取整型
QTextStream &operator>>(unsigned int &i); // 读取无符号整型
QTextStream &operator>>(signed long &i); // 读取长整型
QTextStream &operator>>(unsigned long &i); // 读取无符号长整型
QTextStream &operator>>(qlonglong &i); // 读取长长整型
QTextStream &operator>>(qulonglong &i); // 读取无符号长长整型
QTextStream &operator>>(float &f); // 读取浮点型
QTextStream &operator>>(double &f); // 读取双精度浮点型
QTextStream &operator>>(QString &s); // 读取字符串
QTextStream &operator>>(QByteArray &array); // 读取字节数组
QTextStream &operator<<(QChar ch); // 写入字符
QTextStream &operator<<(char ch); // 写入字符
QTextStream &operator<<(signed short i); // 写入短整型
QTextStream &operator<<(unsigned short i); // 写入无符号短整型
QTextStream &operator<<(signed int i); // 写入整型
QTextStream &operator<<(unsigned int i); // 写入无符号整型
QTextStream &operator<<(signed long i); // 写入长整型
QTextStream &operator<<(unsigned long i); // 写入无符号长整型
QTextStream &operator<<(qlonglong i); // 写入长长整型
QTextStream &operator<<(qulonglong i); // 写入无符号长长整型
QTextStream &operator<<(float f); // 写入浮点型
QTextStream &operator<<(double f); // 写入双精度浮点型
QTextStream &operator<<(const QString &s); // 写入字符串
QTextStream &operator<<(const QByteArray &array); // 写入字节数组
QTextStream &operator<<(const char *string); // 写入C字符串
QTextStream &operator<<(const void *ptr); // 写入指针

// 静态公共成员函数
static QTextStream &endl(QTextStream &stream); // 插入换行符并刷新流
static QTextStream &flush(QTextStream &stream); // 刷新流
static QTextStream &reset(QTextStream &stream); // 重置流
static QTextStream &ws(QTextStream &stream); // 跳过空白字符
static QTextStream &bom(QTextStream &stream); // 插入字节顺序标记

3. QDataStream 类用于数据流操作。

// QDataStream 类是 Qt 框架中用于二进制数据流操作的重要类。以下是 QDataStream 类的所有成员函数和枚举类型的详细列表：

// 枚举类型
enum ByteOrder {
    BigEndian, // 大端字节序
    LittleEndian // 小端字节序
};

enum FloatingPointPrecision {
    SinglePrecision, // 单精度浮点数
    DoublePrecision // 双精度浮点数
};

enum Status {
    Ok, // 状态正常
    ReadPastEnd, // 读取超过末尾
    ReadCorruptData, // 读取损坏数据
    WriteFailed // 写入失败
};

enum Version {
    Qt_1_0 = 1,
    Qt_2_0 = 2,
    Qt_2_1 = 3,
    Qt_3_0 = 4,
    Qt_3_1 = 5,
    Qt_3_3 = 6,
    Qt_4_0 = 7,
    Qt_4_1 = 8,
    Qt_4_2 = 9,
    Qt_4_3 = 10,
    Qt_4_4 = 11,
    Qt_4_5 = 12,
    Qt_4_6 = 13,
    Qt_4_7 = 14,
    Qt_4_8 = 15,
    Qt_4_9 = 16,
    Qt_5_0 = 17,
    Qt_5_1 = 18,
    Qt_5_2 = 19,
    Qt_5_3 = 20,
    Qt_5_4 = 21,
    Qt_5_5 = 22,
    Qt_5_6 = 23,
    Qt_5_7 = 24,
    Qt_5_8 = 25,
    Qt_5_9 = 26,
    Qt_5_10 = 27,
    Qt_5_11 = 28,
    Qt_5_12 = 29,
    Qt_5_13 = 30,
    Qt_5_14 = 31,
    Qt_5_15 = 32,
    Qt_6_0 = 33
};

// 构造函数
QDataStream(); // 默认构造函数
QDataStream(QIODevice *d); // 指定设备的构造函数
QDataStream(QByteArray *a, QIODevice::OpenMode mode); // 指定字节数组的构造函数
QDataStream(const QByteArray &a); // 指定常量字节数组的构造函数

// 析构函数
~QDataStream(); // 析构函数

// 公共成员函数
bool atEnd() const; // 检查是否在流的末尾
QIODevice *device() const; // 返回当前设备
QDataStream::ByteOrder byteOrder() const; // 返回字节顺序
bool floatingPointPrecision() const; // 返回浮点数精度
bool isRawDataEnabled() const; // 检查是否启用原始数据
bool isVersionEnabled() const; // 检查是否启用版本
QDataStream::Status status() const; // 返回状态
QDataStream::Version version() const; // 返回版本
void setByteOrder(QDataStream::ByteOrder bo); // 设置字节顺序
void setDevice(QIODevice *d); // 设置设备
void setFloatingPointPrecision(QDataStream::FloatingPointPrecision precision); // 设置浮点数精度
void setRawData(const char *data, int len); // 设置原始数据
void setStatus(QDataStream::Status status); // 设置状态
void setVersion(int v); // 设置版本
void unsetDevice(); // 取消设置设备
void resetStatus(); // 重置状态
void skipRawData(int len); // 跳过原始数据
QDataStream &operator>>(QChar &ch); // 读取字符
QDataStream &operator>>(char &ch); // 读取字符
QDataStream &operator>>(signed short &i); // 读取短整型
QDataStream &operator>>(unsigned short &i); // 读取无符号短整型
QDataStream &operator>>(signed int &i); // 读取整型
QDataStream &operator>>(unsigned int &i); // 读取无符号整型
QDataStream &operator>>(signed long &i); // 读取长整型
QDataStream &operator>>(unsigned long &i); // 读取无符号长整型
QDataStream &operator>>(qlonglong &i); // 读取长长整型
QDataStream &operator>>(qulonglong &i); // 读取无符号长长整型
QDataStream &operator>>(float &f); // 读取浮点型
QDataStream &operator>>(double &f); // 读取双精度浮点型
QDataStream &operator>>(QString &s); // 读取字符串
QDataStream &operator>>(QByteArray &array); // 读取字节数组
QDataStream &operator<<(QChar ch); // 写入字符
QDataStream &operator<<(char ch); // 写入字符
QDataStream &operator<<(signed short i); // 写入短整型
QDataStream &operator<<(unsigned short i); // 写入无符号短整型
QDataStream &operator<<(signed int i); // 写入整型
QDataStream &operator<<(unsigned int i); // 写入无符号整型
QDataStream &operator<<(signed long i); // 写入长整型
QDataStream &operator<<(unsigned long i); // 写入无符号长整型
QDataStream &operator<<(qlonglong i); // 写入长长整型
QDataStream &operator<<(qulonglong i); // 写入无符号长长整型
QDataStream &operator<<(float f); // 写入浮点型
QDataStream &operator<<(double f); // 写入双精度浮点型
QDataStream &operator<<(const QString &s); // 写入字符串
QDataStream &operator<<(const QByteArray &array); // 写入字节数组

// 静态公共成员函数
static QDataStream &readLine(QDataStream &s, QString &line); // 读取一行数据
static QDataStream &readBytes(QDataStream &s, QByteArray &array); // 读取字节数组
static QDataStream &writeBytes(QDataStream &s, const QByteArray &array); // 写入字节数组

图形和坐标

QPoint：表示二维平面上的点。

// QPoint 类是 Qt 框架中用于表示二维平面上的点的类。以下是 QPoint 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QPoint(); // 默认构造函数，创建一个原点 (0, 0)
QPoint(int xpos, int ypos); // 指定 x 和 y 坐标的构造函数

// 析构函数
~QPoint(); // 析构函数

// 公共成员函数
int x() const; // 返回 x 坐标
int y() const; // 返回 y 坐标
void setX(int x); // 设置 x 坐标
void setY(int y); // 设置 y 坐标
bool isNull() const; // 检查点是否为原点 (0, 0)
int manhattanLength() const; // 返回点与原点的曼哈顿距离
QPoint &operator+=(const QPoint &point); // 加法运算符
QPoint &operator-=(const QPoint &point); // 减法运算符
QPoint &operator*=(qreal factor); // 乘法运算符
QPoint &operator/=(qreal divisor); // 除法运算符
QPoint &operator=(const QPoint &other); // 赋值运算符
bool operator==(const QPoint &p1, const QPoint &p2); // 相等运算符
bool operator!=(const QPoint &p1, const QPoint &p2); // 不等运算符
QPoint operator+(const QPoint &p1, const QPoint &p2); // 加法运算符
QPoint operator-(const QPoint &p1, const QPoint &p2); // 减法运算符
QPoint operator*(const QPoint &point, qreal factor); // 乘法运算符
QPoint operator*(qreal factor, const QPoint &point); // 乘法运算符
QPoint operator/(const QPoint &point, qreal divisor); // 除法运算符
QPoint operator-(const QPoint &point); // 负号运算符

// 静态公共成员函数
static qreal dotProduct(const QPoint &p1, const QPoint &p2); // 计算两个点的点积

QSize：表示二维平面上的大小。

// QSize 类是 Qt 框架中用于表示二维尺寸的类。以下是 QSize 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QSize(); // 默认构造函数，创建一个无效的尺寸 (0, 0)
QSize(int width, int height); // 指定宽度和高度的构造函数

// 析构函数
~QSize(); // 析构函数

// 公共成员函数
bool isNull() const; // 检查尺寸是否为 (0, 0)
bool isEmpty() const; // 检查尺寸是否为空，即宽度或高度小于等于 0
bool isValid() const; // 检查尺寸是否有效，即宽度和高度都大于等于 0
int width() const; // 返回宽度
int height() const; // 返回高度
void setWidth(int width); // 设置宽度
void setHeight(int height); // 设置高度
void transpose(); // 转置尺寸，交换宽度和高度
QSize transposed() const; // 返回转置后的尺寸

QSize &operator+=(const QSize &size); // 加法赋值运算符
QSize &operator-=(const QSize &size); // 减法赋值运算符
QSize &operator*=(double factor); // 乘法赋值运算符
QSize &operator/=(double divisor); // 除法赋值运算符

// 运算符重载
bool operator==(const QSize &s1, const QSize &s2); // 相等运算符
bool operator!=(const QSize &s1, const QSize &s2); // 不等运算符
QSize operator+(const QSize &s1, const QSize &s2); // 加法运算符
QSize operator-(const QSize &s1, const QSize &s2); // 减法运算符
QSize operator*(const QSize &size, double factor); // 乘法运算符
QSize operator*(double factor, const QSize &size); // 乘法运算符
QSize operator/(const QSize &size, double divisor); // 除法运算符

// 扩展尺寸的方法
void scale(int w, int h, Qt::AspectRatioMode mode); // 按指定模式缩放尺寸
void scale(const QSize &s, Qt::AspectRatioMode mode); // 按指定模式缩放尺寸

// 调整尺寸的方法
QSize expandedTo(const QSize &other) const; // 返回扩展到另一个尺寸后的结果
QSize boundedTo(const QSize &other) const; // 返回缩小到另一个尺寸后的结果

QRect：表示二维平面上的矩形。

// QRect 类是 Qt 框架中用于表示二维矩形的类。以下是 QRect 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QRect(); // 默认构造函数，创建一个无效的矩形
QRect(const QPoint &topLeft, const QPoint &bottomRight); // 指定左上角和右下角点的构造函数
QRect(const QPoint &topLeft, const QSize &size); // 指定左上角点和尺寸的构造函数
QRect(int x, int y, int width, int height); // 指定左上角坐标和尺寸的构造函数

// 析构函数
~QRect(); // 析构函数

// 公共成员函数
bool isNull() const; // 检查矩形是否为空
bool isEmpty() const; // 检查矩形是否为空，即宽度或高度小于等于 0
bool isValid() const; // 检查矩形是否有效，即宽度和高度都大于等于 0
int x() const; // 返回左上角的 x 坐标
int y() const; // 返回左上角的 y 坐标
void setX(int x); // 设置左上角的 x 坐标
void setY(int y); // 设置左上角的 y 坐标
int left() const; // 返回左边缘的 x 坐标
int top() const; // 返回上边缘的 y 坐标
int right() const; // 返回右边缘的 x 坐标
int bottom() const; // 返回下边缘的 y 坐标
void setLeft(int x); // 设置左边缘的 x 坐标
void setTop(int y); // 设置上边缘的 y 坐标
void setRight(int x); // 设置右边缘的 x 坐标
void setBottom(int y); // 设置下边缘的 y 坐标
QPoint topLeft() const; // 返回左上角点
QPoint bottomRight() const; // 返回右下角点
QPoint topRight() const; // 返回右上角点
QPoint bottomLeft() const; // 返回左下角点
QPoint center() const; // 返回矩形的中心点
void setTopLeft(const QPoint &position); // 设置左上角点
void setBottomRight(const QPoint &position); // 设置右下角点
void setTopRight(const QPoint &position); // 设置右上角点
void setBottomLeft(const QPoint &position); // 设置左下角点
void moveLeft(int x); // 移动矩形使其左边缘的 x 坐标为指定值
void moveTop(int y); // 移动矩形使其上边缘的 y 坐标为指定值
void moveRight(int x); // 移动矩形使其右边缘的 x 坐标为指定值
void moveBottom(int y); // 移动矩形使其下边缘的 y 坐标为指定值
void moveTopLeft(const QPoint &position); // 移动矩形使其左上角点为指定值
void moveBottomRight(const QPoint &position); // 移动矩形使其右下角点为指定值
void moveTopRight(const QPoint &position); // 移动矩形使其右上角点为指定值
void moveBottomLeft(const QPoint &position); // 移动矩形使其左下角点为指定值
void moveCenter(const QPoint &position); // 移动矩形使其中心点为指定值
void translate(int dx, int dy); // 平移矩形
void translate(const QPoint &offset); // 平移矩形
QRect translated(int dx, int dy) const; // 返回平移后的矩形
QRect translated(const QPoint &offset) const; // 返回平移后的矩形
void moveTo(int x, int y); // 移动矩形使其左上角点为指定值
void moveTo(const QPoint &position); // 移动矩形使其左上角点为指定值
void setRect(int x, int y, int width, int height); // 设置矩形的坐标和尺寸
void getRect(int *x, int *y, int *width, int *height) const; // 获取矩形的坐标和尺寸
void setCoords(int x1, int y1, int x2, int y2); // 设置矩形的坐标
void getCoords(int *x1, int *y1, int *x2, int *y2) const; // 获取矩形的坐标
void adjust(int dx1, int dy1, int dx2, int dy2); // 调整矩形的坐标
QRect adjusted(int dx1, int dy1, int dx2, int dy2) const; // 返回调整后的矩形
QSize size() const; // 返回矩形的尺寸
int width() const; // 返回矩形的宽度
int height() const; // 返回矩形的高度
void setWidth(int width); // 设置矩形的宽度
void setHeight(int height); // 设置矩形的高度
void setSize(const QSize &size); // 设置矩形的尺寸
bool contains(const QPoint &point) const; // 检查矩形是否包含指定点
bool contains(int x, int y) const; // 检查矩形是否包含指定点
bool contains(const QRect &rectangle) const; // 检查矩形是否包含指定矩形
QRect united(const QRect &rectangle) const; // 返回两个矩形的并集
QRect intersected(const QRect &rectangle) const; // 返回两个矩形的交集
bool intersects(const QRect &rectangle) const; // 检查矩形是否与指定矩形相交

// 运算符重载
bool operator==(const QRect &r1, const QRect &r2); // 相等运算符
bool operator!=(const QRect &r1, const QRect &r2); // 不等运算符
QRect operator&(const QRect &r1, const QRect &r2); // 交集运算符
QRect &operator&=(const QRect &rectangle); // 交集赋值运算符
QRect operator|(const QRect &r1, const QRect &r2); // 并集运算符
QRect &operator|=(const QRect &rectangle); // 并集赋值运算符

QColor：表示颜色。

// QColor 类是 Qt 框架中用于表示颜色的类。以下是 QColor 类的所有成员函数和枚举类型的详细列表：

// 枚举类型
enum Spec {
    Invalid, // 无效颜色
    Rgb, // RGB 颜色
    Hsv, // HSV 颜色
    Cmyk, // CMYK 颜色
    Hsl // HSL 颜色
};

enum NameFormat {
    HexRgb, // 十六进制 RGB 格式
    HexArgb // 十六进制 ARGB 格式
};

// 构造函数
QColor(); // 默认构造函数，创建一个无效的颜色
QColor(int r, int g, int b, int a = 255); // 指定 RGB 和透明度的构造函数
QColor(QRgb rgb); // 指定 RGB 值的构造函数
QColor(const QString &name); // 指定颜色名称的构造函数
QColor(const char *name); // 指定颜色名称的构造函数
QColor(QLatin1String name); // 指定颜色名称的构造函数
QColor(Qt::GlobalColor color); // 指定全局颜色的构造函数

// 析构函数
~QColor(); // 析构函数

// 公共成员函数
bool isValid() const; // 检查颜色是否有效
QString name() const; // 返回颜色的名称
void setNamedColor(const QString &name); // 设置颜色的名称
QStringList colorNames() const; // 返回所有支持的颜色名称
Spec spec() const; // 返回颜色的规范
int alpha() const; // 返回透明度
void setAlpha(int alpha); // 设置透明度
qreal alphaF() const; // 返回透明度的浮点值
void setAlphaF(qreal alpha); // 设置透明度的浮点值
int red() const; // 返回红色分量
int green() const; // 返回绿色分量
int blue() const; // 返回蓝色分量
void setRed(int red); // 设置红色分量
void setGreen(int green); // 设置绿色分量
void setBlue(int blue); // 设置蓝色分量
qreal redF() const; // 返回红色分量的浮点值
qreal greenF() const; // 返回绿色分量的浮点值
qreal blueF() const; // 返回蓝色分量的浮点值
void setRedF(qreal red); // 设置红色分量的浮点值
void setGreenF(qreal green); // 设置绿色分量的浮点值
void setBlueF(qreal blue); // 设置蓝色分量的浮点值
QRgb rgb() const; // 返回 RGB 值
void setRgb(int r, int g, int b, int a = 255); // 设置 RGB 值
void setRgb(QRgb rgb); // 设置 RGB 值
QRgb rgba() const; // 返回 RGBA 值
void setRgba(QRgb rgba); // 设置 RGBA 值
int hue() const; // 返回 HSV 色调
int saturation() const; // 返回 HSV 饱和度
int value() const; // 返回 HSV 值
void setHsv(int h, int s, int v, int a = 255); // 设置 HSV 值
qreal hueF() const; // 返回 HSV 色调的浮点值
qreal saturationF() const; // 返回 HSV 饱和度的浮点值
qreal valueF() const; // 返回 HSV 值的浮点值
void setHsvF(qreal h, qreal s, qreal v, qreal a = 1.0); // 设置 HSV 值的浮点值
int cyan() const; // 返回 CMYK 青色分量
int magenta() const; // 返回 CMYK 品红色分量
int yellow() const; // 返回 CMYK 黄色分量
int black() const; // 返回 CMYK 黑色分量
void setCmyk(int c, int m, int y, int k, int a = 255); // 设置 CMYK 值
qreal cyanF() const; // 返回 CMYK 青色分量的浮点值
qreal magentaF() const; // 返回 CMYK 品红色分量的浮点值
qreal yellowF() const; // 返回 CMYK 黄色分量的浮点值
qreal blackF() const; // 返回 CMYK 黑色分量的浮点值
void setCmykF(qreal c, qreal m, qreal y, qreal k, qreal a = 1.0); // 设置 CMYK 值的浮点值
int hueHsl() const; // 返回 HSL 色调
int saturationHsl() const; // 返回 HSL 饱和度
int lightness() const; // 返回 HSL 亮度
void setHsl(int h, int s, int l, int a = 255); // 设置 HSL 值
qreal hueHslF() const; // 返回 HSL 色调的浮点值
qreal saturationHslF() const; // 返回 HSL 饱和度的浮点值
qreal lightnessF() const; // 返回 HSL 亮度的浮点值
void setHslF(qreal h, qreal s, qreal l, qreal a = 1.0); // 设置 HSL 值的浮点值
QColor toRgb() const; // 转换为 RGB 颜色
QColor toHsv() const; // 转换为 HSV 颜色
QColor toCmyk() const; // 转换为 CMYK 颜色
QColor toHsl() const; // 转换为 HSL 颜色
int lighter(int factor = 150) const; // 返回更亮的颜色
int darker(int factor = 200) const; // 返回更暗的颜色
bool operator==(const QColor &c1, const QColor &c2); // 相等运算符
bool operator!=(const QColor &c1, const QColor &c2); // 不等运算符

// 静态公共成员函数
static QColor fromRgb(QRgb rgb); // 从 RGB 值创建颜色
static QColor fromRgba(QRgb rgba); // 从 RGBA 值创建颜色
static QColor fromRgb(int r, int g, int b, int a = 255); // 从 RGB 值创建颜色
static QColor fromHsv(int h, int s, int v, int a = 255); // 从 HSV 值创建颜色
static QColor fromHsvF(qreal h, qreal s, qreal v, qreal a = 1.0); // 从 HSV 值的浮点值创建颜色
static QColor fromCmyk(int c, int m, int y, int k, int a = 255); // 从 CMYK 值创建颜色
static QColor fromCmykF(qreal c, qreal m, qreal y, qreal k, qreal a = 1.0); // 从 CMYK 值的浮点值创建颜色
static QColor fromHsl(int h, int s, int l, int a = 255); // 从 HSL 值创建颜色
static QColor fromHslF(qreal h, qreal s, qreal l, qreal a = 1.0); // 从 HSL 值的浮点值创建颜色
static QColor fromName(const QString &name); // 从颜色名称创建颜色
static QColor fromString(const QString &name); // 从颜色名称创建颜色
static bool isValidColor(const QString &name); // 检查颜色名称是否有效

QPixmap：用于处理图像。

// QPixmap 类是 Qt 框架中用于处理图像的重要类。以下是 QPixmap 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QPixmap(); // 默认构造函数，创建一个空的 QPixmap 对象
QPixmap(const QPixmap &pixmap); // 拷贝构造函数
QPixmap(int width, int height); // 指定宽度和高度的构造函数
QPixmap(const QSize &size); // 指定尺寸的构造函数
QPixmap(const QString &fileName, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor); // 从文件加载图像的构造函数

// 析构函数
~QPixmap(); // 析构函数

// 公共成员函数
QPixmap &operator=(const QPixmap &pixmap); // 赋值运算符
void swap(QPixmap &other); // 交换函数
bool isNull() const; // 检查 QPixmap 是否为空
int width() const; // 返回宽度
int height() const; // 返回高度
QSize size() const; // 返回尺寸
QRect rect() const; // 返回矩形区域
void resize(int width, int height); // 调整大小
void resize(const QSize &size); // 调整大小
bool load(const QString &fileName, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor); // 从文件加载图像
bool loadFromData(const uchar *data, uint len, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor); // 从数据加载图像
bool loadFromData(const QByteArray &data, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor); // 从数据加载图像
bool save(const QString &fileName, const char *format = nullptr, int quality = -1) const; // 保存图像到文件
bool save(QIODevice *device, const char *format = nullptr, int quality = -1) const; // 保存图像到设备
QBitmap mask() const; // 返回掩码
void setMask(const QBitmap &mask); // 设置掩码
bool hasAlpha() const; // 检查是否有透明度
bool hasAlphaChannel() const; // 检查是否有透明通道
void fill(const QColor &color = Qt::white); // 填充颜色
QPixmap scaled(int width, int height, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const; // 缩放图像
QPixmap scaled(const QSize &size, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const; // 缩放图像
QPixmap scaledToWidth(int width, Qt::TransformationMode mode = Qt::FastTransformation) const; // 按宽度缩放图像
QPixmap scaledToHeight(int height, Qt::TransformationMode mode = Qt::FastTransformation) const; // 按高度缩放图像
QPixmap transformed(const QTransform &transform, Qt::TransformationMode mode = Qt::FastTransformation) const; // 变换图像
QPixmap copy(int x, int y, int width, int height) const; // 复制部分图像
QPixmap copy(const QRect &rect) const; // 复制部分图像
QImage toImage() const; // 转换为 QImage
static QPixmap fromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor); // 从 QImage 创建 QPixmap
static QPixmap fromImageReader(QImageReader *imageReader, Qt::ImageConversionFlags flags = Qt::AutoColor); // 从 QImageReader 创建 QPixmap
int depth() const; // 返回图像深度
void setDevicePixelRatio(qreal scaleFactor); // 设置设备像素比
qreal devicePixelRatio() const; // 返回设备像素比
QPixmap detached() const; // 返回分离的 QPixmap
void scroll(int dx, int dy, int x, int y, int width, int height, QRegion *exposed = nullptr); // 滚动图像
void scroll(int dx, int dy, const QRect &rect, QRegion *exposed = nullptr); // 滚动图像

// 静态公共成员函数
static int defaultDepth(); // 返回默认图像深度
static QPixmap fromImage(QImage &&image, Qt::ImageConversionFlags flags = Qt::AutoColor); // 从 QImage 创建 QPixmap
static QPixmap grabWidget(QWidget *widget, const QRect &rectangle); // 抓取窗口部件的图像
static QPixmap grabWidget(QWidget *widget, int x = 0, int y = 0, int width = -1, int height = -1); // 抓取窗口部件的图像
static QPixmap grabWindow(WId window, int x = 0, int y = 0, int width = -1, int height = -1); // 抓取窗口的图像

// 枚举类型
enum ShareMode {
    ImplicitlyShared, // 隐式共享
    ExplicitlyShared // 显式共享
};

QImage：用于处理图像，支持直接像素访问。

// QImage 类是 Qt 框架中用于处理图像的重要类。以下是 QImage 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QImage(); // 默认构造函数，创建一个空的 QImage 对象
QImage(const QSize &size, QImage::Format format); // 指定尺寸和格式的构造函数
QImage(int width, int height, QImage::Format format); // 指定宽度和高度以及格式的构造函数
QImage(uchar *data, int width, int height, QImage::Format format, QImageCleanupFunction cleanupFunction = nullptr, void *cleanupInfo = nullptr); // 从数据指针创建图像的构造函数
QImage(const uchar *data, int width, int height, QImage::Format format, QImageCleanupFunction cleanupFunction = nullptr, void *cleanupInfo = nullptr); // 从数据指针创建图像的构造函数
QImage(uchar *data, int width, int height, int bytesPerLine, QImage::Format format, QImageCleanupFunction cleanupFunction = nullptr, void *cleanupInfo = nullptr); // 从数据指针创建图像的构造函数
QImage(const uchar *data, int width, int height, int bytesPerLine, QImage::Format format, QImageCleanupFunction cleanupFunction = nullptr, void *cleanupInfo = nullptr); // 从数据指针创建图像的构造函数
QImage(const char *const[] xpm); // 从 XPM 数据创建图像的构造函数
QImage(const QString &fileName, const char *format = nullptr); // 从文件加载图像的构造函数
QImage(const QImage &image); // 拷贝构造函数

// 析构函数
~QImage(); // 析构函数

// 公共成员函数
QImage &operator=(const QImage &image); // 赋值运算符
void swap(QImage &other); // 交换函数
bool isNull() const; // 检查 QImage 是否为空
int width() const; // 返回宽度
int height() const; // 返回高度
QSize size() const; // 返回尺寸
QRect rect() const; // 返回矩形区域
int depth() const; // 返回图像深度
int format() const; // 返回图像格式
void fill(uint pixelValue); // 填充颜色
void fill(const QColor &color); // 填充颜色
void fill(Qt::GlobalColor color); // 填充颜色
bool valid(int x, int y) const; // 检查坐标是否有效
int pixelIndex(int x, int y) const; // 返回像素索引
uint pixel(int x, int y) const; // 返回像素值
QRgb pixel(const QPoint &position) const; // 返回像素值
void setPixel(int x, int y, uint index_or_rgb); // 设置像素值
void setPixel(const QPoint &position, uint index_or_rgb); // 设置像素值
QColor pixelColor(int x, int y) const; // 返回像素颜色
QColor pixelColor(const QPoint &position) const; // 返回像素颜色
void setPixelColor(int x, int y, const QColor &color); // 设置像素颜色
void setPixelColor(const QPoint &position, const QColor &color); // 设置像素颜色
uchar *scanLine(int i); // 返回扫描线指针
const uchar *scanLine(int i) const; // 返回扫描线指针
uchar *bits(); // 返回位指针
const uchar *bits() const; // 返回位指针
int bytesPerLine() const; // 返回每行字节数
int byteCount() const; // 返回总字节数
int bitPlaneCount() const; // 返回位平面数
uchar **jumpTable(); // 返回跳转表
const uchar *const *jumpTable() const; // 返回跳转表
QImage scaled(int width, int height, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const; // 缩放图像
QImage scaled(const QSize &size, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const; // 缩放图像
QImage scaledToWidth(int width, Qt::TransformationMode mode = Qt::FastTransformation) const; // 按宽度缩放图像
QImage scaledToHeight(int height, Qt::TransformationMode mode = Qt::FastTransformation) const; // 按高度缩放图像
QImage transformed(const QTransform &matrix, Qt::TransformationMode mode = Qt::FastTransformation) const; // 变换图像
bool load(const QString &fileName, const char *format = nullptr); // 从文件加载图像
bool loadFromData(const uchar *data, int len, const char *format = nullptr); // 从数据加载图像
bool loadFromData(const QByteArray &data, const char *format = nullptr); // 从数据加载图像
bool save(const QString &fileName, const char *format = nullptr, int quality = -1) const; // 保存图像到文件
bool save(QIODevice *device, const char *format = nullptr, int quality = -1) const; // 保存图像到设备
QImage copy(int x, int y, int width, int height) const; // 复制部分图像
QImage copy(const QRect &rect) const; // 复制部分图像
QImage mirrored(bool horizontal = false, bool vertical = true) const; // 镜像图像
QImage rgbSwapped() const; // 交换 RGB 值
bool invertPixels(QImage::InvertMode mode = QImage::InvertRgb); // 反转像素
QImage convertToFormat(QImage::Format format, Qt::ImageConversionFlags flags = Qt::AutoColor) const; // 转换图像格式
QImage convertToFormat(QImage::Format format, const QVector<QRgb> &colorTable, Qt::ImageConversionFlags flags = Qt::AutoColor) const; // 转换图像格式
QVector<QRgb> colorTable() const; // 返回颜色表
void setColorTable(const QVector<QRgb> &colors); // 设置颜色表
int colorCount() const; // 返回颜色数
int bitCount() const; // 返回位数
bool allGray() const; // 检查是否所有像素都是灰度
bool isGrayscale() const; // 检查是否是灰度图像
QImage alphaChannel() const; // 返回 alpha 通道
QImage createAlphaMask(Qt::ImageConversionFlags flags = Qt::AutoColor) const; // 创建 alpha 掩码
QImage createHeuristicMask(bool clipTight = true) const; // 创建启发式掩码
QImage createMaskFromColor(QRgb color, Qt::MaskMode mode = Qt::MaskInColor) const; // 从颜色创建掩码
QPixmap toPixmap() const; // 转换为 QPixmap
static QImage fromData(const uchar *data, int size, const char *format = nullptr); // 从数据创建图像
static QImage fromData(const QByteArray &data, const char *format = nullptr); // 从数据创建图像
static QImage fromPixmap(const QPixmap &pixmap); // 从 QPixmap 创建图像
static QImage fromMono(const uchar *data, int width, int height, int bytesPerLine, QImage::Endian bitOrder = QImage::IgnoreEndian); // 从单色数据创建图像
static QImage fromMono(const uchar *data, int width, int height, int bytesPerLine, QImage::Endian bitOrder, QImageCleanupFunction cleanupFunction = nullptr, void *cleanupInfo = nullptr); // 从单色数据创建图像
static QImage fromMono(const uchar *data, int width, int height, QImage::Endian bitOrder = QImage::IgnoreEndian); // 从单色数据创建图像
static QImage fromMono(const uchar *data, int width, int height, QImage::Endian bitOrder, QImageCleanupFunction cleanupFunction = nullptr, void *cleanupInfo = nullptr); // 从单色数据创建图像
static QImage fromQImageReader(QImageReader *imageReader); // 从 QImageReader 创建图像
static QImage fromImageReader(QImageReader *imageReader, Qt::ImageConversionFlags flags = Qt::AutoColor); // 从 QImageReader 创建图像
static QImage fromData(QByteArray &&data, const char *format = nullptr); // 从数据创建图像

// 枚举类型
enum Format {
    Format_Invalid, // 无效格式
    Format_Mono, // 单色格式
    Format_MonoLSB, // 单色 LSB 格式
    Format_Indexed8, // 索引 8 位格式
    Format_RGB32, // RGB32 格式
    Format_ARGB32, // ARGB32 格式
    Format_ARGB32_Premultiplied, // 预乘 ARGB32 格式
    Format_RGB16, // RGB16 格式
    Format_ARGB8565_Premultiplied, // 预乘 ARGB8565 格式
    Format_RGB666, // RGB666 格式
    Format_ARGB6666_Premultiplied, // 预乘 ARGB6666 格式
    Format_RGB555, // RGB555 格式
    Format_ARGB8555_Premultiplied, // 预乘 ARGB8555 格式
    Format_RGB888, // RGB888 格式
    Format_RGB444, // RGB444 格式
    Format_ARGB4444_Premultiplied, // 预乘 ARGB4444 格式
    Format_RGBX8888, // RGBX8888 格式
    Format_RGBA8888, // RGBA8888 格式
    Format_RGBA8888_Premultiplied, // 预乘 RGBA8888 格式
    Format_BGR30, // BGR30 格式
    Format_A2BGR30_Premultiplied, // 预乘 A2BGR30 格式
    Format_RGB30, // RGB30 格式
    Format_A2RGB30_Premultiplied, // 预乘 A2RGB30 格式
    Format_Alpha8, // Alpha8 格式
    Format_Grayscale8 // 灰度 8 位格式
};

enum InvertMode {
    InvertRgb, // 反转 RGB 值
    InvertRgba // 反转 RGBA 值
};

enum Endian {
    IgnoreEndian, // 忽略字节序
    BigEndian, // 大端字节序
    LittleEndian // 小端字节序
};

QBitmap 是 QImage 的一个子类，用于表示位图。

QPicture 提供了在 Qt 绘图系统中绘制复杂图形的能力。

QTransform 二维变换矩阵 QTransform 类提供了丰富的功能来处理二维变换，包括平移、旋转、缩放和剪切等操作。

通过使用 QTransform，你可以灵活地对图形和界面元素进行各种变换操作。

class QTransform {
public:
    // 构造函数
    QTransform(); // 默认构造函数，创建一个单位矩阵
    QTransform(qreal m11, qreal m12, qreal m21, qreal m22, qreal dx, qreal dy); // 指定矩阵元素的构造函数
    QTransform(qreal m11, qreal m12, qreal m13, qreal m21, qreal m22, qreal m23, qreal m31, qreal m32, qreal m33 = 1.0); // 指定完整矩阵元素的构造函数
    QTransform(const QMatrix &matrix); // 从 QMatrix 构造 QTransform

    // 公共成员函数
    qreal m11() const; // 返回矩阵元素 m11
    qreal m12() const; // 返回矩阵元素 m12
    qreal m13() const; // 返回矩阵元素 m13
    qreal m21() const; // 返回矩阵元素 m21
    qreal m22() const; // 返回矩阵元素 m22
    qreal m23() const; // 返回矩阵元素 m23
    qreal m31() const; // 返回矩阵元素 m31
    qreal m32() const; // 返回矩阵元素 m32
    qreal m33() const; // 返回矩阵元素 m33
    QTransform &operator=(const QTransform &other); // 赋值运算符
    QTransform &operator=(QTransform &&other) noexcept; // 移动赋值运算符
    void swap(QTransform &other) noexcept; // 交换函数
    bool operator==(const QTransform &other) const; // 相等运算符
    bool operator!=(const QTransform &other) const; // 不等运算符
    QTransform operator*(const QTransform &matrix) const; // 矩阵乘法运算符
    QTransform &operator*=(const QTransform &matrix); // 矩阵乘法赋值运算符
    QTransform &translate(qreal dx, qreal dy); // 平移变换
    QTransform &scale(qreal sx, qreal sy); // 缩放变换
    QTransform &shear(qreal sh, qreal sv); // 剪切变换
    QTransform &rotate(qreal angle, Qt::Axis axis = Qt::ZAxis); // 旋转变换
    QTransform &rotateRadians(qreal angle, Qt::Axis axis = Qt::ZAxis); // 以弧度为单位的旋转变换
    bool isIdentity() const; // 检查矩阵是否为单位矩阵
    bool isInvertible() const; // 检查矩阵是否可逆
    qreal determinant() const; // 返回矩阵的行列式
    QTransform inverted(bool *invertible = nullptr) const; // 返回逆矩阵
    QTransform adjoint() const; // 返回伴随矩阵
    QTransform transposed() const; // 返回转置矩阵
    QPoint map(const QPoint &point) const; // 映射点
    QPointF map(const QPointF &point) const; // 映射点（浮点精度）
    QLine map(const QLine &line) const; // 映射线
    QLineF map(const QLineF &line) const; // 映射线（浮点精度）
    QPolygon map(const QPolygon &polygon) const; // 映射多边形
    QPolygonF map(const QPolygonF &polygon) const; // 映射多边形（浮点精度）
    QRegion map(const QRegion &region) const; // 映射区域
    QPainterPath map(const QPainterPath &path) const; // 映射路径
    void map(int x, int y, int *tx, int *ty) const; // 映射点（整数精度）
    QRect mapRect(const QRect &rectangle) const; // 映射矩形
    QRectF mapRect(const QRectF &rectangle) const; // 映射矩形（浮点精度）
    QPolygon mapToPolygon(const QRect &rectangle) const; // 映射矩形到多边形
    void reset(); // 重置矩阵为单位矩阵
    bool isAffine() const; // 检查矩阵是否为仿射变换
    bool isScaling() const; // 检查矩阵是否包含缩放变换
    bool isRotating() const; // 检查矩阵是否包含旋转变换
    bool isTranslating() const; // 检查矩阵是否包含平移变换
    QTransform::TransformationType type() const; // 返回变换类型

    // 枚举类型
    enum TransformationType {
        TxNone = 0x00, // 无变换
        TxTranslate = 0x01, // 平移变换
        TxScale = 0x02, // 缩放变换
        TxRotate = 0x04, // 旋转变换
        TxShear = 0x08, // 剪切变换
        TxProject = 0x10 // 投影变换
    };
};

图形视图框架

QGraphicsItem：图形视图框架中的基本图形项。

QGraphicsScene：用于管理大量的图形项。

QGraphicsView：用于显示图形场景。

模型/视图框架

QAbstractItemModel：模型/视图框架中的抽象模型类。

QStandardItemModel：标准项模型，用于简单的模型/视图编程。

QTableView：用于显示表格数据的视图。

QTreeView：用于显示树形数据的视图。

网络

QUrl：用于处理 URL。

// QUrl 类是 Qt 框架中用于处理 URL 的重要类。以下是 QUrl 类的所有成员函数和枚举类型的详细列表：

// 构造函数
QUrl(); // 默认构造函数，创建一个空的 QUrl 对象
QUrl(const QString &url); // 从字符串创建 QUrl 对象
QUrl(const QString &url, QUrl::ParsingMode mode); // 从字符串和解析模式创建 QUrl 对象
QUrl(const QUrl &other); // 拷贝构造函数
QUrl(QUrl &&other) noexcept; // 移动构造函数

// 析构函数
~QUrl(); // 析构函数

// 公共成员函数
QUrl &operator=(const QUrl &url); // 赋值运算符
QUrl &operator=(QUrl &&url) noexcept; // 移动赋值运算符
void swap(QUrl &other) noexcept; // 交换函数
bool isNull() const; // 检查 QUrl 是否为空
bool isValid() const; // 检查 QUrl 是否有效
bool isEmpty() const; // 检查 QUrl 是否为空字符串
void clear(); // 清空 QUrl
void setUrl(const QString &url, QUrl::ParsingMode mode = TolerantMode); // 设置 URL
QString url(QUrl::FormattingOptions options = FormattingOptions(PrettyDecoded)) const; // 返回 URL 字符串
QString toString(QUrl::FormattingOptions options = FormattingOptions(PrettyDecoded)) const; // 返回 URL 字符串
QString toDisplayString(QUrl::FormattingOptions options = FormattingOptions(PrettyDecoded)) const; // 返回用于显示的 URL 字符串
QString toEncoded(QUrl::FormattingOptions options = FullyEncoded) const; // 返回编码后的 URL 字符串
QUrl adjusted(QUrl::FormattingOptions options) const; // 返回调整后的 URL
void setScheme(const QString &scheme); // 设置方案
QString scheme() const; // 返回方案
void setAuthority(const QString &authority, QUrl::ParsingMode mode = TolerantMode); // 设置权限
QString authority(QUrl::FormattingOptions options = PrettyDecoded) const; // 返回权限
void setUserInfo(const QString &userInfo, QUrl::ParsingMode mode = TolerantMode); // 设置用户信息
QString userInfo(QUrl::FormattingOptions options = PrettyDecoded) const; // 返回用户信息
void setUserName(const QString &userName, QUrl::ParsingMode mode = TolerantMode); // 设置用户名
QString userName(QUrl::FormattingOptions options = PrettyDecoded) const; // 返回用户名
void setPassword(const QString &password, QUrl::ParsingMode mode = TolerantMode); // 设置密码
QString password(QUrl::FormattingOptions options = PrettyDecoded) const; // 返回密码
void setHost(const QString &host, QUrl::ParsingMode mode = TolerantMode); // 设置主机
QString host(QUrl::FormattingOptions options = FullyDecoded) const; // 返回主机
void setPort(int port); // 设置端口
int port(int defaultPort = -1) const; // 返回端口
void setPath(const QString &path, QUrl::ParsingMode mode = TolerantMode); // 设置路径
QString path(QUrl::FormattingOptions options = FullyDecoded) const; // 返回路径
bool hasQuery() const; // 检查是否有查询
void setQuery(const QString &query, QUrl::ParsingMode mode = TolerantMode); // 设置查询
void setQuery(const QUrlQuery &query); // 设置查询
QString query(QUrl::FormattingOptions options = PrettyDecoded) const; // 返回查询
QUrlQuery queryItems() const; // 返回查询项
void setFragment(const QString &fragment, QUrl::ParsingMode mode = TolerantMode); // 设置片段
QString fragment(QUrl::FormattingOptions options = PrettyDecoded) const; // 返回片段
bool hasFragment() const; // 检查是否有片段
bool isRelative() const; // 检查是否是相对 URL
bool isLocalFile() const; // 检查是否是本地文件
QString toLocalFile() const; // 返回本地文件路径
void setPath(const QString &path); // 设置路径
void setQuery(const QString &query); // 设置查询
void setFragment(const QString &fragment); // 设置片段
QUrl fromLocalFile(const QString &localFile); // 从本地文件路径创建 QUrl
QString fromPercentEncoding(const QByteArray &input); // 从百分比编码解码
QByteArray toPercentEncoding(const QString &input, const QByteArray &exclude = QByteArray(), const QByteArray &include = QByteArray()); // 进行百分比编码
void addQueryItem(const QString &key, const QString &value); // 添加查询项
QList<QPair<QString, QString>> queryItems(); // 返回查询项
bool hasQueryItem(const QString &key) const; // 检查是否有查询项
QString queryItemValue(const QString &key) const; // 返回查询项值
QStringList allQueryItemValues(const QString &key) const; // 返回所有查询项值
void removeQueryItem(const QString &key); // 移除查询项
void removeAllQueryItems(const QString &key); // 移除所有查询项
void detach(); // 分离
bool isDetached() const; // 检查是否分离

// 静态公共成员函数
static QUrl fromUserInput(const QString &userInput); // 从用户输入创建 QUrl
static QUrl fromEncoded(const QByteArray &input, QUrl::ParsingMode mode = TolerantMode); // 从编码字符串创建 QUrl
static QByteArray toEncoded(const QUrl &url, QUrl::FormattingOptions options = FullyEncoded); // 返回编码后的 URL 字符串
static QString fromAce(const QByteArray &domain); // 从 ACE 编码解码域名
static QByteArray toAce(const QString &domain); // 对域名进行 ACE 编码
static QStringList idnWhitelist(); // 返回 IDN 白名单
static void setIdnWhitelist(const QStringList &list); // 设置 IDN 白名单

// 枚举类型
enum ParsingMode {
    TolerantMode, // 宽容模式
    StrictMode, // 严格模式
    DecodedMode // 解码模式
};

enum FormattingOption {
    None = 0x0, // 无选项
    RemoveScheme = 0x1, // 移除方案
    RemovePassword = 0x2, // 移除密码
    RemoveUserInfo = RemovePassword | 0x4, // 移除用户信息
    RemovePort = 0x8, // 移除端口
    RemoveAuthority = RemoveUserInfo | RemovePort | 0x10, // 移除权限
    RemovePath = 0x20, // 移除路径
    RemoveQuery = 0x40, // 移除查询
    RemoveFragment = 0x80, // 移除片段
    PreferLocalFile = 0x200, // 优先本地文件
    StripTrailingSlash = 0x400, // 去除末尾斜杠
    NormalizePathSegments = 0x800, // 规范化路径段
    PrettyDecoded = 0x1000, // 美化解码
    EncodeSpaces = 0x2000, // 编码空格
    EncodeUnicode = 0x4000, // 编码 Unicode
    EncodeDelimiters = 0x8000 | 0x10000, // 编码分隔符
    EncodeReserved = 0x20000, // 编码保留字符
    DecodeReserved = 0x40000, // 解码保留字符
    FullyEncoded = EncodeSpaces | EncodeUnicode | EncodeDelimiters | EncodeReserved, // 完全编码
    FullyDecoded = PrettyDecoded | DecodeReserved // 完全解码
};

Q_DECLARE_FLAGS(FormattingOptions, FormattingOption)
Q_DECLARE_OPERATORS_FOR_FLAGS(QUrl::FormattingOptions)

QTcpSocket：用于 TCP 通信。

// QTcpSocket 类是 Qt 框架中用于 TCP 套接字通信的重要类。以下是 QTcpSocket 类的所有成员函数和枚举类型的详细列表：

// 继承自 QAbstractSocket
class QTcpSocket : public QAbstractSocket {
    Q_OBJECT

public:
    // 构造函数
    QTcpSocket(QObject *parent = nullptr); // 默认构造函数

    // 析构函数
    ~QTcpSocket(); // 析构函数

    // 公共成员函数
    void connectToHost(const QString &hostName, quint16 port, OpenMode openMode = ReadWrite, NetworkLayerProtocol protocol = AnyIPProtocol); // 连接到主机
    void connectToHost(const QHostAddress &address, quint16 port, OpenMode openMode = ReadWrite); // 连接到主机
    void disconnectFromHost(); // 断开连接
    bool setSocketDescriptor(qintptr socketDescriptor, SocketState state = ConnectedState, OpenMode openMode = ReadWrite); // 设置套接字描述符
    qintptr socketDescriptor() const; // 返回套接字描述符
    bool waitForConnected(int msecs = 30000); // 等待连接
    bool waitForDisconnected(int msecs = 30000); // 等待断开连接
    bool waitForReadyRead(int msecs = 30000); // 等待数据可读
    bool waitForBytesWritten(int msecs = 30000); // 等待数据写入
    qint64 readData(char *data, qint64 maxlen); // 读取数据
    qint64 writeData(const char *data, qint64 len); // 写入数据
    qint64 bytesAvailable() const; // 返回可读字节数
    qint64 bytesToWrite() const; // 返回待写字节数
    bool canReadLine() const; // 检查是否可以读取一行数据
    void close(); // 关闭套接字
    SocketType socketType() const; // 返回套接字类型
    SocketState state() const; // 返回套接字状态
    SocketError error() const; // 返回套接字错误
    QString errorString() const; // 返回错误描述
    void setLocalAddress(const QHostAddress &address); // 设置本地地址
    QHostAddress localAddress() const; // 返回本地地址
    void setLocalPort(quint16 port); // 设置本地端口
    quint16 localPort() const; // 返回本地端口
    void setPeerAddress(const QHostAddress &address); // 设置对端地址
    QHostAddress peerAddress() const; // 返回对端地址
    void setPeerPort(quint16 port); // 设置对端端口
    quint16 peerPort() const; // 返回对端端口
    void setPeerName(const QString &name); // 设置对端名称
    QString peerName() const; // 返回对端名称
    void setReadBufferSize(qint64 size); // 设置读取缓冲区大小
    qint64 readBufferSize() const; // 返回读取缓冲区大小
    void setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value); // 设置套接字选项
    QVariant socketOption(QAbstractSocket::SocketOption option); // 返回套接字选项
    bool isSequential() const; // 检查是否是顺序访问
    bool atEnd() const; // 检查是否在流的末尾
    qint64 pos() const; // 返回当前位置
    qint64 size() const; // 返回大小
    bool seek(qint64 pos); // 定位到指定位置
    bool reset(); // 重置
    bool flush(); // 刷新
    bool waitForReadyRead(int msecs); // 等待数据可读
    bool waitForBytesWritten(int msecs); // 等待数据写入
    bool open(OpenMode mode); // 打开套接字
    bool isOpen() const; // 检查套接字是否打开
    bool isReadable() const; // 检查套接字是否可读
    bool isWritable() const; // 检查套接字是否可写
    OpenMode openMode() const; // 返回打开模式
    QString fileName() const; // 返回文件名
    bool setSocketDescriptor(qintptr socketDescriptor, SocketState state = ConnectedState, OpenMode openMode = ReadWrite); // 设置套接字描述符
    qintptr socketDescriptor() const; // 返回套接字描述符
    bool isValid() const; // 检查套接字是否有效
    qint64 bytesAvailable() const; // 返回可读字节数
    qint64 bytesToWrite() const; // 返回待写字节数
    bool canReadLine() const; // 检查是否可以读取一行数据
    void close(); // 关闭套接字
    void abort(); // 中止套接字
    SocketType socketType() const; // 返回套接字类型
    SocketState state() const; // 返回套接字状态
    SocketError error() const; // 返回套接字错误
    QString errorString() const; // 返回错误描述
    void setLocalAddress(const QHostAddress &address); // 设置本地地址
    QHostAddress localAddress() const; // 返回本地地址
    void setLocalPort(quint16 port); // 设置本地端口
    quint16 localPort() const; // 返回本地端口
    void setPeerAddress(const QHostAddress &address); // 设置对端地址
    QHostAddress peerAddress() const; // 返回对端地址
    void setPeerPort(quint16 port); // 设置对端端口
    quint16 peerPort() const; // 返回对端端口
    void setPeerName(const QString &name); // 设置对端名称
    QString peerName() const; // 返回对端名称
    void setReadBufferSize(qint64 size); // 设置读取缓冲区大小
    qint64 readBufferSize() const; // 返回读取缓冲区大小
    void setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value); // 设置套接字选项
    QVariant socketOption(QAbstractSocket::SocketOption option); // 返回套接字选项
    bool isSequential() const; // 检查是否是顺序访问
    bool atEnd() const; // 检查是否在流的末尾
    qint64 pos() const; // 返回当前位置
    qint64 size() const; // 返回大小
    bool seek(qint64 pos); // 定位到指定位置
    bool reset(); // 重置
    bool flush(); // 刷新

    // 信号
signals:
    void connected(); // 连接成功信号
    void disconnected(); // 断开连接信号
    void errorOccurred(QAbstractSocket::SocketError socketError); // 错误发生信号
    void stateChanged(QAbstractSocket::SocketState socketState); // 状态改变信号
    void readyRead(); // 数据可读信号
    void bytesWritten(qint64 bytes); // 数据写入信号
    void aboutToClose(); // 即将关闭信号
    void readChannelFinished(); // 读取通道完成信号

    // 枚举类型
    enum SocketType {
        TcpSocket // TCP 套接字
    };

    enum SocketState {
        UnconnectedState, // 未连接状态
        HostLookupState, // 主机查找状态
        ConnectingState, // 连接中状态
        ConnectedState, // 已连接状态
        BoundState, // 绑定状态
        ListeningState, // 监听状态
        ClosingState // 关闭中状态
    };

    enum SocketError {
        ConnectionRefusedError, // 连接被拒绝错误
        RemoteHostClosedError, // 远程主机关闭错误
        HostNotFoundError, // 主机未找到错误
        SocketAccessError, // 套接字访问错误
        SocketResourceError, // 套接字资源错误
        SocketTimeoutError, // 套接字超时错误
        DatagramTooLargeError, // 数据报太大错误
        NetworkError, // 网络错误
        AddressInUseError, // 地址已被使用错误
        SocketAddressNotAvailableError, // 套接字地址不可用错误
        UnsupportedSocketOperationError, // 不支持的套接字操作错误
        UnfinishedSocketOperationError, // 未完成的套接字操作错误
        ProxyAuthenticationRequiredError, // 需要代理认证错误
        SslHandshakeFailedError, // SSL 握手失败错误
        ProxyConnectionRefusedError, // 代理连接被拒绝错误
        ProxyConnectionClosedError, // 代理连接关闭错误
        ProxyConnectionTimeoutError, // 代理连接超时错误
        ProxyNotFoundError, // 代理未找到错误
        ProxyProtocolError, // 代理协议错误
        OperationError, // 操作错误
        SslInternalError, // SSL 内部错误
        SslInvalidUserDataError, // SSL 无效用户数据错误
        TemporaryError, // 临时错误
        UnknownSocketError // 未知套接字错误
    };

    enum NetworkLayerProtocol {
        IPv4Protocol, // IPv4 协议
        IPv6Protocol, // IPv6 协议
        AnyIPProtocol, // 任意 IP 协议
        UnknownNetworkLayerProtocol // 未知网络层协议
    };

    enum SocketOption {
        LowDelayOption, // 低延迟选项
        KeepAliveOption, // 保持活动选项
        MulticastTtlOption, // 多播 TTL 选项
        MulticastLoopbackOption, // 多播环回选项
        TypeOfServiceOption, // 服务类型选项
        ReceiveBufferSizeSocketOption, // 接收缓冲区大小选项
        SendBufferSizeSocketOption // 发送缓冲区大小选项
    };

    enum OpenModeFlag {
        NotOpen = 0x0000, // 不打开
        ReadOnly = 0x0001, // 只读
        WriteOnly = 0x0002, // 只写
        ReadWrite = ReadOnly | WriteOnly, // 读写
        Append = 0x0004, // 追加
        Truncate = 0x0008, // 截断
        Text = 0x0010, // 文本
        Unbuffered = 0x0020 // 无缓冲
    };

    Q_DECLARE_FLAGS(OpenMode, OpenModeFlag)
    Q_DECLARE_OPERATORS_FOR_FLAGS(QTcpSocket::OpenMode)
};

QUdpSocket：用于 UDP 通信。

// QUdpSocket 类是 Qt 框架中用于 UDP 套接字通信的重要类。以下是 QUdpSocket 类的所有成员函数和枚举类型的详细列表：

// 继承自 QAbstractSocket
class QUdpSocket : public QAbstractSocket {
    Q_OBJECT

public:
    // 构造函数
    QUdpSocket(QObject *parent = nullptr); // 默认构造函数

    // 析构函数
    ~QUdpSocket(); // 析构函数

    // 公共成员函数
    bool bind(const QHostAddress &address, quint16 port, QAbstractSocket::BindMode mode = DefaultForPlatform); // 绑定到地址和端口
    bool bind(quint16 port = 0, QAbstractSocket::BindMode mode = DefaultForPlatform); // 绑定到端口
    void close(); // 关闭套接字
    qint64 readDatagram(char *data, qint64 maxSize, QHostAddress *address = nullptr, quint16 *port = nullptr); // 读取数据报
    qint64 writeDatagram(const char *data, qint64 size, const QHostAddress &address, quint16 port); // 写入数据报
    qint64 writeDatagram(const QByteArray &datagram, const QHostAddress &host, quint16 port); // 写入数据报
    bool hasPendingDatagrams() const; // 检查是否有待处理的数据报
    qint64 pendingDatagramSize() const; // 返回待处理数据报的大小
    bool joinMulticastGroup(const QHostAddress &groupAddress); // 加入多播组
    bool leaveMulticastGroup(const QHostAddress &groupAddress); // 离开多播组
    QHostAddress multicastGroup() const; // 返回多播组地址
    void setMulticastInterface(const QNetworkInterface &iface); // 设置多播接口
    QNetworkInterface multicastInterface() const; // 返回多播接口

    // 信号
signals:
    void readyRead(); // 数据可读信号

    // 枚举类型
    enum BindFlag {
        DefaultForPlatform = 0x0, // 默认平台行为
        ShareAddress = 0x1, // 共享地址
        DontShareAddress = 0x2, // 不共享地址
        ReuseAddressHint = 0x4, // 重用地址提示
        DefaultForPlatformBindMode = DefaultForPlatform // 默认平台绑定模式
    };

    Q_DECLARE_FLAGS(BindMode, BindFlag)
    Q_DECLARE_OPERATORS_FOR_FLAGS(QUdpSocket::BindMode)
};

XML(空)

QDomDocument：用于处理 XML 文档。

QXmlStreamReader：用于快速解析 XML。

QXmlStreamWriter：用于快速生成 XML。

数据库

QSqlDatabase：用于连接数据库。

// QSqlDatabase 类是 Qt 框架中用于管理数据库连接的类。它提供了一组函数来创建、配置和关闭数据库连接。以下是 QSqlDatabase 类的所有成员函数和静态函数的详细列表：

// 构造函数和析构函数
QSqlDatabase(); // 默认构造函数
QSqlDatabase(const QSqlDatabase &other); // 拷贝构造函数
~QSqlDatabase(); // 析构函数

// 公共函数
bool isValid() const; // 检查数据库连接是否有效
QString driverName() const; // 获取数据库驱动名称
QSqlDriver *driver() const; // 获取数据库驱动对象
QString databaseName() const; // 获取数据库名称
void setDatabaseName(const QString &name); // 设置数据库名称
QString hostName() const; // 获取主机名
void setHostName(const QString &host); // 设置主机名
int port() const; // 获取端口号
void setPort(int port); // 设置端口号
QString userName() const; // 获取用户名
void setUserName(const QString &name); // 设置用户名
QString password() const; // 获取密码
void setPassword(const QString &password); // 设置密码
QString connectOptions() const; // 获取连接选项
void setConnectOptions(const QString &options = QString()); // 设置连接选项
bool open(); // 打开数据库连接
bool open(const QString &user, const QString &password); // 使用指定用户和密码打开数据库连接
void close(); // 关闭数据库连接
bool isOpen() const; // 检查数据库是否已打开
bool isOpenError() const; // 检查打开数据库时是否有错误
QSqlError lastError() const; // 获取最后发生的错误
QStringList tables(QSql::TableType type = QSql::Tables) const; // 获取数据库中的表列表
QSqlIndex primaryIndex(const QString &tablename) const; // 获取表的主键索引
QSqlRecord record(const QString &tablename) const; // 获取表的记录
QSqlDatabase &operator=(const QSqlDatabase &other); // 赋值运算符
void setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy precisionPolicy); // 设置数值精度策略
QSql::NumericalPrecisionPolicy numericalPrecisionPolicy() const; // 获取数值精度策略

// 静态函数
static QSqlDatabase addDatabase(const QString &type, const QString &connectionName = QLatin1String(defaultConnection)); // 添加数据库连接
static QSqlDatabase database(const QString &connectionName = QLatin1String(defaultConnection), bool open = true); // 获取数据库连接
static QStringList connectionNames(); // 获取所有连接名称
static bool contains(const QString &connectionName = QLatin1String(defaultConnection)); // 检查是否包含指定连接名称
static void removeDatabase(const QString &connectionName); // 移除数据库连接
static QStringList drivers(); // 获取所有可用的数据库驱动
static void registerSqlDriver(const QString &name, QSqlDriverCreatorBase *creator); // 注册自定义数据库驱动
static void removeDatabase(const QString &connectionName); // 移除数据库连接（重载）

QSqlQuery：用于执行 SQL 查询。

// QSqlQuery 类是 Qt 框架中用于执行 SQL 语句和处理查询结果的类。它提供了一组函数来执行 SQL 语句、遍历结果集以及获取查询结果。以下是 QSqlQuery 类的所有成员函数和枚举类型的详细列表：

// 构造函数和析构函数
QSqlQuery(const QString &query = QString(), QSqlDatabase db = QSqlDatabase()); // 使用 SQL 查询和数据库连接构造查询对象
QSqlQuery(QSqlDatabase db); // 使用数据库连接构造查询对象
QSqlQuery(const QSqlQuery &other); // 拷贝构造函数
~QSqlQuery(); // 析构函数

// 公共函数
QSqlQuery &operator=(const QSqlQuery &other); // 赋值运算符
bool isValid() const; // 检查当前记录是否有效
bool isActive() const; // 检查查询是否处于活动状态
bool isSelect() const; // 检查查询是否为 SELECT 语句
bool isForwardOnly() const; // 检查查询是否为仅向前模式
void setForwardOnly(bool forward); // 设置查询为仅向前模式
bool exec(const QString &query); // 执行 SQL 语句
bool exec(); // 执行预准备的 SQL 语句
bool execBatch(QSqlQuery::BatchExecutionMode mode = ValuesAsRows); // 执行批处理 SQL 语句
bool prepare(const QString &query); // 准备 SQL 语句
void bindValue(const QString &placeholder, const QVariant &val, QSql::ParamType paramType = QSql::In); // 绑定值到占位符
void bindValue(int pos, const QVariant &val, QSql::ParamType paramType = QSql::In); // 绑定值到位置
void addBindValue(const QVariant &val, QSql::ParamType paramType = QSql::In); // 添加绑定值
QVariant boundValue(const QString &placeholder) const; // 获取绑定到占位符的值
QVariant boundValue(int pos) const; // 获取绑定到位置的值
QMap<QString, QVariant> boundValues() const; // 获取所有绑定的值
QString executedQuery() const; // 获取最后执行的查询
QSqlError lastError() const; // 获取最后发生的错误
bool isNull(const QString &name) const; // 检查字段是否为 NULL
bool isNull(int field) const; // 检查字段是否为 NULL
QVariant value(const QString &name) const; // 获取字段值
QVariant value(int index) const; // 获取字段值
bool next(); // 移动到下一条记录
bool previous(); // 移动到上一条记录
bool first(); // 移动到第一条记录
bool last(); // 移动到最后一条记录
bool seek(int index, bool relative = false); // 移动到指定记录
int at() const; // 获取当前记录的位置
QString lastQuery() const; // 获取最后执行的查询
int numRowsAffected() const; // 获取受影响的行数
int size() const; // 获取结果集的大小
QSqlRecord record() const; // 获取当前记录
void clear(); // 清除查询
const QSqlDriver *driver() const; // 获取数据库驱动
const QSqlResult *result() const; // 获取 SQL 结果

// 枚举类型
enum BatchExecutionMode {
    ValuesAsRows, // 将值作为行处理
    ValuesAsColumns // 将值作为列处理
};

QSqlTableModel：用于处理数据库表的模型。

// QSqlTableModel 类是 Qt 框架中用于提供数据库表的模型视图支持的类。它继承自 QSqlQueryModel 并提供了对单个数据库表的编辑功能。以下是 QSqlTableModel 类的所有成员函数和信号的详细列表：

// 构造函数和析构函数
QSqlTableModel(QObject *parent = nullptr, QSqlDatabase db = QSqlDatabase()); // 使用父对象和数据库连接构造模型对象
~QSqlTableModel(); // 析构函数

// 公共函数
void setTable(const QString &tableName); // 设置数据库表
QString tableName() const; // 获取数据库表名称
void setFilter(const QString &filter); // 设置过滤条件
QString filter() const; // 获取过滤条件
void setSort(int column, Qt::SortOrder order); // 设置排序条件
void setEditStrategy(QSqlTableModel::EditStrategy strategy); // 设置编辑策略
QSqlTableModel::EditStrategy editStrategy() const; // 获取编辑策略
bool select(); // 执行选择操作
int rowCount(const QModelIndex &parent = QModelIndex()) const; // 获取行数
int columnCount(const QModelIndex &parent = QModelIndex()) const; // 获取列数
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const; // 获取数据
bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole); // 设置数据
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const; // 获取表头数据
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role = Qt::EditRole); // 设置表头数据
QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const; // 获取模型索引
QModelIndex parent(const QModelIndex &index) const; // 获取父模型索引
Qt::ItemFlags flags(const QModelIndex &index) const; // 获取项标志
bool insertRow(int row, const QModelIndex &parent = QModelIndex()); // 插入行
bool insertRows(int row, int count, const QModelIndex &parent = QModelIndex()); // 插入多行
bool removeRow(int row, const QModelIndex &parent = QModelIndex()); // 移除行
bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex()); // 移除多行
bool submit(); // 提交更改
void revert(); // 回滚更改
QSqlRecord record(int row) const; // 获取记录
QSqlRecord record() const; // 获取空记录
bool insertRecord(int row, const QSqlRecord &record); // 插入记录
bool setRecord(int row, const QSqlRecord &record); // 设置记录
bool updateRowInTable(int row, const QSqlRecord &record); // 更新表中的行
bool insertRowIntoTable(const QSqlRecord &record); // 插入行到表中
bool deleteRowFromTable(int row); // 从表中删除行
QSqlDatabase database() const; // 获取数据库连接
void clear(); // 清除模型

// 信号
void primeInsert(int row, QSqlRecord &record); // 插入前信号
void beforeInsert(QSqlRecord &record); // 插入前信号
void beforeUpdate(int row, QSqlRecord &record); // 更新前信号
void beforeDelete(int row); // 删除前信号

// 枚举类型
enum EditStrategy {
    OnFieldChange, // 字段更改时提交
    OnRowChange, // 行更改时提交
    OnManualSubmit // 手动提交
};

多媒体(空)

QMediaPlayer：用于播放音频和视频。

QMediaPlaylist：用于管理多媒体播放列表。

WEB(空)

WebEngineView：用于显示 Web 内容（基于 Chromium）。

QWebChannel：用于与 Web 页面进行通信。

国际化和本地化(空)

QLocale：用于处理本地化设置，如日期格式、数字格式等。

QTranslator：用于应用程序的国际化翻译。

其他实用工具

QSettings：用于持久化应用程序设置。

QFileSystemWatcher：用于监控文件和目录的变化。

QProcess：用于启动外部进程并与它们进行通信。

QTimer：用于定时器操作。

QEvent：用于事件处理。

QThread：用于多线程编程。

基础控件：

QWidget：所有用户界面元素的基类。

QPushButton：按钮控件。

// QPushButton 类是 Qt 框架中用于创建按钮的类。它继承自 QAbstractButton，并提供了创建和操作按钮的功能。以下是 QPushButton 类的所有成员函数和信号的详细列表：

// 构造函数和析构函数
QPushButton(QWidget *parent = nullptr); // 使用父对象构造按钮
QPushButton(const QString &text, QWidget *parent = nullptr); // 使用文本和父对象构造按钮
QPushButton(const QIcon &icon, const QString &text, QWidget *parent = nullptr); // 使用图标、文本和父对象构造按钮
~QPushButton(); // 析构函数

// 公共函数
void setCheckable(bool checkable); // 设置按钮是否可选中
bool isCheckable() const; // 检查按钮是否可选中
bool isChecked() const; // 检查按钮是否被选中
void setAutoRepeat(bool autoRepeat); // 设置按钮是否自动重复
bool autoRepeat() const; // 检查按钮是否自动重复
void setAutoRepeatDelay(int delay); // 设置自动重复延迟
int autoRepeatDelay() const; // 获取自动重复延迟
void setAutoRepeatInterval(int interval); // 设置自动重复间隔
int autoRepeatInterval() const; // 获取自动重复间隔
void setDefault(bool defaultButton); // 设置按钮是否为默认按钮
bool isDefault() const; // 检查按钮是否为默认按钮
void setFlat(bool flat); // 设置按钮是否为平面样式
bool isFlat() const; // 检查按钮是否为平面样式
void setMenu(QMenu *menu); // 设置按钮的菜单
QMenu *menu() const; // 获取按钮的菜单
void showMenu(); // 显示按钮的菜单

// 重载的公共函数
QSize sizeHint() const; // 获取推荐大小
QSize minimumSizeHint() const; // 获取最小推荐大小

// 保护函数
void paintEvent(QPaintEvent *event); // 绘制事件
bool event(QEvent *e); // 事件处理

// 信号
void pressed(); // 按钮按下信号
void released(); // 按钮释放信号
void clicked(bool checked = false); // 按钮点击信号
void toggled(bool checked); // 按钮切换信号

QLabel：标签控件，用于显示文本或图像。

// QLabel 类是 Qt 框架中用于显示文本或图像的类。它继承自 QFrame，并提供了创建和操作标签的功能。以下是 QLabel 类的所有成员函数和信号的详细列表：

// 构造函数和析构函数
QLabel(QWidget *parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags()); // 使用父对象和窗口标志构造标签
QLabel(const QString &text, QWidget *parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags()); // 使用文本、父对象和窗口标志构造标签
~QLabel(); // 析构函数

// 公共函数
void setText(const QString &text); // 设置标签文本
QString text() const; // 获取标签文本
void setAlignment(Qt::Alignment alignment); // 设置文本对齐方式
Qt::Alignment alignment() const; // 获取文本对齐方式
void setIndent(int indent); // 设置文本缩进
int indent() const; // 获取文本缩进
void setMargin(int margin); // 设置边距
int margin() const; // 获取边距
void setPixmap(const QPixmap &pixmap); // 设置标签图像
QPixmap pixmap() const; // 获取标签图像
void setPicture(const QPicture &picture); // 设置标签图片
QPicture picture() const; // 获取标签图片
void setMovie(QMovie *movie); // 设置标签动画
QMovie *movie() const; // 获取标签动画
void setNum(int num); // 设置标签数字
void setNum(double num); // 设置标签数字
void setScaledContents(bool scaled); // 设置内容是否缩放
bool hasScaledContents() const; // 检查内容是否缩放
void setOpenExternalLinks(bool open); // 设置是否打开外部链接
bool openExternalLinks() const; // 检查是否打开外部链接
void setTextFormat(Qt::TextFormat format); // 设置文本格式
Qt::TextFormat textFormat() const; // 获取文本格式
void setTextInteractionFlags(Qt::TextInteractionFlags flags); // 设置文本交互标志
Qt::TextInteractionFlags textInteractionFlags() const; // 获取文本交互标志
void setWordWrap(bool on); // 设置是否自动换行
bool wordWrap() const; // 检查是否自动换行
QSize sizeHint() const; // 获取推荐大小
QSize minimumSizeHint() const; // 获取最小推荐大小

// 保护函数
void changeEvent(QEvent *ev); // 更改事件
void mousePressEvent(QMouseEvent *ev); // 鼠标按下事件
void mouseReleaseEvent(QMouseEvent *ev); // 鼠标释放事件
void paintEvent(QPaintEvent *ev); // 绘制事件
void focusInEvent(QFocusEvent *ev); // 获取焦点事件
void focusOutEvent(QFocusEvent *ev); // 失去焦点事件
void keyPressEvent(QKeyEvent *ev); // 按键按下事件
void keyReleaseEvent(QKeyEvent *ev); // 按键释放事件
void contextMenuEvent(QContextMenuEvent *ev); // 上下文菜单事件
void wheelEvent(QWheelEvent *ev); // 滚轮事件

// 信号
void linkActivated(const QString &link); // 链接激活信号
void linkHovered(const QString &link); // 链接悬停信号

QLineEdit：单行文本输入框。

// QLineEdit 类是 Qt 框架中用于输入和编辑单行文本的类。它继承自 QWidget，并提供了创建和操作单行文本编辑器的功能。以下是 QLineEdit 类的所有成员函数和信号的详细列表：

// 构造函数和析构函数
QLineEdit(QWidget *parent = nullptr); // 使用父对象构造单行文本编辑器
QLineEdit(const QString &contents, QWidget *parent = nullptr); // 使用内容和父对象构造单行文本编辑器
~QLineEdit(); // 析构函数

// 公共函数
void setText(const QString &text); // 设置文本
QString text() const; // 获取文本
void setPlaceholderText(const QString &text); // 设置占位文本
QString placeholderText() const; // 获取占位文本
void setAlignment(Qt::Alignment flag); // 设置对齐方式
Qt::Alignment alignment() const; // 获取对齐方式
void cursorBackward(bool mark, int steps = 1); // 向后移动光标
void cursorForward(bool mark, int steps = 1); // 向前移动光标
void cursorWordBackward(bool mark); // 向后移动一个单词
void cursorWordForward(bool mark); // 向前移动一个单词
void backspace(); // 删除光标前的字符
void del(); // 删除光标后的字符
void home(bool mark); // 移动光标到行首
void end(bool mark); // 移动光标到行尾
void setCursorPosition(int); // 设置光标位置
int cursorPosition() const; // 获取光标位置
int cursorPositionAt(const QPoint &pos); // 获取指定位置的光标位置
void setDragEnabled(bool b); // 设置是否启用拖放
bool dragEnabled() const; // 检查是否启用拖放
void setReadOnly(bool); // 设置是否只读
bool isReadOnly() const; // 检查是否只读
void setFrame(bool); // 设置是否有边框
bool hasFrame() const; // 检查是否有边框
void setTextMargins(int left, int top, int right, int bottom); // 设置文本边距
void setTextMargins(const QMargins &margins); // 设置文本边距
QMargins textMargins() const; // 获取文本边距
void setValidator(const QValidator *v); // 设置验证器
const QValidator *validator() const; // 获取验证器
void setCompleter(QCompleter *c); // 设置自动完成器
QCompleter *completer() const; // 获取自动完成器
QSize sizeHint() const; // 获取推荐大小
QSize minimumSizeHint() const; // 获取最小推荐大小
void setEchoMode(EchoMode); // 设置回显模式
EchoMode echoMode() const; // 获取回显模式
bool isModified() const; // 检查文本是否被修改
void setModified(bool); // 设置文本修改状态
void setSelection(int start, int length); // 设置选中文本
bool hasSelectedText() const; // 检查是否有选中文本
QString selectedText() const; // 获取选中文本
int selectionStart() const; // 获取选中文本的起始位置
bool isUndoAvailable() const; // 检查撤销是否可用
bool isRedoAvailable() const; // 检查重做是否可用
void setDragEnabled(bool b); // 设置是否启用拖放
bool dragEnabled() const; // 检查是否启用拖放
void setCursorMoveStyle(Qt::CursorMoveStyle style); // 设置光标移动风格
Qt::CursorMoveStyle cursorMoveStyle() const; // 获取光标移动风格
void setInputMask(const QString &inputMask); // 设置输入掩码
QString inputMask() const; // 获取输入掩码
void setContextMenuPolicy(Qt::ContextMenuPolicy policy); // 设置上下文菜单策略
Qt::ContextMenuPolicy contextMenuPolicy() const; // 获取上下文菜单策略

// 公共槽
void clear(); // 清除文本
void selectAll(); // 全选文本
void undo(); // 撤销
void redo(); // 重做
void cut(); // 剪切
void copy() const; // 复制
void paste(); // 粘贴
void deselect(); // 取消选择
void insert(const QString &); // 插入文本

// 信号
void textChanged(const QString &text); // 文本改变信号
void textEdited(const QString &text); // 文本编辑信号
void cursorPositionChanged(int old, int new); // 光标位置改变信号
void returnPressed(); // 按下回车信号
void editingFinished(); // 编辑完成信号
void selectionChanged(); // 选中文本改变信号

// 枚举类型
enum EchoMode { Normal, NoEcho, Password, PasswordEchoOnEdit }; // 回显模式

QTextEdit：多行文本输入框。

QTextEdit 类提供了显示和编辑富文本的基本功能，可以通过设置文本、占位文本、对齐方式和字体样式来定制富文本编辑器。

它还提供了处理文本选择、撤销、重做和剪切复制粘贴的公共槽，以及文本改变、选中文本改变和光标位置改变的信号。

// QTextEdit 类是 Qt 框架中用于显示和编辑富文本的类。它继承自 QAbstractScrollArea，并提供了创建和操作富文本编辑器的功能。以下是 QTextEdit 类的所有成员函数和信号的详细列表：

// 构造函数和析构函数
QTextEdit(QWidget *parent = nullptr); // 使用父对象构造富文本编辑器
QTextEdit(const QString &text, QWidget *parent = nullptr); // 使用文本和父对象构造富文本编辑器
~QTextEdit(); // 析构函数

// 公共函数
void setText(const QString &text); // 设置文本
QString text() const; // 获取纯文本
QString toPlainText() const; // 获取纯文本
QString toHtml() const; // 获取 HTML 文本
void setHtml(const QString &text); // 设置 HTML 文本
void setPlaceholderText(const QString &text); // 设置占位文本
QString placeholderText() const; // 获取占位文本
void setAlignment(Qt::Alignment a); // 设置对齐方式
Qt::Alignment alignment() const; // 获取对齐方式
void setCurrentFont(const QFont &f); // 设置当前字体
QFont currentFont() const; // 获取当前字体
void setFontFamily(const QString &fontFamily); // 设置字体族
QString fontFamily() const; // 获取字体族
void setFontPointSize(qreal s); // 设置字体点大小
qreal fontPointSize() const; // 获取字体点大小
void setFontWeight(int w); // 设置字体权重
int fontWeight() const; // 获取字体权重
void setFontItalic(bool b); // 设置字体是否斜体
bool fontItalic() const; // 检查字体是否斜体
void setFontUnderline(bool b); // 设置字体是否下划线
bool fontUnderline() const; // 检查字体是否下划线
void setTextColor(const QColor &c); // 设置文本颜色
QColor textColor() const; // 获取文本颜色
void setTextBackgroundColor(const QColor &c); // 设置文本背景颜色
QColor textBackgroundColor() const; // 获取文本背景颜色
void setTabChangesFocus(bool b); // 设置按 Tab 键是否改变焦点
bool tabChangesFocus() const; // 检查按 Tab 键是否改变焦点
void setTabStopDistance(qreal distance); // 设置 Tab 键停止距离
qreal tabStopDistance() const; // 获取 Tab 键停止距离
void setDocument(QTextDocument *document); // 设置文档
QTextDocument *document() const; // 获取文档
void setUndoRedoEnabled(bool enable); // 设置是否启用撤销和重做
bool isUndoRedoEnabled() const; // 检查是否启用撤销和重做
void setLineWrapMode(LineWrapMode mode); // 设置换行模式
LineWrapMode lineWrapMode() const; // 获取换行模式
void setLineWrapColumnOrWidth(int w); // 设置换行列或宽度
int lineWrapColumnOrWidth() const; // 获取换行列或宽度
void setReadOnly(bool ro); // 设置是否只读
bool isReadOnly() const; // 检查是否只读
void setOverwriteMode(bool overwrite); // 设置是否覆盖模式
bool overwriteMode() const; // 检查是否覆盖模式
void setAcceptRichText(bool accept); // 设置是否接受富文本
bool acceptRichText() const; // 检查是否接受富文本
void setTextCursor(const QTextCursor &cursor); // 设置文本光标
QTextCursor textCursor() const; // 获取文本光标
bool canPaste() const; // 检查是否可以粘贴
QVariant inputMethodQuery(Qt::InputMethodQuery query) const; // 输入法查询
QSize sizeHint() const; // 获取推荐大小
QSize minimumSizeHint() const; // 获取最小推荐大小

// 公共槽
void clear(); // 清除文本
void selectAll(); // 全选文本
void undo(); // 撤销
void redo(); // 重做
void cut(); // 剪切
void copy() const; // 复制
void paste(); // 粘贴
void append(const QString &text); // 追加文本
void scrollToAnchor(const QString &name); // 滚动到锚点
void insertHtml(const QString &text); // 插入 HTML 文本
void insertPlainText(const QString &text); // 插入纯文本
void ensureCursorVisible(); // 确保光标可见

// 信号
void textChanged(); // 文本改变信号
void selectionChanged(); // 选中文本改变信号
void cursorPositionChanged(); // 光标位置改变信号
void currentCharFormatChanged(const QTextCharFormat &format); // 当前字符格式改变信号
void copyAvailable(bool yes); // 复制可用信号
void redoAvailable(bool available); // 重做可用信号
void undoAvailable(bool available); // 撤销可用信号
void modificationChanged(bool changed); // 修改状态改变信号

// 枚举类型
enum LineWrapMode { NoWrap, WidgetWidth, FixedPixelWidth, FixedColumnWidth }; // 换行模式

QCheckBox：复选框控件。

QRadioButton：单选按钮控件。

QComboBox：下拉框控件。

QSlider：滑动条控件。

QSpinBox：数字微调框控件。

布局管理：

QHBoxLayout：水平布局管理器。

QVBoxLayout：垂直布局管理器。

QGridLayout：网格布局管理器。

QFormLayout：表单布局管理器。

容器控件：

QGroupBox：分组框控件。

QTabWidget：选项卡控件。

QStackedWidget：堆叠控件，一次只显示一个子控件。

QScrollArea：滚动区域控件。

高级控件：

QTreeWidget：树形控件。

QTableWidget：表格控件。

QListView：列表视图控件。

QProgressBar：进度条控件。

QDialog：对话框控件。

QMessageBox：消息框控件。

主窗口和菜单：

QMainWindow：主窗口控件。

QMenuBar：菜单栏控件。

QToolBar：工具栏控件。

QStatusBar：状态栏控件。

鼠标和键盘

QMouseEvent：鼠标事件。

class QMouseEvent : public QInputEvent {
public:
    // 构造函数
    QMouseEvent(QEvent::Type type, const QPointF &localPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers);
    QMouseEvent(QEvent::Type type, const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers);

    // 公共成员函数
    QPointF localPos() const; // 返回事件的本地坐标位置
    QPointF windowPos() const; // 返回事件的窗口坐标位置
    QPointF screenPos() const; // 返回事件的屏幕坐标位置
    QPoint pos() const; // 返回事件的本地坐标位置（整数精度）
    QPoint globalPos() const; // 返回事件的屏幕坐标位置（整数精度）
    int x() const; // 返回事件的本地坐标位置的 x 坐标（整数精度）
    int y() const; // 返回事件的本地坐标位置的 y 坐标（整数精度）
    int globalX() const; // 返回事件的屏幕坐标位置的 x 坐标（整数精度）
    int globalY() const; // 返回事件的屏幕坐标位置的 y 坐标（整数精度）
    Qt::MouseButton button() const; // 返回触发事件的鼠标按钮
    Qt::MouseButtons buttons() const; // 返回事件发生时所有按下的鼠标按钮

    // 枚举类型
    enum MouseButton {
        NoButton = 0x00000000, // 无按钮
        LeftButton = 0x00000001, // 左键
        RightButton = 0x00000002, // 右键
        MiddleButton = 0x00000004, // 中键
        BackButton = 0x00000008, // 后退按钮
        ForwardButton = 0x00000010, // 前进按钮
        TaskButton = 0x00000020, // 任务按钮
        ExtraButton4 = 0x00000040, // 额外按钮4
        ExtraButton5 = 0x00000080, // 额外按钮5
        ExtraButton6 = 0x00000100, // 额外按钮6
        ExtraButton7 = 0x00000200, // 额外按钮7
        ExtraButton8 = 0x00000400, // 额外按钮8
        ExtraButton9 = 0x00000800, // 额外按钮9
        ExtraButton10 = 0x00001000, // 额外按钮10
        ExtraButton11 = 0x00002000, // 额外按钮11
        ExtraButton12 = 0x00004000, // 额外按钮12
        ExtraButton13 = 0x00008000, // 额外按钮13
        ExtraButton14 = 0x00010000, // 额外按钮14
        ExtraButton15 = 0x00020000, // 额外按钮15
        ExtraButton16 = 0x00040000, // 额外按钮16
        ExtraButton17 = 0x00080000, // 额外按钮17
        ExtraButton18 = 0x00100000, // 额外按钮18
        ExtraButton19 = 0x00200000, // 额外按钮19
        ExtraButton20 = 0x00400000, // 额外按钮20
        ExtraButton21 = 0x00800000, // 额外按钮21
        ExtraButton22 = 0x01000000, // 额外按钮22
        ExtraButton23 = 0x02000000, // 额外按钮23
        ExtraButton24 = 0x04000000, // 额外按钮24
        AllButtons = 0x07ffffff // 所有按钮
    };
};

QKeyEvent：键盘事件。

class QKeyEvent : public QInputEvent {
public:
    // 构造函数
    QKeyEvent(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers, const QString &text = QString(), bool autorep = false, ushort count = 1);

    // 公共成员函数
    int key() const; // 返回触发事件的键盘按键
    QString text() const; // 返回按键对应的文本
    bool isAutoRepeat() const; // 检查事件是否由自动重复触发
    int count() const; // 返回事件的重复次数
    bool matches(QKeySequence::StandardKey key) const; // 检查事件是否匹配指定的标准按键序列

    // 枚举类型
    enum Key {
        Key_Escape = 0x01000000, //  Esc 键
        Key_Tab = 0x01000001, //  Tab 键
        Key_Backtab = 0x01000002, //  Backtab 键
        Key_Backspace = 0x01000003, //  Backspace 键
        Key_Return = 0x01000004, //  Return 键
        Key_Enter = 0x01000005, //  Enter 键
        Key_Insert = 0x01000006, //  Insert 键
        Key_Delete = 0x01000007, //  Delete 键
        Key_Pause = 0x01000008, //  Pause 键
        Key_Print = 0x01000009, //  Print 键
        Key_SysReq = 0x0100000a, //  SysReq 键
        Key_Clear = 0x0100000b, //  Clear 键
        Key_Home = 0x01000010, //  Home 键
        Key_End = 0x01000011, //  End 键
        Key_Left = 0x01000012, //  左箭头键
        Key_Up = 0x01000013, //  上箭头键
        Key_Right = 0x01000014, //  右箭头键
        Key_Down = 0x01000015, //  下箭头键
        Key_PageUp = 0x01000016, //  PageUp 键
        Key_PageDown = 0x01000017, //  PageDown 键
        Key_Shift = 0x01000020, //  Shift 键
        Key_Control = 0x01000021, //  Control 键
        Key_Meta = 0x01000022, //  Meta 键
        Key_Alt = 0x01000023, //  Alt 键
        Key_AltGr = 0x01001103, //  AltGr 键
        Key_CapsLock = 0x01000024, //  CapsLock 键
        Key_NumLock = 0x01000025, //  NumLock 键
        Key_ScrollLock = 0x01000026, //  ScrollLock 键
        Key_F1 = 0x01000030, //  F1 键
        Key_F2 = 0x01000031, //  F2 键
        Key_F3 = 0x01000032, //  F3 键
        Key_F4 = 0x01000033, //  F4 键
        Key_F5 = 0x01000034, //  F5 键
        Key_F6 = 0x01000035, //  F6 键
        Key_F7 = 0x01000036, //  F7 键
        Key_F8 = 0x01000037, //  F8 键
        Key_F9 = 0x01000038, //  F9 键
        Key_F10 = 0x01000039, //  F10 键
        Key_F11 = 0x0100003a, //  F11 键
        Key_F12 = 0x0100003b, //  F12 键
        Key_F13 = 0x0100003c, //  F13 键
        Key_F14 = 0x0100003d, //  F14 键
        Key_F15 = 0x0100003e, //  F15 键
        Key_F16 = 0x0100003f, //  F16 键
        Key_F17 = 0x01000040, //  F17 键
        Key_F18 = 0x01000041, //  F18 键
        Key_F19 = 0x01000042, //  F19 键
        Key_F20 = 0x01000043, //  F20 键
        Key_F21 = 0x01000044, //  F21 键
        Key_F22 = 0x01000045, //  F22 键
        Key_F23 = 0x01000046, //  F23 键
        Key_F24 = 0x01000047, //  F24 键
        Key_F25 = 0x01000048, //  F25 键
        Key_F26 = 0x01000049, //  F26 键
        Key_F27 = 0x0100004a, //  F27 键
        Key_F28 = 0x0100004b, //  F28 键
        Key_F29 = 0x0100004c, //  F29 键
        Key_F30 = 0x0100004d, //  F30 键
        Key_F31 = 0x0100004e, //  F31 键
        Key_F32 = 0x0100004f, //  F32 键
        Key_F33 = 0x01000050, //  F33 键
        Key_F34 = 0x01000051, //  F34 键
        Key_F35 = 0x01000052, //  F35 键
        Key_Super_L = 0x01000053, //  左 Super 键
        Key_Super_R = 0x01000054, //  右 Super 键
        Key_Menu = 0x01000055, //  Menu 键
        Key_Hyper_L = 0x01000056, //  左 Hyper 键
        Key_Hyper_R = 0x01000057, //  右 Hyper 键
        Key_Help = 0x01000058, //  Help 键
        Key_Direction_L = 0x01000059, //  左 Direction 键
        Key_Direction_R = 0x01000060, //  右 Direction 键
        Key_Space = 0x20, //  Space 键
        Key_Any = Key_Space, //  Any 键
        Key_Exclam = 0x21, //  Exclam 键
        Key_QuoteDbl = 0x22, //  QuoteDbl 键
        Key_NumberSign = 0x23, //  NumberSign 键
        Key_Dollar = 0x24, //  Dollar 键
        Key_Percent = 0x25, //  Percent 键
        Key_Ampersand = 0x26, //  Ampersand 键
        Key_Apostrophe = 0x27, //  Apostrophe 键
        Key_ParenLeft = 0x28, //  ParenLeft 键
        Key_ParenRight = 0x29, //  ParenRight 键
        Key_Asterisk = 0x2a, //  Asterisk 键
        Key_Plus = 0x2b, //  Plus 键
        Key_Comma = 0x2c, //  Comma 键
        Key_Minus = 0x2d, //  Minus 键
        Key_Period = 0x2e, //  Period 键
        Key_Slash = 0x2f, //  Slash 键
        Key_0 = 0x30, //  0 键
        Key_1 = 0x31, //  1 键
        Key_2 = 0x32, //  2 键
        Key_3 = 0x33, //  3 键
        Key_4 = 0x34, //  4 键
        Key_5 = 0x35, //  5 键
        Key_6 = 0x36, //  6 键
        Key_7 = 0x37, //  7 键
        Key_8 = 0x38, //  8 键
        Key_9 = 0x39, //  9 键
        Key_Colon = 0x3a, //  Colon 键
        Key_Semicolon = 0x3b, //  Semicolon 键
        Key_Less = 0x3c, //  Less 键
        Key_Equal = 0x3d, //  Equal 键
        Key_Greater = 0x3e, //  Greater 键
        Key_Question = 0x3f, //  Question 键
        Key_At = 0x40, //  At 键
        Key_A = 0x41, //  A 键
        Key_B = 0x42, //  B 键
        Key_C = 0x43, //  C 键
        Key_D = 0x44, //  D 键
        Key_E = 0x45, //  E 键
        Key_F = 0x46, //  F 键
        Key_G = 0x47, //  G 键
        Key_H = 0x48, //  H 键
        Key_I = 0x49, //  I 键
        Key_J = 0x4a, //  J 键
        Key_K = 0x4b, //  K 键
        Key_L = 0x4c, //  L 键
        Key_M = 0x4d, //  M 键
        Key_N = 0x4e, //  N 键
        Key_O = 0x4f, //  O 键
        Key_P = 0x50, //  P 键
        Key_Q = 0x51, //  Q 键
        Key_R = 0x52, //  R 键
        Key_S = 0x53, //  S 键
        Key_T = 0x54, //  T 键
        Key_U = 0x55, //  U 键
        Key_V = 0x56, //  V 键
        Key_W = 0x57, //  W 键
        Key_X = 0x58, //  X 键
        Key_Y = 0x59, //  Y 键
        Key_Z = 0x5a, //  Z 键
        Key_BracketLeft = 0x5b, //  BracketLeft 键
        Key_Backslash = 0x5c, //  Backslash 键
        Key_BracketRight = 0x5d, //  BracketRight 键
        Key_AsciiCircum = 0x5e, //  AsciiCircum 键
        Key_Underscore = 0x5f, //  Underscore 键
        Key_QuoteLeft = 0x60, //  QuoteLeft 键
        Key_BraceLeft = 0x7b, //  BraceLeft 键
        Key_Bar = 0x7c, //  Bar 键
        Key_BraceRight = 0x7d, //  BraceRight 键
        Key_AsciiTilde = 0x7e, //  AsciiTilde 键
        Key_nobreakspace = 0x0a0, //  nobreakspace 键
        Key_exclamdown = 0x0a1, //  exclamdown 键
        Key_cent = 0x0a2, //  cent 键
        Key_sterling = 0x0a3, //  sterling 键
        Key_currency = 0x0a4, //  currency 键
        Key_yen = 0x0a5, //  yen 键
        Key_brokenbar = 0x0a6, //  brokenbar 键
        Key_section = 0x0a7, //  section 键
        Key_diaeresis = 0x0a8, //  diaeresis 键
        Key_copyright = 0x0a9, //  copyright 键
        Key_ordfeminine = 0x0aa, //  ordfeminine 键
        Key_guillemotleft = 0x0ab, //  guillemotleft 键
        Key_notsign = 0x0ac, //  notsign 键
        Key_hyphen = 0x0ad, //  hyphen 键
        Key_registered = 0x0ae, //  registered 键
        Key_macron = 0x0af, //  macron 键
        Key_degree = 0x0b0, //  degree 键
        Key_plusminus = 0x0b1, //  plusminus 键
        Key_twosuperior = 0x0b2, //  twosuperior 键
        Key_threesuperior = 0x0b3, //  threesuperior 键
        Key_acute = 0x0b4, //  acute 键
        Key_mu = 0x0b5, //  mu 键
        Key_paragraph = 0x0b6, //  paragraph 键
        Key_periodcentered = 0x0b7, //  periodcentered 键
        Key_cedilla = 0x0b8, //  cedilla 键
        Key_onesuperior = 0x0b9, //  onesuperior 键
        Key_masculine = 0x0ba, //  masculine 键
        Key_guillemotright = 0x0bb, //  guillemotright 键
        Key_onequarter = 0x0bc, //  onequarter 键
        Key_onehalf = 0x0bd, //  onehalf 键
        Key_threequarters = 0x0be, //  threequarters 键
        Key_questiondown = 0x0bf, //  questiondown 键
        Key_Agrave = 0x0c0, //  Agrave 键
        Key_Aacute = 0x0c1, //  Aacute 键
        Key_Acircumflex = 0x0c2, //  Acircumflex 键
        Key_Atilde = 0x0c3, //  Atilde 键
        Key_Adiaeresis = 0x0c4, //  Adiaeresis 键
        Key_Aring = 0x0c5, //  Aring 键
        Key_AE = 0x0c6, //  AE 键
        Key_Ccedilla = 0x0c7, //  Ccedilla 键
        Key_Egrave = 0x0c8, //  Egrave 键
        Key_Eacute = 0x0c9, //  Eacute 键

QWheelEvent：滚轮事件。

class QWheelEvent : public QInputEvent {
public:
    // 构造函数
    QWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint delta, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::Orientation orient = Qt::Vertical);
    QWheelEvent(const QPointF &pos, const QPointF &globalPos, int delta, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::Orientation orient = Qt::Vertical);
    QWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers);

    // 公共成员函数
    QPoint pos() const; // 返回事件的本地坐标位置（整数精度）
    QPoint globalPos() const; // 返回事件的屏幕坐标位置（整数精度）
    QPointF position() const; // 返回事件的本地坐标位置（浮点精度）
    QPointF globalPosition() const; // 返回事件的屏幕坐标位置（浮点精度）
    QPoint pixelDelta() const; // 返回像素级别的滚动增量
    QPoint angleDelta() const; // 返回角度级别的滚动增量
    Qt::Orientation orientation() const; // 返回滚轮的方向
    Qt::MouseButtons buttons() const; // 返回事件发生时所有按下的鼠标按钮
    int delta() const; // 返回滚动的角度增量（仅在 Qt4 兼容模式下使用）

    // 枚举类型
    enum {
        DefaultDeltasPerStep = 120 // 默认的滚动步长（角度增量）
    };
};

标签：const,QT,2024.8,void,int,bool,QString,20,Qt
From： https://blog.csdn.net/gopher9511/article/details/141341439

QT中常用类的成员(2024.8.20更新)