重学Qt——Qt常用界面组件

常用界面组件

界面组件

Widget组件：GUI程序的主要特点就是有窗口界面，界面上有各种组件可实现交互操作。

• Qt为GUI程序设计提供了丰富的界面组件，这些界面组件统称为widget组件。
• QWidget类作为界面组件和独立窗口时，拥有一些主要的属性和接口函数，这些属性和函数用于控制界面组件和窗口的各种特性。

QWidget

Qt类库中的界面组件都是以QWidget为基础构建的，QWidget类是所有可视组件的基类，提供了绘制、事件处理和布局管理等基本功能。

• 所有界面组件都是基于QWidget类构建的，它们是构成GUI应用程序的窗口界面的基本元素。这些组件可以从窗口系统接收事件并在屏幕上绘制自己。

QWidget类的基础地位

• QWidget 是Qt库中的核心类，是所有可视组件的基类。
• QWidget 提供了绘制、事件处理和布局管理等基本功能。
• 继承关系：QWidget的父类是QObject和QPaintDevice，因此它是一个多重继承的类。QObject支持元对象系统；QPaintDevice是用于绘图的类。

界面组件的特性

• 事件接收：界面组件可以从窗口系统接收鼠标事件、键盘事件和其他事件。
• 绘制功能：能在屏幕上绘制自己。

Qt Designer中的组件面板中的体现：

• 在Qt Designer进行UI可视化设计时，窗口左侧的组件面板包含了GUI设计中常用的各种界面组件。

QWidget类的主要属性:

属性名称	描述
geometry	控件的几何形状，包括位置和大小（坐标和宽高）。
size	控件的当前大小。
pos	控件的当前位置（相对于父控件或画布）。
width	控件的宽度。
height	控件的高度。
visible	控件是否可见，true表示可见，false表示隐藏。
enabled	控件是否处于启用状态，true表示启用，false表示禁用。
focusPolicy	控件的焦点策略，决定控件如何获得输入焦点。
styleSheet	应用的样式表，用于自定义控件的外观。
windowTitle	窗口的标题，用于显示在窗口标题栏中。
modality	确定控件是否为模态窗口，影响用户与其他窗口的交互。
toolTip	鼠标悬停时显示的工具提示。
icon	设置窗口或控件的图标。
layout	控件的布局管理器，定义如何在控件内排列子控件。
minimumSize	控件的最小尺寸。
maximumSize	控件的最大尺寸。

常用方法：

方法名	描述
setGeometry(int x, int y, int w, int h)	设置控件的位置和大小（x、y坐标及宽高）。
move(int x, int y)	移动控件到指定位置。
resize(int w, int h)	调整控件的大小。
show()	显示控件。
hide()	隐藏控件。
setVisible(bool visible)	设置控件是否可见。
setEnabled(bool enabled)	设置控件是否启用。
setFocus()	设置控件为当前焦点控件。
setStyleSheet(const QString &style)	应用样式表以自定义控件外观。
setToolTip(const QString &tip)	设置鼠标悬停时显示的工具提示。
setWindowTitle(const QString &title)	设置窗口标题。
setFixedSize(int w, int h)	设置控件的固定大小，禁止调整。
minimumSize()	返回控件的最小尺寸。
maximumSize()	返回控件的最大尺寸。
layout()	返回控件的布局管理器。
update()	刷新控件以重绘其内容。
close()	关闭窗口控件。

示例：

#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>

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

    QWidget *widget = new QWidget();
    widget->setWindowTitle("My Widget");
    widget->resize(400, 300);
    widget->setVisible(true);
    widget->setStyleSheet("background-color: lightblue;");
    widget->setToolTip("This is a tooltip.");

    QVBoxLayout *layout = new QVBoxLayout(widget);
    // 添加其他控件到布局...

    widget->show();
    return app.exec();
}

运行结果：

QWidget作为窗口时的属性

除了作为界面组件，QWidget也可以作为独立的窗口，其子类QMainWindow、QDialog也是常用的窗口类。当QWidget作为窗口时，它有一些与窗口相关的属性，包括：

• 窗口标题（title）。
• 窗口大小（size）。
• 窗口位置（position）。
• 是否可见（visible）等。

常见属性：

属性名称	描述
windowTitle	窗口的标题。这个属性用于设置窗口的标题栏文本。
windowIcon	窗口的图标。这个属性用于设置窗口的图标，通常显示在窗口的标题栏和任务栏上。
windowOpacity	窗口的不透明度。这个属性用于设置窗口的透明度，取值范围通常是 0（完全透明）到 1（完全不透明）。
windowFilePath	窗口关联的文件的路径。这个属性可能用于指示窗口与某个文件关联，例如当打开某个文件时显示的窗口。
windowModified	指示文件是否已被修改的标记。这个属性通常用于编辑器类应用，当用户修改文件内容时，该属性会标记为"已修改"，可能在窗口标题上显示出来。
windowModality	窗口的模式（模态或非模态）。模态窗口会阻止用户与其他窗口交互，直到该模态窗口被关闭或操作完成。非模态窗口则允许用户与其他窗口交互。
windowFlags	窗口的标志。这个属性用于设置窗口的各种行为，如是否可调整大小、是否显示边框等。可以通过组合不同的标志来定制窗口的行为和外观。

示例：

#include <QApplication>
#include <QMainWindow>
#include <QWidget>
#include <QVBoxLayout>
#include <QPushButton>

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

    QMainWindow *mainWindow = new QMainWindow();
    mainWindow->setWindowTitle("My Main Window");
    mainWindow->setGeometry(100, 100, 800, 600);
    mainWindow->setWindowIcon(QIcon("icon.png"));

    QWidget *centralWidget = new QWidget();
    QVBoxLayout *layout = new QVBoxLayout(centralWidget);
    
    QPushButton *button = new QPushButton("Click Me");
    layout->addWidget(button);

    mainWindow->setCentralWidget(centralWidget);
    mainWindow->show();

    return app.exec();
}

常用界面类组件

按钮类

按钮类组件

1. 组件面板中的Buttons分组包含了多种按钮类组件。
2. 这些按钮类组件的类继承关系详述，其中QAbstractButton是抽象类，定义按钮共有特性但不能创建实例对象。
3. QDialogButtonBox作为一个复合组件类，用于对话框中的互斥选择按钮组合。

常见普通按钮：

组件名称	特点	描述
QPushButton	用户可以通过点击按钮来执行特定功能。常用于应用程序的界面上。	一个常见的按钮控件，用于触发事件或动作。
QToolButton	通常用于工具栏或菜单中，可以显示一个弹出菜单，提供多个命令或选项。	带有小箭头的按钮控件，通常用于显示工具菜单或执行特定任务。
QRadioButton	用户可以在多个单选按钮中选择一个。多个单选按钮可以组成一个单选按钮组，以便只能选择其中的一个选项。	单选按钮控件，用于在一组选项中选择一个选项。
QCheckBox	用户可以通过点击复选框来选择或取消选择某个选项。常用于表示开关状态或选项设置。	复选框控件，用于表示一个二选一的状态（开/关）。

按钮属性接口

QAbstractButton是一个抽象类，无法直接用于创建实际的按钮对象，但它作为多个按钮类的基类，定义了一组共享的属性和接口函数。

这些属性和接口函数被继承，使得基于QAbstractButton的子类能够共享这些特性和功能。

1、属性

QAbstractButton定义了一些通用的属性，这些属性可以被所有继承自QAbstractButton的按钮类使用，包括：

• checked：确定按钮当前是否被选中（例如在复选框和单选按钮中）。
• enabled：指示按钮是否可用。
• text：按钮上显示的文字。
• icon：按钮的图标。
• toolTip：鼠标悬停时显示的提示信息。

2、接口函数

QAbstractButton提供了许多虚拟函数和常用的接口，具体按钮类可以重写这些接口来实现特定行为，包括：

• click()：模拟用户点击按钮。
• toggle()：切换按钮的选中状态，适用于可以选中的按钮（如复选框）。
• setChecked(bool)：设置按钮的选中状态。
• isChecked()：返回按钮是否被选中。
• setText(const QString &)：设置按钮显示的文本。
• setIcon(const QIcon &)：设置按钮的图标。

3、信号

QAbstractButton还提供了多个信号，这些信号可以用于按钮状态变化时的通知，包括：

• clicked()：当按钮被点击时发出该信号。
• pressed()：当按钮被按下时发出该信号。
• released()：当按钮被释放时发出该信号。
• toggled(bool)：当按钮的选中状态改变时发出该信号（适用于切换按钮）。

输入类

输入类组件，这是用于在界面上获取输入的一些组件，例如获取输入的文字、数字、日期和时间等数据。

组件名称	描述
QComboBox	一个下拉列表框，允许用户从预定义的选项列表中选择一个选项。它通常用于选择列表中的值。
QFontComboBox	一个特殊的下拉列表框，专门用于选择字体。它提供了系统中可用的所有字体供用户选择。
QLineEdit	一个简单的单行文本输入框，用于获取用户的输入。它可以用来输入文本字符串。
QTextEdit	一个多行文本编辑器，允许用户输入和编辑富文本（包含格式和样式）。适用于需要复杂文本编辑的场景。
QPlainTextEdit	与QTextEdit类似，但QPlainTextEdit只支持纯文本编辑，不包含任何格式或样式。
QSpinBox	一个用于输入整数值的控件。它提供了一个带箭头的输入框，用户可以通过点击箭头来增加或减少值。
QDoubleSpinBox	与QSpinBox类似，但QDoubleSpinBox用于输入双精度浮点数值。

滑动型数值输入组件

组件名称	描述
QSlider	QSlider是Qt框架中的一个组件，用于创建一个滑块控件。它允许用户通过滑动条来选择或调整一个值范围。常用于需要连续调整值的场景，如音量控制等。
QDial	QDial是Qt框架中的另一个组件，提供了一个类似于旋钮的界面。用户可以通过旋转它来选择或调整一个值。适用于需要旋转操作的界面设计。
QScrollBar	QScrollBar是Qt框架中的一个基本滚动条组件。它允许用户通过滚动条来滚动内容，常用于需要展示大量内容但屏幕空间有限的场景。
QKeySequenceEdit	QKeySequenceEdit是一个用于编辑和管理序列的组件。它允许用户输入和编辑一系列字符或符号序列，常用于文本编辑或序列编辑相关的应用程序中。

显示类

这些组件用于显示字符串、数值、文本等内容。

显示类组件一般只能显示内容，而不能编辑、输入内容。

组件名称	描述
QLabel	一个用于显示文本的简单控件。它通常用于显示静态文本或标签。
QTextBrowser	一个富文本编辑器控件，允许用户浏览和编辑带有HTML格式的文本。它提供了基本的文本编辑功能，如复制、粘贴和查找等。
QGraphicsView	一个用于展示图形项目的视图控件。它通常与QGraphicsScene一起使用，用于展示复杂的图形和动画。
QCalendarWidget	一个日历控件，提供了一个日历界面供用户选择和导航日期。它可以用于日期选择、日程安排等应用场景。
QLCDNumber	一个用于显示液晶数字显示的控件。它可以用于显示数字和其他简单的文本信息，具有液晶显示器的外观。
QProgressBar	一个进度条控件，用于显示任务进度。它通常用于表示正在进行的任务或操作的进度。
QOpenGLWidget	一个用于OpenGL渲染的控件。它提供了一个在Qt应用程序中嵌入OpenGL内容的方式，可以用于创建复杂的图形和动画。
QQuickWidget	一个用于加载和运行基于QML（Qt Modeling Language）应用程序的控件。它允许在Qt应用程序中嵌入QML界面，提供丰富的交互式体验。

容器类

这是一些容器类组件。在容器类组件上可以放置其他组件，并可以使用布局管理容器内的子组件。

容器类组件对应的类及其功能

组件名称	描述
QGroupBox	用于创建一个分组框，通常用于将相关控件组合在一起并提供一个标题。常用于组织表单和界面布局。
QScrollArea	提供滚动区域的功能，允许用户滚动查看超出其可见区域的内容。常用于包含大量数据的控件或需要滚动功能的界面。
QToolBox	提供选项卡式的界面布局，每个选项卡可以包含不同的控件和内容。常用于展示多个相关界面或数据集合。
QTabWidget	与QToolBox类似，提供基于标签页的界面布局，允许用户在多个页面之间切换。常用于需要展示多个独立界面的应用程序。
QStackedWidget	提供堆叠式界面布局，只有一个页面可见，通过切换可以显示不同的页面。常用于需要展示多个页面的应用程序，但一次只显示一个页面的场景。
QFrame	用于创建一个框架，可以包含标题和其他控件。常用于组织界面元素并提供一致的外观。
QMdiArea	提供多文档界面（MDI）的功能，允许在一个主窗口中打开多个子窗口。常用于需要同时处理多个窗口的应用程序。
QDockWidget	提供可停靠的窗口小部件，通常用于创建带有标题和边框的面板，可以停靠在主窗口的边缘或浮动作为独立窗口。
QAxWidget	用于嵌入ActiveX控件的Qt封装类，允许在Qt应用程序中直接使用Windows平台的ActiveX控件。

Item组件

Item 组件主要指的是在基于 Qt Quick 的应用程序中使用的可视元素。这些元素用于构建动态和富有表现力的用户界面

模型/视图结构的基础概念

• Qt的模型/视图结构用于将数据存储和数据展示分离。
• 每一种视图组件需要相应的一种模型用于存储数据。

Item Views组件

继承关系：

• Item Views组件的类继承自QAbstractItemView。
• QAbstractItemView的父类是QAbstractScrollArea。

功能：

• Item Views组件用于实现模型/视图结构。
• 它们需要通过模型提供的数据进行显示。

Item Widgets组件

定义：

• Item Widgets组件类是相应Item Views组件类的子类。

功能：

• 它们直接使用项(item)来存储数据。
• 被称为相应视图类的便利类（convenience class）。

示例：

• QListWidget是QListView的便利类。
• QTreeWidget是QTreeView的便利类。

布局管理

布局管理

• 布局管理的重要性：在UI设计中，布局管理是关键的一环，它决定了界面元素的排列方式和位置。
• UI文件与MOC编译：UI文件经过Qt的MOC（元对象编译器）编译后，可视化设计的布局管理会被转换为C++代码。
• 布局管理可以完成两件事：1、自动调整控件的位置，包括控件之间的间距、对齐等；2、当用户调整窗口大小时，位于布局管理器内的控件也会随之调整大小，从而保持整个界面的美观。

布局管理类

布局管理相关的类

主要布局管理类：Qt框架提供了多种布局管理类，如QHBoxLayout、QVBoxLayout、GridLayout等，这些类在Qt Designer中有对应的可视化组件。

QLayout

QLayout类是从Q0bject和QLayoutItem类继承而来的。即QLayout类具有Q0bject类的属性和方法，同时也具有QLayoutItem类的特性。

• QLayout类不是从QWidget继承而来的，所以布局管理类对象并不是窗口上可见的界面组件。
• 主要用于管理和组织窗口中的其他控件，确保控件在窗口中的位置和大小符合设计要求。

从QLayout继承而来的几个常用布局管理类：

布局组件	描述
QVBoxLayout	此布局将组件按照垂直方向堆叠，每个组件从上到下排列。通常用于构建表单等场景。
QHBoxLayout	此布局将组件按照水平方向堆叠，每个组件从左到右排列。常用于创建工具条等场景。
QGridLayout	提供基于行和列的二维网格结构来排列组件。用户可以通过定义行列和间距来调整组件的位置。常用于需要复杂布局的界面设计。
QFormLayout	用于创建表单界面，其中标签和字段组件自动对齐。它通常用于创建用户界面中的表单输入部分。
QStackedLayout	此布局允许用户在同一位置堆叠多个组件，但一次只显示一个组件。通常用于实现标签页切换等功能。

Qt 共提供了 5 种布局管理器，每种布局管理器对应一个类，它们与QLayout的继承关系：

QLayoutItem

QLayoutItem类没有父类，它是QLayout布局管理中的基础项，用于管理布局中的各个元素。

• 布局管理的基础，封装了在布局中管理的每一个控件或占位符的属性。通过 QLayoutItem，布局管理器可以跟踪各个子控件的尺寸、位置和可见性

示例：

#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>
#include <QPushButton>
#include <QLayoutItem>
#include <QLabel>
#include <iostream>

class LayoutExample : public QWidget {
public:
    LayoutExample() {
        QVBoxLayout *layout = new QVBoxLayout(this);

        QLabel *label = new QLabel("Click the button to list layout items:");
        layout->addWidget(label);

        QPushButton *button = new QPushButton("List Layout Items");
        layout->addWidget(button);

        connect(button, &QPushButton::clicked, this, &LayoutExample::listLayoutItems);
    }

private:
    void listLayoutItems() {
        QLayout *layout = this->layout();
        for (int i = 0; i < layout->count(); ++i) {
            QLayoutItem *item = layout->itemAt(i);
            if (item) {
                QWidget *widget = item->widget();
                if (widget) {
                    std::cout << "Item " << i << ": " << widget->objectName().toStdString() << std::endl;
                }
            }
        }
    }
};

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

    LayoutExample example;
    example.setWindowTitle("QLayoutItem Example");
    example.resize(300, 200);
    example.show();

    return app.exec();
}

运行结果：

常见的布局类

常见布局类属性：

属性名称	描述
类型（Type）	定义了布局的总体类型，如线性布局、网格布局等。
方向（Direction）	指定布局中子元素的排列方向，如水平或垂直。
边距（Margins）	定义布局边缘与子元素之间的间距。
填充（Padding）	定义布局内部的空间，即子元素与布局边界之间的间距。
大小（Size）和大小策略（Size Policy）	控制布局的大小及其在容器中的比例。可以设置固定大小或根据内容进行自动调整。
间距（Spacing）	在网格布局中，指定行和列之间的间距。
边距、对齐和偏移（Edges, Alignment, and Offsets）	用于控制子元素在布局中的位置和对齐方式。
可视区域（Visible Area）	定义布局的可见区域范围。
子元素（Children Elements）	表示包含在布局中的子元素或组件。
层次结构（Hierarchy）	在复杂布局中，描述各个子元素之间的层次结构和关系。

QVBoxLayout

用于垂直排列子控件的布局管理器。它将添加到其中的控件从上到下排列，并自动调整它们的大小和位置，以适应父容器的空间。

常用方法：

成员方法	功 能
void QBoxLayout::addWidget(QWidget *widget, int stretch = 0, Qt::Alignment alignment = Qt::Alignment())	向布局管理器中添加指定的 widget 控件。默认情况下，stretch 拉伸系数为 0，表示 widget 控件的尺寸为默认值；alignment 是一个枚举类型参数，默认值也是 0，表示该控件会填满占用的整个空间。
void QBoxLayout::addStretch(int stretch = 0)	添加一个空白行，整个窗口中除了控件占用的区域外，其它区域可以由多个（≥0）空白行分摊，分摊比例取余于各个空白行设置的 stretch 参数的值。strech 参数的默认值为 0，表示当窗口很小时，空白行可以不占据窗口空间。当窗口中包含多个 strech 值为 0 的空白行时，它们会平分窗口中的空白区域。
void QBoxLayout::addSpacing(int size)	添加一个 size 大小的固定间距。
void QLayout::setMargin(int margin)	设置布局管理器中所有控件的外边距，上、下、左、右外边距的大小都为 margin。默认情况下，所有方向的外边距为 11 px。
void QLayout::setContentsMargins(int left, int top, int right, int bottom)	设置布局管理器中所有控件的外边距，和 setMargin() 的区别是，此方法可以自定义上、下、左、右外边距的值。
void QBoxLayout::setDirection(Direction direction)	设置布局管理器中控件的布局方向，Direction 是一个枚举类型，对于 QVBoxLayout 布局管理器，direction 参数的值通常选择 QBoxLayout::TopToBottom（从上到下依次摆放）或者 QBoxLayout::BottomToTop（从下到上依次摆放）。
bool QBoxLayout::setStretchFactor(QWidget *widget, int stretch)	设置布局管理器中某个控件的拉伸系数。
bool QBoxLayout::setStretchFactor(QLayout *layout, int stretch)	布局管理器内部可以再放置一个布局管理器，该方法用来设置内部某个布局管理器的拉伸系数。

示例：如何创建一个垂直布局，并在其中添加一些控件。

#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>
#include <QPushButton>
#include <QLabel>
#include <QLineEdit>

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

    // 创建主窗口
    QWidget window;
    window.setWindowTitle("QVBoxLayout Example");

    // 创建 QVBoxLayout
    QVBoxLayout *layout = new QVBoxLayout();

    // 创建控件
    QLabel *label = new QLabel("Enter your name:");
    QLineEdit *lineEdit = new QLineEdit();
    QPushButton *button = new QPushButton("Submit");
    
    // 添加控件到布局中
    layout->addWidget(label);
    layout->addWidget(lineEdit);
    layout->addWidget(button);

    // 设置布局到主窗口
    window.setLayout(layout);
    window.resize(300, 150);
    window.show();

    return app.exec();
}

代码说明

1. 创建窗口：使用 QWidget 创建主窗口。
2. 创建布局：实例化 QVBoxLayout。
3. 添加控件：在布局中添加 QLabel、QLineEdit 和 QPushButton。
4. 设置布局：将布局设置为窗口的布局，使控件自动管理其位置和大小。

运行结果：

示例2：

#include <QApplication>
#include <QWidget>
#include <QLabel>
#include <QVBoxLayout>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //创建主窗口
    QWidget widget;
    widget.setWindowTitle("QVBoxLayout垂直布局");
    //创建垂直布局管理器
    QVBoxLayout *layout=new QVBoxLayout;
    //设置布局管理器中所有控件从下往上依次排列
    layout->setDirection(QBoxLayout::BottomToTop);

    //连续创建 3 个文本框，并设置它们的背景和字体大小
    QLabel lab1("Label1");
    lab1.setStyleSheet("QLabel{background:#dddddd;font:20px;}");
    lab1.setAlignment(Qt::AlignCenter);
    QLabel lab2("Label2");
    lab2.setStyleSheet("QLabel{background:#cccccc;font:20px;}");
    lab2.setAlignment(Qt::AlignCenter);
    QLabel lab3("Label3");
    lab3.setStyleSheet("QLabel{background:#ffffff;font:20px;}");
    lab3.setAlignment(Qt::AlignCenter);

    //将 3 个文本框和 2 个空白行添加到管理器中，它们的伸缩系数比是 2:1:2:3:3
    layout->addStretch(2);
    layout->addWidget(&lab1,1);
    layout->addWidget(&lab2,2);
    layout->addWidget(&lab3,3);
    layout->addStretch(3);

    //将布局管理器添加到 widget 窗口中
    widget.setLayout(layout);
    widget.show();
    return a.exec();
}

运行结果：

代码解析：

• 通过调用 setDirection() 方法，将添加到 QVBoxLayout 管理器中的所有控件（包括空白行）按照从下到上的顺序依次摆放。比如，由于 lab1 文本框是第二个添加到管理器中的，因此在最终显示的界面中，lab1 位于倒数第二的位置。
• 通过调用 addStrech() 方法，向管理器中先后添加了两个空白行，它们的伸缩系数分别为 2 和 3，因此 widget 窗口中的空白区域会平均分为 5 份，一个空白行占 3 份，另一个占 2 份。
• 通过调用 addWidget() 方法，向管理器中先后添加了 3 个文本框，它们的拉伸系数比为 1:2:3，所以当我们拉伸 widget 窗口时，三个文本框的大小（宽度）呈现 1:2:3 的关系。
• 通过调用 setLayout() 方法，成功地将 layout 布局管理器添加到了 widget 窗口中。也可以在创建 layout 对象时指定 widget 作为它的父窗口，两种方式是完全等价的。

QHBoxLayout

用于水平排列子控件的布局管理器。它将添加到其中的控件从左到右排列，并 dynamically 调整它们的大小和位置，确保它们自适应父容器的空间。

常用方法：

方法	描述
addWidget(QWidget *widget, int stretch = 0, Qt::Alignment alignment = 0)	添加一个小部件到布局中，可以设置拉伸因子和对齐方式。
addLayout(QLayout *layout, int stretch = 0)	将另一个布局添加到此布局中，允许设置拉伸因子。
addSpacing(int space)	在布局中添加固定的空白间距。
addStretch(int stretch = 0)	在布局中添加可伸缩的空白空间，stretch决定伸展比例。
insertWidget(int index, QWidget *widget, int stretch = 0, Qt::Alignment alignment = 0)	在指定位置插入一个小部件。
insertLayout(int index, QLayout *layout, int stretch = 0)	在指定位置插入另一个布局。
setSpacing(int spacing)	设置布局中小部件之间的间距。
setContentsMargins(int left, int top, int right, int bottom)	设置布局的内容边距。
setAlignment(QWidget *widget, Qt::Alignment alignment)	设置指定小部件的对齐方式。
count()	返回布局中小部件和布局数目的总计。
itemAt(int index)	返回给定索引位置的布局项。
removeWidget(QWidget *widget)	从布局中移除指定的小部件。
removeItem(QLayoutItem *item)	从布局中移除指定的布局项。

示例：如何创建一个水平布局，并在其中添加一些控件。

#include <QApplication>
#include <QWidget>
#include <QHBoxLayout>
#include <QPushButton>
#include <QLabel>
#include <QLineEdit>
#include <QSpacerItem>

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

    // 创建主窗口
    QWidget window;
    window.setWindowTitle("QHBoxLayout Example");

    // 创建 QHBoxLayout
    QHBoxLayout *layout = new QHBoxLayout();

    // 创建控件
    QLabel *label = new QLabel("Name:");
    QLineEdit *lineEdit = new QLineEdit();
    QPushButton *button = new QPushButton("Submit");

    // 添加控件到布局中
    layout->addWidget(label);
    layout->addWidget(lineEdit);
    layout->addWidget(button);

    // 添加空间项，确保按钮靠右
    layout->addSpacerItem(new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum));

    // 设置布局到主窗口
    window.setLayout(layout);
    window.resize(400, 100);
    window.show();

    return app.exec();
}

代码说明

1. 创建窗口：使用 QWidget 创建主窗口。
2. 创建布局：实例化 QHBoxLayout。
3. 添加控件：把 QLabel、QLineEdit 和 QPushButton 添加到布局中。
4. 添加空间项：QSpacerItem 用于在按钮右侧添加可扩展的空白区域，使按钮靠右对齐。
5. 设置布局：将布局设置为窗口的布局，使控件自动管理其位置和大小。

运行结果：

示例2：

#include <QApplication>
#include <QWidget>
#include <QLabel>
#include <QHBoxLayout>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //创建主窗口
    QWidget widget;
    widget.setWindowTitle("QHBoxLayout水平布局");
    //创建水平布局管理器
    QHBoxLayout *layout=new QHBoxLayout;
    //设置布局管理器中所有控件的布局方向为从右往左依次排列
    layout->setDirection(QBoxLayout::RightToLeft);

    //连续创建 3 个文本框，并设置它们的背景和字体大小
    QLabel lab1("Label1");
    lab1.setStyleSheet("QLabel{background:#dddddd;font:20px;}");
    lab1.setAlignment(Qt::AlignCenter);
    QLabel lab2("Label2");
    lab2.setStyleSheet("QLabel{background:#cccccc;font:20px;}");
    lab2.setAlignment(Qt::AlignCenter);
    QLabel lab3("Label3");
    lab3.setStyleSheet("QLabel{background:#ffffff;font:20px;}");
    lab3.setAlignment(Qt::AlignCenter);

    //将 3 个文本框和 2 个空白列添加到管理器中，它们的拉伸系数比是 2:1:2:3:3
    layout->addStretch(2);
    layout->addWidget(&lab1,1);
    layout->addWidget(&lab2,2);
    layout->addWidget(&lab3,3);
    layout->addStretch(3);

    //将布局管理器添加到 widget 窗口中
    widget.setLayout(layout);
    widget.show();
    return a.exec();
}

运行结果：

QGridLayout

Qt 中的一种强大的布局管理器，用于在网格中组织控件。不同于线性布局，QGridLayout 允许你在一个二维网格中自由放置控件，使得界面的布局更加灵活和复杂。

• 可以随意指定 QGridLayout 的行数和列数，各个控件可以随意摆放，必要时某些位置可以空着不用。

常用方法：

成员方法	功 能
int QGridLayout::rowCount() const	获取网格的行数。
int QGridLayout::columnCount() const	获取网格的列数。
void QGridLayout::addWidget(QWidget *widget, int row, int column, Qt::Alignment alignment = Qt::Alignment())	将 widget 控件添加到网格中的 (row,column) 位置处，并且可以自定义该控件的对齐方式。
void QGridLayout::addWidget(QWidget *widget, int fromRow, int fromColumn, int rowSpan, int columnSpan, Qt::Alignment alignment = Qt::Alignment())	将 widget 控件从 (fromRow, fromColumn) 位置开始，跨 rowSpan 行和 ColumnSpan 列添加到网格中，并且可以自定义该控件的对齐方式。
void QGridLayout::addLayout(QLayout *layout, int row, int column, Qt::Alignment alignment = Qt::Alignment())	向网格中的 (row, column) 位置处添加 layout 布局管理器。
void QGridLayout::addLayout(QLayout *layout, int row, int column, int rowSpan, int columnSpan, Qt::Alignment alignment = Qt::Alignment())	将 layout 布局管理器从 (row, column) 位置开始，跨 rowSpan 行和 ColumnSpan 列添加到网格中，并且可以自定义该布局控件的对齐方式。
void QGridLayout::setColumnStretch(int column, int stretch)	给指定的第 column 列设置伸缩系数。
void QGridLayout::setRowStretch(int row, int stretch)	给指定的第 row 行设置伸缩系数。
void QGridLayout::setColumnMinimumWidth(int column, int minSize)	设置第 column 列的最小宽度。
void QGridLayout::setRowMinimumHeight(int row, int minSize)	设置第 row 行的最小宽度。

示例：如何创建一个网格布局，并在其中添加一些控件。

#include <QApplication>
#include <QWidget>
#include <QGridLayout>
#include <QPushButton>
#include <QLabel>
#include <QLineEdit>

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

    // 创建主窗口
    QWidget window;
    window.setWindowTitle("QGridLayout Example");

    // 创建 QGridLayout
    QGridLayout *layout = new QGridLayout();

    // 创建控件
    QLabel *label1 = new QLabel("Name:");
    QLineEdit *lineEdit1 = new QLineEdit();
    QLabel *label2 = new QLabel("Age:");
    QLineEdit *lineEdit2 = new QLineEdit();
    QPushButton *submitButton = new QPushButton("Submit");

    // 添加控件到布局中
    layout->addWidget(label1, 0, 0); // 第1行，第1列
    layout->addWidget(lineEdit1, 0, 1); // 第1行，第2列
    layout->addWidget(label2, 1, 0); // 第2行，第1列
    layout->addWidget(lineEdit2, 1, 1); // 第2行，第2列
    layout->addWidget(submitButton, 2, 0, 1, 2); // 第3行，第1列，占两列

    // 设置布局到主窗口
    window.setLayout(layout);
    window.resize(300, 150);
    window.show();

    return app.exec();
}

代码说明

1. 创建窗口：使用 QWidget 创建主窗口。
2. 创建布局：实例化 QGridLayout。
3. 添加控件：将 QLabel、QLineEdit 和 QPushButton 添加到指定的行和列中。layout->addWidget(widget, row, column) 用于指定控件放置的位置。layout->addWidget(submitButton, 2, 0, 1, 2) 将提交按钮放置在第3行第1列，并占用两列。
4. 设置布局：将布局设置为窗口的布局，使控件自动管理其位置和大小。

运行结果：

示例2：

#include <QApplication>
#include <QWidget>
#include <QLabel>
#include <QGridLayout>
#include <QPushButton>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //创建主窗口
    QWidget widget;
    widget.setWindowTitle("QGridLayout网格布局");
    //创建 4 个按钮和 1 个文本框
    QPushButton *but1 = new QPushButton("but1");
    QPushButton *but2 = new QPushButton("but2");
    QLabel *lab3 = new QLabel("lab");
    lab3->setStyleSheet("QLabel{background:#dddddd;font:20px;}");
    lab3->setAlignment(Qt::AlignCenter);
    QPushButton *but3 = new QPushButton("but3");
    QPushButton *but4 = new QPushButton("but4");
    //创建网格布局控件
    QGridLayout *layout = new QGridLayout;
    //向 layout 中添加控件，并指定各个控件的位置
    layout->addWidget(but1, 0, 0);
    layout->addWidget(but2, 0, 2);
    layout->addWidget(lab3, 1, 0, 3, 3);
    layout->addWidget(but3, 4, 0);
    layout->addWidget(but4, 4, 2);
    //将 layout 添加到 widget 窗口中
    widget.setLayout(layout);
    widget.show();
    return a.exec();
}

运行结果：

QFormLayout

Qt 中的一种专门用于创建表单布局的布局管理器。它通常用于显示标签和对应的输入框，方便用户填写数据。QFormLayout 会自动将标签放在左侧，输入控件放在右侧，适合用于简洁的表单设计。

常用方法：

成员方法	功 能
void QFormLayout::addRow(QWidget *label, QWidget *field)	将指定的 field 控件和存储标签的 label 控件添加到表单控件中的末尾。
void QFormLayout::addRow(const QString &labelText, QWidget *field)	将指定的 field 控件和 labelText 标签添加到表单控件的末尾。
void QFormLayout::insertRow(int row, const QString &labelText, QWidget *field)	将指定的 field 控件和 labelText 标签插入到表单控件中指定行的位置。
void QFormLayout::removeRow(int row)	删除表单控件中的指定行。
void QFormLayout::removeRow(QWidget *widget)	删除表单控件中 widget 控件所在的行。
void setRowWrapPolicy(RowWrapPolicy policy)	设置标签的显示格式，默认标签位于控件的左侧。 RowWrapPolicy 是 QFormLayout 中定义的枚举类型，该类型包含 3 个值： QFormLayout::DontWrapRows：标签始终在输入框的左侧； QFormLayout::WrapLongRows：根据输入框的尺寸，标签可能位于输入框的左侧，也可能位于上方； QFormLayout::WrapAllRows：标签始终在输入框的上方；
void QFormLayout::setSpacing(int spacing)	将行间距和列间距设置为 spacing。

示例：如何创建一个表单布局

#include <QApplication>
#include <QWidget>
#include <QFormLayout>
#include <QLineEdit>
#include <QPushButton>
#include <QLabel>

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

    // 创建主窗口
    QWidget window;
    window.setWindowTitle("QFormLayout Example");

    // 创建 QFormLayout
    QFormLayout *layout = new QFormLayout();

    // 创建控件
    QLineEdit *nameEdit = new QLineEdit();
    QLineEdit *ageEdit = new QLineEdit();
    QPushButton *submitButton = new QPushButton("Submit");

    // 添加控件到布局中
    layout->addRow("Name:", nameEdit);
    layout->addRow("Age:", ageEdit);
    layout->addRow(submitButton); // 可以直接添加按钮行

    // 设置布局到主窗口
    window.setLayout(layout);
    window.resize(300, 150);
    window.show();

    return app.exec();
}

代码说明：

1. 创建窗口：使用 QWidget 创建主窗口。
2. 创建布局：实例化 QFormLayout。
3. 添加控件：使用 addRow() 方法添加标签和对应的控件。第一个参数为标签，第二个参数为控件。可以添加没有标签的控件，如按钮，直接通过 addRow(submitButton) 来添加。
4. 设置布局：将布局设置为窗口的布局，使控件自动管理其位置和大小。

运行结果：

示例2：

#include <QApplication>
#include <QWidget>
#include <QLineEdit>
#include <QFormLayout>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //创建主窗口
    QWidget widget;
    widget.setWindowTitle("QFormLayout表单布局");
    //创建 4 个按钮和 1 个文本框
    QFormLayout* layout = new QFormLayout();
    //设置表单中的标签都位于控件的上方
    layout->setRowWrapPolicy(QFormLayout::WrapAllRows);
    
    //添加 3 行输入框和标签
    layout->addRow("Name:",new QLineEdit());
    layout->addRow("Email:",new QLineEdit());
    layout->addRow("Adress:",new QLineEdit());
    //设置行间距和列间距为 10
    layout->setSpacing(10);
    //将 layout 表单添加到 widget 窗口中
    widget.setLayout(layout);
    widget.show();
    return a.exec();
}

QStackedLayout

Qt 中的一种布局管理器，用于在一个位置堆叠多个控件，只有一个控件在任何时刻可见。这种布局非常适合用于标签页、向导界面或动态内容切换的场景。

常用方法：

方法	功 能
int QStackedLayout::addWidget(QWidget *widget)	将 widget 控件添加到 QStackedLayout 控件中。
int QStackedLayout::insertWidget(int index, QWidget *widget)	将 widget 控件插入到 QStackedLayout 控件指定的位置处。

信号：

信号函数	功 能
void QStackedLayout::currentChanged(int index)	切换当前显示的控件时，会触发此信号，index 为显示的新控件的索引。
void QStackedLayout::widgetRemoved(int index)	移除某个控件时，会触发此信号，index 为被移除控件的索引。

槽函数：

槽函数	功 能
void setCurrentIndex(int index)	将第 index 个控件作为要显示的控件。
void QStackedLayout::setCurrentWidget(QWidget *widget)	设置 widget 作为当前要实现的控件。注意，必须保证 widget 存储在 QStackedLayout 控件中。

示例：如何创建一个堆叠布局，以及如何在两个页面之间切换。

#include <QApplication>
#include <QWidget>
#include <QStackedLayout>
#include <QPushButton>
#include <QLabel>
#include <QVBoxLayout>

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

    // 创建主窗口
    QWidget window;
    window.setWindowTitle("QStackedLayout Example");

    // 创建 QStackedLayout
    QStackedLayout *stackedLayout = new QStackedLayout();

    // 创建各个页面
    QWidget *page1 = new QWidget();
    QVBoxLayout *page1Layout = new QVBoxLayout();
    page1Layout->addWidget(new QLabel("This is Page 1"));
    QPushButton *toPage2Button = new QPushButton("Go to Page 2");
    page1Layout->addWidget(toPage2Button);
    page1->setLayout(page1Layout);

    QWidget *page2 = new QWidget();
    QVBoxLayout *page2Layout = new QVBoxLayout();
    page2Layout->addWidget(new QLabel("This is Page 2"));
    QPushButton *toPage1Button = new QPushButton("Go to Page 1");
    page2Layout->addWidget(toPage1Button);
    page2->setLayout(page2Layout);

    // 将页面添加到堆叠布局中
    stackedLayout->addWidget(page1);
    stackedLayout->addWidget(page2);

    // 连接按钮点击信号以切换页面
    QObject::connect(toPage2Button, &QPushButton::clicked, [=]() {
        stackedLayout->setCurrentIndex(1); // 切换到 Page 2
    });
    QObject::connect(toPage1Button, &QPushButton::clicked, [=]() {
        stackedLayout->setCurrentIndex(0); // 切换到 Page 1
    });

    // 设置布局到主窗口
    window.setLayout(stackedLayout);
    window.resize(300, 150);
    window.show();

    return app.exec();
}

代码说明

1. 创建窗口：使用 QWidget 创建主窗口。
2. 创建布局：实例化 QStackedLayout。
3. 创建页面：创建两个子窗口（page1 和 page2），每个窗口使用垂直布局添加标签和按钮。
4. 添加页面：将子窗口添加到堆叠布局中。
5. 信号连接：连接按钮的点击信号，以切换堆叠布局中的当前页面：setCurrentIndex(1) 切换到第二个页面。setCurrentIndex(0) 切换回第一个页面。
6. 设置布局：将堆叠布局设置为窗口的布局，自动管理控件的显示。

运行结果：

示例2：

#include <QApplication>
#include <QWidget>
#include <QPushButton>
#include <QLabel>
#include <QLineEdit>
#include <QStackedLayout>
#include <QListWidget>
#include <QHBoxLayout>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //创建主窗口
    QWidget widget;
    widget.setWindowTitle("QStackedLayout分组布局");
    widget.resize(600,400);
    //向主窗口中添加一个水平布局控件
    QHBoxLayout *layout=new QHBoxLayout;

    //创建一个列表
    QListWidget listWidget(&widget);
    listWidget.setMinimumWidth(150);
    listWidget.setFont(QFont("宋体",14));
    listWidget.addItem("QPushButton");
    listWidget.addItem("QLabel");
    listWidget.addItem("QLineEdit");

    //新建 3 个窗口，分别放置文本框、按钮和单行输入框
    QWidget widget1;
    widget1.setMinimumSize(400,400);
    QPushButton but1("这是一个按钮",&widget1);

    QWidget widget2;
    widget2.setMinimumSize(400,400);
    QLabel lab1("这是一个文本框",&widget2);

    QWidget widget3;
    widget3.setMinimumSize(400,400);
    QLineEdit edit("这是一个单行输入框",&widget3);

    //创建一个分组布局，将 3 个窗口添加到分组控件中
    QStackedLayout *stackedLayout = new QStackedLayout;
    stackedLayout->addWidget(&widget1);
    stackedLayout->addWidget(&widget2);
    stackedLayout->addWidget(&widget3);

    //layout 第一列添加 QListWidget 控件，第二列添加分组布局控件，设置它们的伸缩系数比为 1:4
    layout->addWidget(&listWidget,1);
    layout->addLayout(stackedLayout,4);

    //将 layout 水平布局控件添加到 widget 窗口中
    widget.setLayout(layout);
    widget.show();

    //连接信号和槽，实现当点击列表中的某一项，切换分组布局管理器显示的控件
    QObject::connect(&listWidget,&QListWidget::currentRowChanged,stackedLayout,&QStackedLayout::setCurrentIndex);
    return a.exec();
}

运行结果：

QSplitter

分割条

QSplitter用于创建可调整大小的窗口，允许用户通过拖动分割条来改变窗口部分的大小。

• 用于将窗口分割成多个可调整大小的部分。实现水平或垂直分割，一般用在两个可以自由改变大小的组件之间进行分割
• 允许用户通过拖动分隔条来改变各个部分的大小，非常适合用于需要同时显示多个控件或视图的场景，例如文本编辑器、文件管理器等。

常用方法：

方法	描述
addWidget(QWidget *widget)	将小部件添加到分割器中，并在其中创建可调节的分隔线。
setSizes(const QVector &sizes)	设置各个小部件的初始大小。
sizes()	返回一个包含各个小部件当前大小的 QVector。
handle(int index)	返回指定索引的分隔条的指针。
setOrientation(Qt::Orientation orientation)	设置分隔器的方向（水平或垂直）。
orientation()	返回当前分隔器的方向。
setStretchFactor(int index, int stretch)	设置小部件的伸缩因子，影响分隔器调整大小时的比例。
stretchFactor(int index)	返回指定小部件的伸缩因子。
setCollapsible(int index, bool collapsible)	设置指定小部件是否可折叠。
isVertical()	返回分隔器是否为垂直方向。
setSizes(int size1, int size2)	设置两个小部件的大小（适用于两个小部件的情况）。

示例：如何创建一个包含两个可调整大小的文本编辑框的窗口。

#include <QApplication>
#include <QWidget>
#include <QSplitter>
#include <QTextEdit>
#include <QVBoxLayout>

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

    // 创建主窗口
    QWidget window;
    window.setWindowTitle("QSplitter Example");

    // 创建 QSplitter
    QSplitter *splitter = new QSplitter(Qt::Horizontal);

    // 创建两个 QTextEdit
    QTextEdit *textEdit1 = new QTextEdit();
    textEdit1->setPlainText("Text Edit 1");

    QTextEdit *textEdit2 = new QTextEdit();
    textEdit2->setPlainText("Text Edit 2");

    // 将 QTextEdit 添加到 QSplitter
    splitter->addWidget(textEdit1);
    splitter->addWidget(textEdit2);

    // 设置主布局
    QVBoxLayout *layout = new QVBoxLayout();
    layout->addWidget(splitter);
    window.setLayout(layout);

    // 设置窗口大小
    window.resize(400, 300);
    window.show();

    return app.exec();
}

代码说明：

1. 创建窗口：使用 QWidget 创建主窗口。
2. 创建 QSplitter：实例化 QSplitter，设置方向为水平（Qt::Horizontal）。也可以使用 Qt::Vertical 进行垂直布局。
3. 创建控件：创建两个 QTextEdit，用于输入文本。
4. 添加控件到 QSplitter：将 QTextEdit 添加到 QSplitter 中，形成分隔。
5. 设置布局：创建垂直布局，并将 QSplitter 添加到布局中。
6. 设置窗口属性：设置窗口大小和显示。

运行结果：

示例2：

#include <QApplication>
#include <QMainWindow>
#include <QSplitter>
#include <QTextEdit>
#include <QListView>
#include <QVBoxLayout>
#include <QStringListModel>

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

    QMainWindow window;

    // 创建 QSplitter
    QSplitter *splitter = new QSplitter(Qt::Horizontal);

    // 创建控件
    QTextEdit *textEdit = new QTextEdit(splitter);
    textEdit->setText("This is a QTextEdit control.");

    QListView *listView = new QListView(splitter);
    listView->setModel(new QStringListModel(QStringList() << "Item 1" << "Item 2" << "Item 3"));

    // 将控件添加到分隔器
    splitter->addWidget(textEdit);
    splitter->addWidget(listView);

    // 设置初始大小
    splitter->setSizes(QList<int>() << 200 << 100);

    // 将分隔器设置为主窗口的中心小部件
    window.setCentralWidget(splitter);

    window.resize(400, 300);
    window.show();

    return a.exec();
}

运行结果：

布局可视化

布局可视化设计的代码原理

在Qt Designer中设计的布局，实际上是通过对各类布局管理类的实例进行配置实现的。这些配置信息会被保存在UI文件中，并在MOC编译过程中转换为C++代码。

• 大部分情况下，可以通过Qt Designer进行可视化布局设计，但在某些复杂情况下，如需要动态调整布局或实现特定布局效果时，需要编程实现布局管理。

使用容器组件：

• 容器组件的作用：容器组件用于存放需要布局管理的组件，可以对容器内的组件设置一种布局方式，当容器大小变化时，容器内组件的大小和位置能自动变化。
• 布局管理的组件也可以不放在容器组件里，直接进行布局管理。

水平布局

• 水平布局的概念和属性：水平布局是将组件在水平方向上依次排列的布局方式。
• 布局属性：包括layoutLeftMargin、layoutTopMargin、layoutRightMargin和layoutBottomMargin四个边距属性，以及layoutSpacing表示组件的最小间距。
• 底层代码原理：在MOC预编译结果文件的setupUi()函数中，会生成创建水平布局、分组框和按钮等对象的代码。

网格布局

• 网格布局的概念：网格布局是将组件按照一定的网格进行布局的方式。
• 可视化设计网格布局的方法：在容器组件内先摆放组件，然后点击工具栏上的网格布局按钮进行网格布局。

网格布局的几个属性：

属性名称	描述	默认值或功能描述
layoutHorizontalSpacing	水平方向上组件的最小间距	无具体默认值，根据实际情况设定
layoutVerticalSpacing	垂直方向上组件的最小间距	无具体默认值，根据实际情况设定
layoutRowStretch	各行的延展因子，与垂直布局的 layoutStretch属性功能相同	无具体默认值，根据实际需求设定，可能会影响布局行的高度比例分配
layoutColumnStretch	各列的延展因子，与水平布局的layoutStretch 属性功能相同	无具体默认值，根据实际需求设定，可能会影响布局列的宽度比例分配
layoutRowMinimumHeight	各行的最小高度，单位是像素	如果是0（零），则表示自动设置；如果是非零整数值则表示设置具体的高度值限制每行的最小高度限制，但不会忽略设置内容所需的最低值或其他行为时的对齐策略的要求。
layoutColumnMinimumWidth	各列的最小宽度，单位是像素	如果是0（零），则表示自动设置；如果是非零整数值则表示设置具体的宽度值限制每列的最小宽度限制，但不会忽略设置内容所需的最低值或其他行为时的对齐策略的要求。
layoutSizeConstraint	布局的尺寸限制方式，其值是枚举类型QLayout::SizeConstraint	默认设置为QLayout::SetDefaultConstraint，即根据父组件的最小尺寸作为网格布局的最小尺寸来限制子组件的布局尺寸。此属性定义了如何控制布局的尺寸和子组件的缩放行为。

常见界面组件

字符串操作

字符集与编码

• ASCII字符集：基础字符集，1字节编码，包含英语字母、数字、标点符号等。
• Latin1字符集：ASCII的扩展，1字节编码，用于表示拉丁字母表中的特殊语言字符。
• Unicode编码：为了表示更多语言（如汉语、日语）的字符，出现了Unicode编码。它通过对Latin1字节进行扩展，使用额外的字节来表示更多的字符。其中包括多种存储方案，如UTF-8和UTF-16。
• UTF-8：最少1字节编码，最多4字节。可以兼容Latin1编码，被广泛使用。Qt Creator默认使用UTF-8编码存储C++语言头文件和源文件。

QString

QString是Qt库中用于处理字符串的类。

核心特点：

• 数据存储：使用QChar类型的字符存储字符串，每个字符占用2字节（使用UTF-16编码）。对于超出常规Unicode范围的字符，QString使用两个连续的QChar来表示。
• 功能丰富：提供了大量的接口函数用于字符串操作。
• 内存优化：使用隐式共享技术，只在修改字符串时复制，以节省内存。

QString字符串的创建和初始化

定义和创建方式：QString 是一个用于处理字符串的类，有多种构造函数。创建时，可以通过传递 const char * 类型的数据来初始化 QString 对象的内容。例如，通过传递 "Hello Qt" 来创建一个包含此内容的 QString 对象。

示例：

const char* str = "Hello Qt";
QString qStr = QString::fromUtf8(str); // 将const char*转换为QString

编码转换：在 Qt Creator 中，源文件默认使用 UTF-8 编码保存。当使用 const char * 类型的数据初始化 QString 时，QString 会使用其静态函数 fromUtf8() 将 const char * 类型的数据转换为 UTF-16 编码的字符串。

QString字符串的索引和操作

索引访问：QString 存储的字符串是一个 QChar 字符数组。可以使用元素索引操作符 "[]" 或 at() 函数访问每个字符。索引序号从 0 开始。

字符类型：在 QString 中，每个字符都是 QChar 类型，是用 UTF-16 编码的。因此，一个汉字也是一个字符。

示例：

QString str = "酒";
QChar ch0 = str.at(0); // 获取第一个字符
QChar ch7 = str.at(7); // 这里假设str是一个包含汉字的字符串，索引从0开始计数

常用操作接口函数：

QString 提供了许多用于字符串操作的接口函数。

这些函数包括但不仅限于：查找、替换、截取、连接等。这些函数允许开发者方便地对字符串进行各种操作。

方法名称	功能描述
length()	返回字符串的长度（字符数）。
append()	在字符串的末尾追加字符或字符串。
insert()	在字符串的指定位置插入字符或字符串。
replace()	替换字符串中的字符或子字符串。
trimmed()	去除字符串开头和结尾的空格。
contains()	检查字符串是否包含某个子字符串。

示例：

QString str = "Hello World";
int len = str.length(); // 获取长度
str.append("!"); // 追加字符
str.insert(5, "Beautiful "); // 在指定位置插入字符串
str.replace(0, 5, "Hi"); // 替换子字符串
str = str.trimmed(); // 去除首尾空格
bool contains = str.contains("Hi"); // 检查是否包含子字符串"Hi"

QString 字符串与数值的转换

在程序中，经常需要进行字符串与数值之间的转换。

QString 提供了一系列函数用于字符串与数值之间的转换，包括整数、浮点数与字符串之间的转换，以及不同进制之间的转换。使用这些函数可以方便地进行数据转换。

1、字符串转数值

整数转换

使用 QString::toInt：

QString str = "123";
bool ok;
int num = str.toInt(&ok);
if (ok) {
    // 转换成功
}

浮点数转换

使用 QString::toDouble：

QString str = "123.45";
bool ok;
double dNum = str.toDouble(&ok);
if (ok) {
    // 转换成功
}

2、数值转字符串

整数转换

使用 QString::number：

int num = 123;
QString str = QString::number(num);

浮点数转换

使用 QString::number：

double dNum = 123.45;
QString str = QString::number(dNum, 'f', 2);  // 'f' 表示浮点数，2 为小数位数

示例：

#include <QCoreApplication>
#include <QString>
#include <QDebug>

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

    // 字符串转整数
    QString strInt = "42";
    bool okInt;
    int intValue = strInt.toInt(&okInt);
    if (okInt) {
        qDebug() << "Integer value:" << intValue;
    }

    // 字符串转浮点数
    QString strDouble = "3.14";
    bool okDouble;
    double doubleValue = strDouble.toDouble(&okDouble);
    if (okDouble) {
        qDebug() << "Double value:" << doubleValue;
    }

    // 整数转字符串
    int num = 123;
    QString strFromInt = QString::number(num);
    qDebug() << "String from integer:" << strFromInt;

    // 浮点数转字符串
    double dNum = 456.78;
    QString strFromDouble = QString::number(dNum, 'f', 2);
    qDebug() << "String from double:" << strFromDouble;

    return a.exec();
}

Qchar

QChar类是用于处理字符的类，尤其在处理QString字符串中的字符时非常有用。QChar采用UTF-16编码表示字符，提供了一系列接口函数用于字符操作。

• QChar用于表示一个字符，是QString字符串中的基本元素。它采用UTF-16编码，能够处理各种Unicode字符。

主要接口函数：QChar类提供了一系列接口函数，用于操作字符。这些函数的输入参数为空，都是对QChar对象所表示的字符进行操作。

• 字符操作：包括获取字符的Unicode码点、字符类别等。
• 格式化输出：用于将字符格式化为特定的字符串表示形式。
• 字符比较：用于比较两个字符的大小、是否相等等。
• 字符转换：用于将字符转换为大写、小写或其他形式。

接口函数的作用：

• 这些接口函数使得QChar能够执行各种字符处理任务，如格式化输出、字符比较和转换等。这些功能在处理字符串、文本和用户界面等场景中非常有用。

函数原型

函数原型	描述
bool isDigit	判断一个字符是否为数字字符。
bool isLetter	判断一个字符是否为字母字符。
bool isLetterOrNumber	判断一个字符是否为字母或数字字符。
bool isLower	判断一个字符是否为小写字母。
bool isUpper	判断一个字符是否为大写字母。
bool isMark	判断一个字符是否为标记字符（如标点符号、特殊符号等）。
bool isNonCharacter	判断一个字符是否为非字符（例如控制字符）。
bool isNull	判断一个字符是否为空字符。
bool isNumber	判断一个字符是否为数字（可能包括小数点和科学计数法等）。
bool isPrint	判断一个字符是否为可打印字符（即可见字符）。
bool isPunct	判断一个字符是否为标点符号。
bool isSpace	判断一个字符是否为空白字符（如空格、制表符等）。
bool isSymbol	判断一个字符是否为符号字符（如数学符号、货币符号等）。
char toLatin1	将字符转换为 Latin1 编码格式。具体转换方式和输入有关。
QChar toLower	将给定的字符转换为小写字母，如果输入已经是小写则不变。这是一个重载函数，具体实现取决于输入类型。
QChar toUpper	将给定的字符转换为大写字母，如果输入已经是大写则不变。这也是一个重载函数，具体实现取决于输入类型。
char16_t unicode	获取给定字符的 Unicode 编码值。这是一个重载函数，具体实现取决于输入类型。
QChar fromUcs2	用于从 UCS-2 编码生成一个 QChar 对象。UCS-2 是一种字符编码，使用 2 字节表示 Unicode 字符。

QChar与Latin1字符的转换

QChar是UTF-16编码的字符，而Latin1是一种单字节编码，常用于表示ASCII字符。在某些情况下，需要将QChar转换为Latin1编码。这时，可以使用QChar的toLatin1()函数。但需要注意的是，只有当QChar字符的编码值在0到255的范围内时，这种转换才有意义。超出此范围的字符无法被正确转换。

QChar字符的Unicode编码

QChar的接口函数unicode()用于获取字符的UTF-16编码。这意味着我们可以获取任何字符，包括汉字的UTF-16编码。此外，我们还能够通过char16_t类型的编码构造QChar字符。为此，可以使用QChar的静态函数fromUcs2()。这个函数接受一个char16_t类型的参数，根据该参数创建一个对应的QChar对象。

QChar的逻辑运算符

QChar类提供了逻辑运算符，用于两个QChar对象的比较。这种比较实际上是基于两个QChar字符的UTF-16编码的大小进行的。例如，可以通过逻辑运算符来判断和替换字符串中的特定字符。

示例：

假设我们有一个字符串 str ，其中包含汉字"河"，我们想将其替换为"湖"。我们可以使用QChar的逻辑运算符来完成这个任务。

QString str = "河是一个汉字";
QChar riverChar = str.at(0); // 获取第一个字符（汉字"河"）的QChar对象
int riverCode = riverChar.unicode(); // 获取该汉字的UTF-16编码

// 使用逻辑比较判断字符是否为"河"
if (riverCode == /*"河"的UTF-16编码*/) {
    // 使用fromUcs2()构造代表"湖"的QChar对象，并用它替换原来的字符
    str.replace(0, 1, QChar::fromUcs2(/*"湖"的UTF-16编码*/));
}

代码解析：展示了如何使用QChar的逻辑运算符以及如何将QChar与UTF-16编码进行转换。

• 首先，通过 unicode() 函数获取汉字的UTF-16编码，
• 然后使用逻辑比较判断该字符是否为我们要替换的字符。
• 如果是，使用 fromUcs2() 函数构造新的字符（这里是"湖"），并用它替换原来的字符。

输出显示组件

QLabel

QLabel 类本身提供有很多属性和方法，它还从父类继承了很多属性和方法。

QLabel 类常用的一些属性和方法：

属 性	含 义
alignment	保存 QLabel 控件中内容的对齐方式，默认情况下，QLabel 控件中的内容保持左对齐和垂直居中。 该属性的值可以通过调用 alignment() 方法获得，可以借助 setAlignment() 方法修改。
text	保存 QLabel 控件中的文本，如果 QLabel 控件中没有文本，则 text 的值为空字符串， 该属性的值可以通过 text() 方法获得，可以借助 setText() 方法修改。
pixmap	保存 QLabel 控件内显示的图片，如果控件内没有设置图片，pixmap 的值为 0。 该属性的值可以通过调用 pixmap() 方法获得，可以借助 setPixmap() 方法修改。
selectedText	保存 QLabel 控件中被选择了的文本，当没有文本被选择时，selectedText 的值为空字符串。 该属性的值可以通过调用 selectedText() 方法获得。
hasSelectedText	判断用户是否选择了 QLabel 控件内的部分文本，如果是则返回 true，反之则返回 false。默认情况下，该属性的值为 false。
indent	保存 QLabel 控件内文本的缩进量，文本的缩进方向和 alignment 属性的值有关。 该属性的值可以通过调用 indent() 方法获得，可以借助 setIndent() 方法修改。
margin	保存 QLabel 控件中内容与边框之间的距离（边距），margin 的默认值为 0。 该属性的值可以通过调用 margin() 方法获得，可以借助 setMargin() 方法修改。
wordWrap	保存 QLabel 控件内文本的换行策略。当该属性的值为 true 时，控件内的文本会在必要时自动换行。默认情况下，控件内的文本是禁止自动换行的。 该属性的值可以通过 wordWrap() 方法获得，可以借助 setWordWrap() 方法修改。

一些常用的操作 QLabel 控件的成员方法，它们有些定义在 QLabel 类内，有些是通过继承父类得到的：

成员方法	功 能
hide()	隐藏文本框。
clear()	清空 QLabel 控件内所有显示的内容。
setToolTip(QString)	设置信息提示，当用户的鼠标放在QLabel 文本框上时会自动跳出文字。
setToolTipDuration(int)	设置提示信息出现的时间，单位是毫秒。
setStyleSheet(QString)	设置 QLabel 文本框的样式。
setGeometry(int x, int y, int w, int h)	设置 QLabel 文本框的位置 (x, y) 以及尺寸 (w, h)。

QLabel文本框的信号：

信号函数	功 能
linkActivated(const QString &link)	用户点击超链接时触发，link 参数用于向槽函数传输超链接的 URL。
linkHovered(const QString &link)	用户的鼠标悬停到超链接位置时触发，link 参数用于向槽函数传输超链接的 URL。

QLabel 控件提供的槽函数：

槽函数	功 能
clear()	清空 QLabel 控件内所有的内容。
setMovie(QMovie *movie)	清空 QLabel 控件内所有的内容，改为显示指定的 movie 动画。
setNum(int num)	清空 QLabel 控件内所有的内容，改为显示 num 整数的值。
setNum(double num)	清空 QLabel 控件内所有的内容，改为显示 num 小数的值。
setPicture(const QPicture &picture)	清空 QLabel 控件内所有的内容，改为显示经 QPicture 类处理的图像。
setPixmap(const QPixmap &)	清空 QLabel 控件内所有的内容，改为显示经 QPixmap 类处理的图像。
setText(const QString &)	清空 QLabel 控件内所有的内容，改为显示指定的文本。

示例：

#include <QApplication>
#include <QLabel>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //创建一个文本框
    QLabel lab;

    //设置文本框内容居中显示
    lab.setAlignment(Qt::AlignCenter);
    //设置文本框的坐标和尺寸
    lab.setGeometry(100,100,400,400);
    //设置文本框要显示超链接内容
    lab.setText("<a href=\"点击链接\">helloworld");
    //当用户鼠标位于文本框上时，显示提示内容
    lab.setToolTip("点击超链接显示URL");
    //提示内容显示 1 秒
    lab.setToolTipDuration(1000);

    //为文本框设置信号和槽，当用户点击超链接时，将文本框内容改为超链接的 URL
    QObject::connect(&lab,&QLabel::linkActivated,&lab,&QLabel::setText);
    //程序运行后，文本框显示
    lab.show();

    return a.exec();
}

运行结果：

数值输入输出

数值输入输出组件

组件名称	功能描述	使用场景
QSpinBox	提供一个向上和向下的箭头，允许用户选择整数值。	适用于选择整数值，如设置数量或分数。
QDoubleSpinBox	类似于 QSpinBox，但用于输入浮点数。	适用于需要更精确的小数输入，如价格或间隔。
QSlider	允许用户通过滑动条选择数值。	适用于音量控制或调节亮度等场景。
QProgressBar	显示任务的进度，通过数值表示当前状态。	适用于长期运行操作的进度展示。

QSpinBox

QSpinBox 是Qt框架中的一个用于输入整数值的控件。它提供了一个小的文本框和上下调整按钮，用户可以通过输入数字或点击按钮来增加或减少数值。

QSpinBox 常用于需要从用户获取整数的场景，比如设置数量、等级等。

常用属性：

属性	描述
minimum	最小值，默认值为INT_MIN。
maximum	最大值，默认值为INT_MAX。
value	当前值，用户设置的数值。
singleStep	每次增加或减少的步长，默认值为1。
prefix	设置数值前的前缀字符串，例如货币符号。
suffix	设置数值后的后缀字符串，例如单位（如"件"、"kg"）。
readOnly	控制是否为只读模式，设置为true后，无法更改值。
alignment	设置文本的对齐方式（如左对齐、右对齐或居中）。
keyboardTracking	控制是否在键盘输入时立即更新值，默认为true。
displayIntegerBase	控制十进制、十六进制等形式表示整数的基数。

常用方法：

方法	描述
setRange(min, max)	设置允许的最小和最大值。
setValue(value)	设置当前的值。
value()	获取当前的值。
setSingleStep(step)	设置每次增减的步长。
singleStep()	获取当前的步长。
setSuffix(suffix)	设置后缀，例如单位（如"件"或"kg"）。
setPrefix(prefix)	设置前缀，例如"$"或"€"。
prefix()	获取当前的前缀。
suffix()	获取当前的后缀。
setReadOnly(bool)	设置为只读模式，用户无法修改值。
setValueRange(min, max)	用于设置允许的值范围，等同于setRange()。
valueChanged(int)	当值变化时发出信号。
editingFinished()	编辑完成时发出信号。
setAlignment(alignment)	设置文本对齐方式（例如Qt::AlignRight等）。
setKeyboardTracking(bool)	设置键盘跟踪，决定是否在输入时立即更新。

示例：如何使用 QSpinBox 控件创建一个基本的Qt应用程序。

#include <QApplication>
#include <QWidget>
#include <QSpinBox>
#include <QVBoxLayout>
#include <QLabel>

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

    // 创建主窗口
    QWidget window;
    window.setWindowTitle("QSpinBox 示例");

    // 创建一个垂直布局
    QVBoxLayout *layout = new QVBoxLayout(&window);

    // 创建一个标签
    QLabel *label = new QLabel("请选择一个数字：");
    layout->addWidget(label);

    // 创建QSpinBox
    QSpinBox *spinBox = new QSpinBox();
    spinBox->setRange(0, 100); // 设置范围
    spinBox->setSingleStep(1); // 设置步进值
    spinBox->setValue(50); // 设置初始值
    layout->addWidget(spinBox);

    // 连接信号与槽
    QObject::connect(spinBox, QOverload<int>::of(&QSpinBox::valueChanged), 
                     [&](int value) {
                         label->setText(QString("当前选中数字: %1").arg(value));
                     });

    // 设置布局并显示窗口
    window.setLayout(layout);
    window.resize(300, 200);
    window.show();

    return app.exec();
}

示例解析

1. 基础设置：
   • 创建一个 QWidget 作为主窗口，并设置窗口标题。
   • 使用 QVBoxLayout 来管理控件的垂直布局。
2. 添加控件：
   • 创建一个 QLabel 用于显示提示信息。
   • 创建一个 QSpinBox ，设置其范围为0到100，步进值为1，并设定初始值为50。
3. 信号与槽的连接：
   • 连接 QSpinBox 的 valueChanged 信号到一个槽函数，当值发生变化时，更新 QLabel 的文本，显示当前选中的数字。
4. 窗口显示：
   • 设置布局，并显示主窗口。

运行结果：

QDoubleSpinBox

QDoubleSpinBox 是 Qt 框架中的一个小部件，专门用于输入浮点数（双精度数）。

允许用户通过输入、上下箭头按钮或鼠标滚轮来调整其值，常用于需要小数输入的场合。

示例：如何在 Qt 应用程序中使用 QDoubleSpinBox 。

#include <QApplication>
#include <QWidget>
#include <QDoubleSpinBox>
#include <QVBoxLayout>
#include <QLabel>

class DoubleSpinBoxExample : public QWidget {
public:
    DoubleSpinBoxExample() {
        // 创建布局
        QVBoxLayout *layout = new QVBoxLayout(this);

        // 创建标签
        QLabel *label = new QLabel("请选择一个浮点数：", this);
        layout->addWidget(label);

        // 创建 QDoubleSpinBox
        QDoubleSpinBox *doubleSpinBox = new QDoubleSpinBox(this);
        doubleSpinBox->setRange(0.0, 100.0);    // 设置最小值和最大值
        doubleSpinBox->setSingleStep(0.1);      // 设置每次增减的步进
        doubleSpinBox->setDecimals(2);           // 设置小数点后显示的位数
        doubleSpinBox->setValue(50.0);          // 设置初始值
        layout->addWidget(doubleSpinBox);

        // 连接信号和槽
        connect(doubleSpinBox, QOverload<double>::of(&QDoubleSpinBox::valueChanged),
                [label](double value){ label->setText("当前选择: " + QString::number(value)); });

        // 设置布局
        setLayout(layout);
        setWindowTitle("QDoubleSpinBox 示例");
    }
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    
    DoubleSpinBoxExample window;
    window.resize(300, 100);
    window.show();
    
    return app.exec();
}

运行代码的步骤

1. 确保你的系统中安装了 Qt 开发环境。
2. 创建一个新的 Qt 项目，并将以上代码粘贴到主源文件中。
3. 编译并运行项目，你将看到一个包含 QDoubleSpinBox 的窗口，用户可以通过它选择浮点数。

运行结果：

QSlider

QSlider 是 Qt 中的一个用户界面控件，用于提供一个可以滑动的条形控件，让用户选择一个值。通常用于设置数值范围，常见的应用包括音量控制、亮度调节、记录进度等。

常用属性：

属性	描述
minimum	滑动条允许的最小值，默认值为0。
maximum	滑动条允许的最大值，默认值为100。
value	当前滑块的位置值。
orientation	滑动条的方向（水平或垂直），默认是水平。
tickInterval	刻度之间的间隔值，设置滑动条的刻度数量。
tickPosition	刻度的位置（如QSlider::TicksAbove、QSlider::TicksBelow等）。
pageStep	页面步长，按页面增减的步长，默认值为1。
invertedAppearance	是否反向显示滑动条，true表示反向，false表示正常显示。
sliderPosition	当前滑块位置的值，与value()相同。
singleStep	每次按箭头增加或减少的步长，默认值为1。

常用方法：

方法	描述
setRange(min, max)	设置滑动条的最小值和最大值。
setValue(value)	设置当前滑动位置的值。
value()	获取当前滑动位置的值。
setOrientation(orientation)	设置滑动条的方向（水平或垂直）。
orientation()	获取滑动条的当前方向。
setTickInterval(tickInterval)	设置刻度间隔。
setTicksPosition(position)	设置刻度的位置（如QSlider::TicksBothSides）。
setPageStep(step)	设置页面步长，用于按页面增减的滑动量。
pageStep()	获取当前的页面步长。
setMinimumSize(width, height)	设置滑动条的最小尺寸。
sliderMoved(value)	当滑块移动时发出信号，可以连接到自定义槽函数。
valueChanged(value)	当值变化时发出信号，可以连接到自定义槽函数。
setInvertedAppearance(bool)	设置滑动条是否反转显示。

示例：如何创建一个 QSlider ，并根据滑块的值更新一个标签的文本

#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>
#include <QSlider>
#include <QLabel>

class SliderExample : public QWidget {
    Q_OBJECT

public:
    SliderExample(QWidget *parent = nullptr) : QWidget(parent) {
        // 创建垂直布局
        QVBoxLayout *layout = new QVBoxLayout(this);

        // 创建一个滑块
        QSlider *slider = new QSlider(Qt::Horizontal);
        slider->setRange(0, 100);       // 设置范围
        slider->setValue(50);           // 设置初始值
        slider->setSingleStep(1);       // 设置步长

        // 创建一个标签用于显示滑块的值
        QLabel *label = new QLabel("Value: 50");
        label->setAlignment(Qt::AlignCenter);

        // 连接信号与槽
        connect(slider, &QSlider::valueChanged, [label](int value) {
            label->setText(QString("Value: %1").arg(value));
        });

        // 将控件添加到布局
        layout->addWidget(slider);
        layout->addWidget(label);

        // 设置布局
        setLayout(layout);
        setWindowTitle("QSlider Example");
    }
};

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

    SliderExample window;
    window.resize(300, 100);
    window.show();

    return app.exec();
}

#include "main.moc"

代码解析

1. 创建滑块：
   • QSlider *slider = new QSlider(Qt::Horizontal); 创建一个水平的滑块。
2. 设置范围和初始值：
   • slider->setRange(0, 100); 设置滑块的值范围为 0 到 100。
   • slider->setValue(50); 设置滑块的初始值为 50。
3. 设置步长：
   • slider->setSingleStep(1); 设置每次滑动改变的步长为 1。
4. 连接信号与槽：
   • 使用 connect() 函数连接 valueChanged(int) 信号到一个 Lambda 表达式，更新标签文本以反映当前滑块的值。
5. 布局管理：
   • 使用 QVBoxLayout 管理滑块和标签的布局，并将其设置为窗口的布局。

运行结果：

QProgressBar

QProgressBar 是 Qt 中用于显示进度的控件，常用于表示某个操作的进行状态，例如文件下载、任务执行等。它提供了一种直观的方式来展示当前任务的进度，使得用户能够了解当前操作的完成度。

常用属性：

属性	描述
minimum	进度条的最小值，默认值为0。
maximum	进度条的最大值，默认值为100。
value	当前进度值，表示已完成的进度。
textVisible	是否显示进度文本，true表示显示，false表示隐藏。
format	设置进度文本的格式，支持字符串格式化。
orientation	进度条的方向（水平或垂直），默认是水平。
canceled	设置是否允许取消进度，比如长时间操作中的进度条。
minimumSize	设置进度条的最小尺寸。
textAlignment	设置进度文本的对齐方式（如左、中、右对齐）。
stylesheet	应用样式表以自定义进度条的外观。

常用方法：

方法	描述
setRange(min, max)	设置进度条的最小值和最大值。
setValue(value)	设置当前进度的值。
value()	获取当前进度的值。
setTextVisible(bool)	控制是否显示进度文本。
setFormat(format)	设置进度文本的格式，例如"%p%"表示百分比。
setOrientation(orientation)	设置进度条的方向（水平或垂直）。
reset()	重置进度条到最小值。
setTextAlignment(alignment)	设置文本的对齐方式（如左、中、右对齐）。
setStyleSheet(sheet)	应用样式表以自定义进度条的外观。

示例：

#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>
#include <QPushButton>
#include <QProgressBar>
#include <QTimer>

class ProgressBarExample : public QWidget {
    Q_OBJECT

public:
    ProgressBarExample() {
        QVBoxLayout *layout = new QVBoxLayout(this);
        
        QProgressBar *progressBar = new QProgressBar(this);
        progressBar->setRange(0, 100);
        progressBar->setValue(0);
        
        QPushButton *startButton = new QPushButton("Start", this);

        layout->addWidget(progressBar);
        layout->addWidget(startButton);
        
        connect(startButton, &QPushButton::clicked, this, [progressBar]() {
            progressBar->setValue(0);
            QTimer *timer = new QTimer();
            QObject::connect(timer, &QTimer::timeout, [progressBar, timer]() {
                int value = progressBar->value();
                if (value < 100) {
                    progressBar->setValue(value + 1);
                } else {
                    timer->stop();
                    delete timer;
                }
            });
            timer->start(100);  // 每100毫秒更新一次
        });
    }
};

int main(int argc, char *argv[]) {
    QApplication a(argc, argv);
    ProgressBarExample w;
    w.show();
    return a.exec();
}

#include "main.moc"

运行结果：

QScrollBar

Qt 中用于提供滚动功能的组件，允许用户通过水平或垂直方向的滑动来浏览内容，例如长列表或大文本区域。

常用属性：

属性	描述
minimum	滚动条的最小值，默认值为0。
maximum	滚动条的最大值，默认值为100。
value	当前滚动位置的值。
orientation	滚动条的方向（水平或垂直），默认是水平。
singleStep	每次按箭头增减的步长，默认值为1。
pageStep	页面步长，按页面增减的量，默认值为1。
sliderPosition	当前滑块位置的值，与value()相同。
sliderMovement	设置滑块移动的方式（如滑动或跳跃）。
tickInterval	设置刻度之间的间隔。
tickPosition	刻度的位置（如QScrollBar::TicksBothSides）。

常用方法：

方法名	描述
setValue()	设置滚动条当前位置的值。
value()	返回滚动条当前位置的值。
setRange(int minimum, int maximum)	设置滚动条的最小值和最大值范围。
minimum()	返回滚动条的最小值。
maximum()	返回滚动条的最大值。
singleStep()	返回滚动条单次滚动的值大小。
setSingleStep(int steps)	设置滚动条单次滚动的值大小。
pageStep()	返回滚动条页面滚动的值大小。
setPageStep(int steps)	设置滚动条页面滚动的值大小。
sliderPosition()	返回滑块当前位置相对于滚动条起始点的距离。
setSliderPosition(int pos)	设置滑块的位置。
orientation()	返回滚动条的朝向（水平或垂直）。
setOrientation(Qt::Orientation orientation)	设置滚动条的朝向。
action()	返回上次操作的滚动行为（例如滑动滑块或使用箭头按钮）。
eventFilter(QObject *watched, QEvent *event)	用于事件过滤的重载方法，通常用于自定义事件处理。不是直接用于控制滚动条，而是用于处理与滚动条相关的事件。

示例：创建一个窗口，包含一个垂直滚动条和一个文本框，用户可以通过滚动条来滚动文本内容：

#include <QApplication>
#include <QScrollBar>
#include <QTextEdit>
#include <QVBoxLayout>
#include <QWidget>

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

    QWidget window;
    QVBoxLayout layout(&window);

    QTextEdit *textEdit = new QTextEdit();
    textEdit->setText("这里是一些示例文本。\n可以随意添加更多文本来测试滚动条的效果。");
    textEdit->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn); // 总是显示垂直滚动条

    QScrollBar *scrollBar = new QScrollBar(Qt::Vertical);
    scrollBar->setRange(0, 100); // 设置滚动范围
    scrollBar->setValue(0); // 初始化当前值

    // 连接滚动条的值变化信号与文本编辑器的设置滚动位置
    QObject::connect(scrollBar, &QScrollBar::valueChanged, [textEdit](int value) {
        textEdit->verticalScrollBar()->setValue(value);
    });

    layout.addWidget(textEdit);
    layout.addWidget(scrollBar);
    window.setLayout(&layout);
    window.setWindowTitle("QScrollBar Example");
    window.resize(400, 300);
    window.show();

    return app.exec();
}

运行结果：

QDial

Qt 中的一个用于选择值的旋转选择器组件。它提供了一种直观的方式来允许用户通过旋转一个圆形控件来选择范围内的值。

常用属性：

属性名称	描述
Minimum	仪表盘刻度的最小值。这个值表示仪表盘的起始点。
Maximum	仪表盘刻度的最大值。这个值表示仪表盘的终点。
Value	当前指针在仪表盘上指示的值。可以通过设置这个属性来改变指针的位置。
Step	每次增加或减少值的步长。当使用某些方法来改变当前值时，这个属性决定了每次改变的幅度。
StartAngle	指针开始的角度（以度为单位）。改变这个属性可以改变指针在仪表盘上出现的初始位置。
HandleShape	定义仪表盘指针的形状。通常有箭头形状或其他图形形状等选项可供选择。
颜色属性	这些属性允许您自定义仪表盘的各种元素的颜色，如指针、刻度线等。
背景属性	这些属性允许您自定义仪表盘的背景，例如设置背景颜色或背景图片等。

常用方法：

方法	描述
setNotched	设置是否带有缺口。当设置为 true 时，Dial 将显示一个缺口，表示其当前值的变化范围。
setNotchSize	设置缺口的尺寸。通过此方法来调整缺口的宽度或大小。
setNotchCount	设置缺口的数量。决定 Dial 上显示的缺口的数量。
setValue	设置 Dial 的当前值。可以通过此方法设置 Dial 显示的值。
value	获取 Dial 的当前值。通过此方法可以获取 Dial 当前显示的值。
setMinimumValue	设置 Dial 的最小值。定义 Dial 可以显示的最小值范围。
setMaximumValue	设置 Dial 的最大值。定义 Dial 可以显示的最大值范围。
setSingleStep	设置单次旋转的最小步长。控制 Dial 每次旋转时的增量大小。
setStep	设置旋转时的步长值。用于控制每次旋转的步数或移动的值大小。
setRangeValue 或 setRange	设置 Dial 的范围值。可以同时设置最小值和最大值范围。
setLabelFormat 或 setPrefix 或 setSuffix	设置标签的格式或前缀和后缀。用于自定义 Dial 显示值的格式，如添加单位或货币符号等。
setMarkerLength 或 setTickLength 或 setLabelLength	设置标记的长度或标签的长度。控制 Dial 上标记或标签的长度大小。
setLabelPrecision 或 setDecimalPrecision	设置标签的小数精度或有效位数限制。控制 Dial 显示值的精度或小数位数限制。

示例：如何使用 QDial 组件

#include <QApplication>
#include <QDial>
#include <QVBoxLayout>
#include <QLabel>
#include <QWidget>

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

    QWidget window;
    QVBoxLayout layout(&window);
    
    QDial *dial = new QDial();
    dial->setRange(0, 100); // 设置范围从0到100
    dial->setValue(50); // 设置初始值
    QLabel *label = new QLabel("Value: 50");

    // 连接信号与槽
    QObject::connect(dial, &QDial::valueChanged, [&label](int value) {
        label->setText(QString("Value: %1").arg(value));
    });

    layout.addWidget(dial);
    layout.addWidget(label);
    window.setLayout(&layout);
    window.setWindowTitle("QDial Example");
    window.resize(200, 200);
    window.show();

    return app.exec();
}

代码解析

1. 创建 QDial： 初始化一个 QDial 实例并设置其值范围为 0 到 100。
2. 当前值的默认设置： 使用 setValue 方法设置初始值。
3. 信号连接： 当拨盘的值改变时，更新标签文本以显示当前值。
4. 布局设置： 使用 QVBoxLayout 来排列 QDial 和 QLabel。

运行结果：

文本输入

QPlainTextEdit

Qt 中的一种用于显示和编辑纯文本的组件。与 QTextEdit 不同，QPlainTextEdit 专注于处理大文本、提高性能和资源使用效率，适合需要处理简单文本的场景。

方法：

属性/方法	描述
text()	获取当前显示的纯文本内容。
plainText()	返回当前编辑的纯文本内容（与 text() 功能相同）。
cursorPosition()	返回当前光标位置。
cursorWidth()	获取或设置光标宽度。
readOnly()	返回控件是否为只读模式。
setText(const QString &text)	设置要显示的纯文本内容。
toPlainText()	返回当前编辑的纯文本内容（与 plainText() 功能相同）。
appendPlainText(const QString &text)	在文本末尾追加纯文本内容。
cursorForPosition(int position)	返回给定位置的光标对象。
setTextWidth(int width)	设置文本的宽度。
load(const QString &fileName)	从文件中加载文本内容到编辑器中。
redoAction()	执行重新操作（如果有可用）。
undoAction()	执行撤销操作（如果有可用）。
setReadOnly(bool readOnly)	设置控件为只读或可编辑模式。
setCursorWidth(int width)	设置光标宽度（与 cursorWidth() 获取功能不同）。

示例：如何使用 QPlainTextEdit 组件。

#include <QApplication>
#include <QPlainTextEdit>
#include <QVBoxLayout>
#include <QWidget>
#include <QPushButton>

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

    QWidget window;
    QVBoxLayout layout(&window);

    QPlainTextEdit *plainTextEdit = new QPlainTextEdit();
    plainTextEdit->setPlainText("请输入文本...\n可以在这里撰写内容。");

    QPushButton *button = new QPushButton("获取文本");
    QObject::connect(button, &QPushButton::clicked, [plainTextEdit]() {
        QString text = plainTextEdit->toPlainText();
        qDebug() << "当前文本:" << text;
    });

    layout.addWidget(plainTextEdit);
    layout.addWidget(button);
    window.setLayout(&layout);
    window.setWindowTitle("QPlainTextEdit Example");
    window.resize(400, 300);
    window.show();

    return app.exec();
}

代码解析

1. 创建 QPlainTextEdit： 初始化一个纯文本编辑器并设置初始文本。
2. 创建按钮： 用于获取当前文本内容。
3. 信号连接： 连接按钮点击信号到 QPlainTextEdit，获取并打印当前文本。
4. 布局设置： 使用 QVBoxLayout 来排列 QPlainTextEdit 和按钮。

运行结果：

QLineEdit

Qt 中用于输入和编辑单行文本的控件。它通常用于用户输入简短的文本，如用户名、搜索词或设置项。

常用属性：

属 性	含 义
text	保存输入框中的文本。 该属性的值可以通过 text() 方法获取，也可以通过 setText(const QString &) 方法修改。
maxLength	设置输入框中最多可以放置的文本长度。当文本长度超出最大限度后，超出部分将被丢弃。 默认情况下，maxLength 的值为 32767。该属性的值可以通过 maxLength() 函数获得，也可以通过 setMaxLength(int) 方法修改。
placeholderText	设置提示信息，例如当用户未选中输入框时，输入框中显示"请输入..."，而用户选中输入框时，"请输入..." 随之消失。 该属性的值可以通过 placeholderText() 方法获取，也可以通过 setPlaceholderText(const QString &) 方法修改。
clearButtonEnabled	当输入框中有文本时，输入框的右侧可以显示一个"一键清除"按钮。该属性的默认值为 false，即输入框中不会自动显示清除按钮。 该属性的值可以通过 isClearButtonEnabled() 方法获取，也可以通过 setClearButtonEnabled(bool enable) 方法修改。
echoMode	设定输入框中文本的显示样式，该属性的可选值有以下几个： QLineEdit::Normal：正常显示所输入的字符，此为默认选项。 QLineEdit::NoEcho：不显示任何输入的字符，常用于密码类型的输入，且长度保密 QLineEdit::Password：显示与平台相关的密码掩饰字符，而不是实际输入的字符。当用户重新点击输入框时，可以紧接着之前的文本继续输入。 QLineEdit::PasswordEchoOnEdit：编辑时正常显示输入的字符，编辑完成后改为用密码掩饰字符显示。当用户重新点击输入框时，不能紧接着之前的文本继续输入。 该属性的是可以通过 echoMode() 方法获取，也可以通过 setEchoMode(EchoMode) 方法修改。
frame	控制输入框的边框。默认情况下，输入框是带有边框的。 该属性的值可以通过 hasFrame() 方法获取，也可以通过 setFrame(bool) 方法修改。

常用方法：

方法名称	描述
setText(const QString &text)	设置行编辑器中的文本。
text()	获取当前行编辑器中的文本。
setReadOnly(bool readOnly)	设置文本是否为只读模式。
setEchoMode(QLineEdit::EchoMode mode)	控制如何显示输入的文本，如正常显示、密码模式等。
setPlaceholderText(const QString &text)	设置当文本框为空时的提示文本。
focusInEvent(QFocusEvent *)	处理获取焦点的事件。
focusOutEvent(QFocusEvent *)	处理失去焦点的事件。
keyPressEvent(QKeyEvent *)	处理键盘按键事件。
setSelection(int start, int length)	选择文本的特定部分。
selectedText()	获取当前选中的文本。
setValidator(const QValidator *validator)	设置输入验证器，用于控制用户输入的格式和范围。
isReadOnly()	检查文本是否为只读模式。
hasSelectedText()	检查是否有选中的文本。
cursorPosition()	获取光标的位置。
setCursorPosition(int pos)	设置光标的位置。
textChanged(const QString &text)	发出信号，当文本改变时调用此槽函数。
returnPressed()	发出信号，当用户按下回车键时调用此槽函数。
move(int x, int y)	指定输入框位于父窗口中的位置。
setValidator(const QValidator *v)	限制输入框中的文本内容，比如输入框只包含整数。
setReadOnly(bool)	设置输入框是否进入只读状态。在只读状态下，用户仍可以采用粘贴、拖拽的方式向输入框中放置文本，但无法进行编辑。
setAlignent(Qt::Alignment flag)	设置输入框中输入文本的位置。
clear()	清空文本框中的内容。
setText(const QString &)	重新指定文本框中的内容。

示例：如何使用 QLineEdit 组件。

#include <QApplication>
#include <QLineEdit>
#include <QVBoxLayout>
#include <QLabel>
#include <QWidget>

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

    QWidget window;
    QVBoxLayout layout(&window);

    QLabel *label = new QLabel("请输入文本:");
    QLineEdit *lineEdit = new QLineEdit();
    lineEdit->setPlaceholderText("在这里输入内容...");

    // 连接信号与槽
    QObject::connect(lineEdit, &QLineEdit::textChanged, [&label](const QString &text) {
        label->setText("当前输入: " + text);
    });

    layout.addWidget(label);
    layout.addWidget(lineEdit);
    window.setLayout(&layout);
    window.setWindowTitle("QLineEdit Example");
    window.resize(300, 120);
    window.show();

    return app.exec();
}

代码解析

1. 创建 QLineEdit： 初始化一个单行文本编辑器并设置占位符文本。
2. 创建标签：显示用户当前输入的文本。
3. 信号连接：连接 textChanged 信号，当用户输入时更新标签显示内容。
4. 布局设置：使用 QVBoxLayout 来按垂直方向排列标签和文本编辑框。

运行结果：

示例2：

#include <QApplication>
#include <QWidget>
#include <QLineEdit>

using namespace std;
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //创建一个窗口，作为输入框的父窗口
    QWidget widget;
    //设置窗口的标题
    widget.setWindowTitle("登录窗口");
   
    //创建账号输入框
    QLineEdit lineEdit(&widget);
    //指定输入框位于父窗口中的位置
    lineEdit.move(100,100);
    //设置提示信息
    lineEdit.setPlaceholderText("请输入账号...");
    //让输入框显示"一键清除"按钮
    lineEdit.setClearButtonEnabled(true);
   
    //创建密码输入框
    QLineEdit lineEditPass(&widget);
    lineEditPass.setPlaceholderText("请输入密码...");
    lineEditPass.move(100,150);
    //指定文本显示方式，保护用户账号安全
    lineEditPass.setEchoMode(QLineEdit::Password);
   
    //指定窗口的尺寸和显示文字的大小
    widget.resize(500,300);
    widget.setFont(QFont("宋体",16));

    widget.show();
    return a.exec();
}

运行结果：

QTextEdit

Qt 中用于显示和编辑多行文本的控件。它支持富文本格式，可以插入图片、表格等复杂内容，适合需要文本格式化和排版的场景。

常用方法：

方法名称	描述
QTextEdit(QWidget *parent = nullptr)	构造函数，创建一个 QTextEdit 对象。
setText(const QString &text)	设置文本编辑器中的文本内容。
text()	获取当前文本编辑器中的文本内容。
setPlainText(const QString &text)	设置纯文本内容。
toPlainText()	获取纯文本内容。
setHtml(const QString &html)	设置 HTML 内容。
setReadOnly(bool readOnly)	设置文本编辑器为只读或可编辑模式。
setWordWrap(bool wrap)	启用或禁用自动换行功能。
append(const QString &text)	在文本末尾追加文本。
insertPlainText(const QString &text, int cursorPosition = -1)	在指定位置插入纯文本。
insertHtml(const QString &html, int cursorPosition = -1)	在指定位置插入 HTML 内容。
setUndoRedoEnabled(bool enable)	启用或禁用撤销/重做功能。
focusInEvent(QFocusEvent *) 和 focusOutEvent(QFocusEvent *)	处理获取和失去焦点的事件。
setLineWrapColumnOrWidth(int columnOrWidth, LineWrapMode mode = NormalWrap)	设置自动换行的列数或宽度。
placeTextCursorAfterVisiblePosition(int index, TextCursorType cursorType)	在可视文本的指定位置放置光标。

示例：如何使用 QTextEdit 组件。

#include <QApplication>
#include <QTextEdit>
#include <QVBoxLayout>
#include <QPushButton>
#include <QWidget>

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

    QWidget window;
    QVBoxLayout layout(&window);

    QTextEdit *textEdit = new QTextEdit();
    textEdit->setPlaceholderText("这是一个文本编辑器...\n可以输入多行文本。");

    QPushButton *button = new QPushButton("获取文本");
    QObject::connect(button, &QPushButton::clicked, [textEdit]() {
        QString text = textEdit->toPlainText();
        qDebug() << "当前文本:" << text;
    });

    layout.addWidget(textEdit);
    layout.addWidget(button);
    window.setLayout(&layout);
    window.setWindowTitle("QTextEdit Example");
    window.resize(400, 300);
    window.show();

    return app.exec();
}

代码解析

1. 创建 QTextEdit: 实例化一个多行文本编辑器并设置占位符。
2. 创建按钮: 用于获取当前文本内容。
3. 信号连接: 连接按钮点击信号到 QTextEdit，获取并打印当前文本。
4. 布局设置: 使用 QVBoxLayout 来排列文本编辑器和按钮。

运行结果：

按钮

QPushButton

QPushButton 是 Qt 中用于创建可点击按钮的控件，属于 Qt Widget 模块中的一部分。它是实现用户交互功能的关键控件，常用于触发各种操作，例如提交表单、启动任务、打开对话框等。

QPushButton 类提供了很多实用的属性

属 性	含 义
text	保存按钮上要显示的文字。 该属性的值可以通过 text() 方法获取，也可以通过 setText(const QString &text) 方法修改。
icon	保存按钮左侧要显示的图标。 该属性的值可以通过 icon() 方法获取，也可以通过 setIcon(const QIcon &icon) 方法修改。
iconsize	保存按钮左侧图标的尺寸。 该属性的值可以通过 iconSize() 方法获取，也可以通过 setIconSize(const QSize &size) 方法修改。
size	保存按钮的尺寸。 该属性的值可以通过 size() 方法获取，也可以通过 resize(int w, int h) 或者 resize(const QSize &) 方法修改。
font	保存按钮上文字的字体和大小。 该属性的值可以通过 font() 方法获取，也可以通过 setFont(const QFont &) 方法修改。
flat	初始状态下，按钮是否显示边框。flat 属性的默认值为 flase，表示按钮带有边框。 该属性的值可以通过 isFlat() 方法获取，也可以通过 setFlat(bool) 方法修改。
enabled	指定按钮是否可以被按下。 该属性的默认值为 true，表示按钮可以被按下，即按钮处于启用状态。当该属性的值为 false 时，按钮将不能被点击，按钮处于禁用状态。 该属性的值可以通过 isEnabled() 方法获取，也可以通过 setEnabled(bool) 方法进行修改。
autoDefault	当用户按下 Enter 回车键时，是否触发点击按钮的事件。 当按钮的父窗口为 QDialog 窗口时，该属性的值为 true；其它情况下，该属性的默认值为 false。 该属性的值可以通过 autoFault() 方法获取，也可以通过 setAutoFault(bool) 方法修改。

QPushButton 常用的成员方法：

方 法	功 能
move(int x, int y)	手动指定按钮位于父窗口中的位置。
setStyleSheet(const QString &styleSheet)	自定义按钮的样式，包括按钮上文字或图片的显示效果，按钮的形状等等。
setGeometry(int x, int y, int w, int h)	同时指定按钮的尺寸和位置。
adjustSize()	根据按钮上要显示的内容，自动调整按钮的大小。
setDisabled(bool disable)	指定按钮是否可以被按下。当 disable 值为 true 时，表示按钮不能被按下，即禁用按钮的功能。

QPushButton 类常用的信号函数和槽函数：

信号	功 能
clicked() clicked(bool checked = false)	用户点击按钮并释放（或者按下按钮对应的快捷键）后，触发此信号。
pressed()	用户按下按钮时会触发此信号。
released()	用户松开按钮时会触发此信号。
click()	单击指定的按钮。
setIconSize()	重新设置按钮上图片的尺寸。
hide()	隐藏按钮控件。
setMenu(QMenu *menu)	弹出与按钮关联的菜单。

示例：如何使用 QPushButton 创建按钮并响应点击事件。

#include <QApplication>
#include <QWidget>
#include <QPushButton>
#include <QVBoxLayout>
#include <QMessageBox>

class ButtonExample : public QWidget {
    Q_OBJECT

public:
    ButtonExample(QWidget *parent = nullptr) : QWidget(parent) {
        // 创建垂直布局
        QVBoxLayout *layout = new QVBoxLayout(this);

        // 创建按钮
        QPushButton *button1 = new QPushButton("Click Me", this);
        QPushButton *button2 = new QPushButton("Exit", this);

        // 连接按钮的点击信号到槽函数
        connect(button1, &QPushButton::clicked, this, &ButtonExample::onButton1Click);
        connect(button2, &QPushButton::clicked, this, &ButtonExample::close); // 关闭窗口

        // 将按钮添加到布局
        layout->addWidget(button1);
        layout->addWidget(button2);

        // 设置布局
        setLayout(layout);
        setWindowTitle("QPushButton Example");
    }

private slots:
    void onButton1Click() {
        QMessageBox::information(this, "Information", "Button 1 clicked!");
    }
};

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

    ButtonExample window;
    window.resize(200, 100);
    window.show();

    return app.exec();
}

#include "main.moc"

代码解析

1. 创建按钮：
   • QPushButton *button1 = new QPushButton("Click Me", this); 创建第一个按钮，并设置其文本为 "Click Me"。
   • QPushButton *button2 = new QPushButton("Exit", this); 创建第二个按钮，并设置其文本为 "Exit"。
2. 连接信号与槽：
   • 使用 connect 方法将 button1 的 clicked() 信号连接到自定义槽 onButton1Click() 。当按钮被点击时，会执行相应的槽函数。
   • button2 的点击事件直接连接到 close 槽，以关闭窗口。
3. 显示信息框：
   • 在按钮 1 被点击时，使用 QMessageBox::information() 方法弹出一个信息框，提示用户按钮被点击。
4. 设置布局：
   • 使用 QVBoxLayout 布局管理器将按钮整齐排列。

运行结果：

示例2：

#include <QApplication>
#include <QWidget>
#include <QPushButton>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    QWidget widget;
    //设置 widget 窗口的标题
    widget.setWindowTitle("QWidget窗口");
    //创建一个按钮，并内嵌到 widget 窗口中
    QPushButton but("按钮",&widget);
    //按钮的位置位于距 widget 窗口左上角 (100,100) 的位置
    but.move(100,50);
    //设置按钮上文字的大小。
    but.setStyleSheet("QPushButton{font:20px;}");
    //调整按钮的尺寸
    but.resize(200,100);
    //建立信息和槽，当用户点击并释放按钮后，该按钮隐藏。
    QObject::connect(&but,&QPushButton::clicked,&but,&QPushButton::hide);

    widget.show();
    return a.exec();
}

运行结果：

QToolButton

QToolButton 是 Qt 中的一种按钮控件，它为用户提供了一种更灵活的方式来触发操作。与传统的 QPushButton 不同， QToolButton 主要用于工具栏或小型控件界面，通常用于展示图标和可选菜单。这种按钮特别适合在界面空间受限时使用，因为它的设计是为了占用更少的空间并提供多功能性。

主要特性

1. 显示图标：
   • QToolButton 主要用于显示图标而不是文本，可以使用 setIcon(const QIcon &icon) 方法来设置图标。
2. 下拉菜单：
   • 除了能够响应点击事件外，

QToolButton

还可以提供下拉菜单。使用

setPopupMode(QToolButton::PopupMode mode)

方法可以设置按钮的弹出类型，例如：

    * QToolButton::InstantPopup：点击按钮时立即显示下拉菜单。
    * QToolButton::DelayedPopup：悬停一段时间后显示下拉菜单。

3. 可选菜单项：
   • 在 QToolButton 下拉菜单中，可以添加多个操作选项，允许用户选择操作。
4. 样式：
   • QToolButton 允许通过样式表进行强化及定制，可以调整按钮的外观和行为以适应应用主题。
5. 启用/禁用：
   • 通过 setEnabled(bool) 方法可以启用或禁用按钮，禁用后用户无法进行点击。

示例：如何使用 QToolButton 创建一个工具按钮并响应点击事件，以及如何添加下拉菜单。

#include <QApplication>
#include <QWidget>
#include <QToolButton>
#include <QMenu>
#include <QVBoxLayout>
#include <QMessageBox>

class ToolButtonExample : public QWidget {
    Q_OBJECT

public:
    ToolButtonExample(QWidget *parent = nullptr) : QWidget(parent) {
        // 创建布局
        QVBoxLayout *layout = new QVBoxLayout(this);

        // 创建工具按钮
        QToolButton *toolButton = new QToolButton(this);
        toolButton->setIcon(QIcon::fromTheme("document-open")); // 设置图标
        toolButton->setToolTip("Open a document"); // 设置提示文本
        toolButton->setPopupMode(QToolButton::InstantPopup); // 设置为弹出模式

        // 创建下拉菜单
        QMenu *menu = new QMenu(this);
        menu->addAction("Action 1", this, &ToolButtonExample::action1);
        menu->addAction("Action 2", this, &ToolButtonExample::action2);
        toolButton->setMenu(menu); // 将菜单设置为工具按钮的菜单

        // 将按钮添加到布局
        layout->addWidget(toolButton);

        // 设置布局
        setLayout(layout);
        setWindowTitle("QToolButton Example");
    }

private slots:
    void action1() {
        QMessageBox::information(this, "Action", "You selected Action 1.");
    }

    void action2() {
        QMessageBox::information(this, "Action", "You selected Action 2.");
    }
};

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

    ToolButtonExample window;
    window.resize(200, 100);
    window.show();

    return app.exec();
}

#include "main.moc"

代码解析

1. 创建工具按钮：
   • QToolButton *toolButton = new QToolButton(this); 创建一个工具按钮并设置其父窗口。
   • 使用 setIcon(QIcon::fromTheme("document-open")); 设置按钮的图标。
2. 设置提示：
   • 使用 setToolTip("Open a document"); 方法为按钮设置说明，用户在鼠标悬停时显示。
3. 创建下拉菜单：
   • 使用 QMenu 创建一个菜单，并通过 addAction 方法添加菜单项。
   • 使用 setMenu(menu); 将菜单设置为按钮的下拉菜单。
4. 连接槽函数：
   • 将菜单项的点击事件连接到相应的槽函数 action1() 和 action2() ，在选择菜单项时显示相应的信息框。

运行结果：

QRadioButton

QRadioButton 是 Qt 中的一种控件，用于创建单选按钮（Radio Button）。单选按钮通常用于在多个互斥选项中让用户选择一个。只有一个单选按钮可以在同一组中被选中，因此一旦选择了新的选项，当前选择的按钮将自动取消选择。

主要特性

1. 互斥性：QRadioButton 的核心特点是互斥性。当一组单选按钮中选中一个，其他所有按钮会自动取消选择。
2. 分组：单选按钮通常以组的形式出现，可以使用 QButtonGroup 来管理一组 QRadioButton 。这可以帮助处理用户选择的逻辑。
3. 文本与图标：QRadioButton 可以同时显示文本和图标，可以使用 setText(const QString &text) 和 setIcon(const QIcon &icon) 来设置。
4. 状态：通过 isChecked() 方法可以检查选项是否被选中，而 setChecked(bool checked) 可以设置其状态。
5. 信号机制：QRadioButton 支持 Qt 的信号与槽机制，可以通过 toggled(bool checked) 信号捕捉用户的选中状态改变，从而执行相应的操作。

示例：如何使用 QRadioButton 控件，以及如何将其与 QButtonGroup 配合使用

#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>
#include <QRadioButton>
#include <QButtonGroup>
#include <QLabel>
#include <QMessageBox>

class RadioButtonExample : public QWidget {
    Q_OBJECT

public:
    RadioButtonExample(QWidget *parent = nullptr) : QWidget(parent) {
        
        // 创建布局
        QVBoxLayout *layout = new QVBoxLayout(this);
        
        // 创建标签
        label = new QLabel("Please select an option:", this);
        layout->addWidget(label);

        // 创建单选按钮
        QRadioButton *radio1 = new QRadioButton("Option 1", this);
        QRadioButton *radio2 = new QRadioButton("Option 2", this);
        QRadioButton *radio3 = new QRadioButton("Option 3", this);
        
        // 添加单选按钮到布局
        layout->addWidget(radio1);
        layout->addWidget(radio2);
        layout->addWidget(radio3);

        // 创建按钮组
        QButtonGroup *buttonGroup = new QButtonGroup(this);
        buttonGroup->addButton(radio1, 1);
        buttonGroup->addButton(radio2, 2);
        buttonGroup->addButton(radio3, 3);

        // 连接信号与槽
        connect(buttonGroup, &QButtonGroup::buttonClicked, this, &RadioButtonExample::onButtonClicked);
        
        // 设置初始选中
        radio1->setChecked(true);
        
        // 设置布局
        setLayout(layout);
        setWindowTitle("QRadioButton Example");
    }

private slots:
    void onButtonClicked(QAbstractButton *button) {
        QString selectedOption = button->text();
        label->setText("You selected: " + selectedOption);
    }

private:
    QLabel *label;
};

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

    RadioButtonExample window;
    window.resize(250, 150);
    window.show();

    return app.exec();
}

#include "main.moc"

代码解析

1. 创建布局：使用 QVBoxLayout 创建一个垂直布局，方便放置多个控件。
2. 创建单选按钮：使用 QRadioButton 创建多个单选按钮。
3. 创建按钮组：QButtonGroup 用于管理单选按钮的组，确保只有一个按钮可以被选中。使用 addButton() 方法将单选按钮添加到组中。
4. 信号连接：将 buttonClicked(int id) 信号连接到槽函数 onButtonClicked(QAbstractButton *button) ，当用户点击某个按钮时，该函数被调用。
5. 状态更新：槽函数会根据被点击的按钮更新标签的文本，显示用户选择的选项。

运行结果：

QCheckBox

QCheckBox 是 Qt 中的一种控件，用于创建复选框（Check Box）。与单选按钮不同，复选框允许用户在多个选项之间进行多重选择。用户可以选择多个复选框，也可以选择不选。

主要特性

1. 选择和取消选择：QCheckBox 可以单独控制选择状态，用户可以根据需要选中或取消选中复选框。
2. 三态状态：QCheckBox 支持三种状态：选中、未选中和部分选中（第三个状态通常用于表示父级复选框的子项中只有部分被选中）。通过设置 Qt::CheckState 可以实现这种状态。
3. 文本和图标：可以在复选框中显示文本和图标，使用 setText(const QString &text) 和 setIcon(const QIcon &icon) 方法来设置。
4. 信号机制：QCheckBox 支持 Qt 的信号与槽机制，通过 toggled(bool checked) 信号捕捉用户的选中状态改变，从而执行相应的操作。

示例：如何使用 QCheckBox 控件

#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>
#include <QCheckBox>
#include <QLabel>

class CheckBoxExample : public QWidget {
    Q_OBJECT

public:
    CheckBoxExample(QWidget *parent = nullptr) : QWidget(parent) {
        // 创建布局
        QVBoxLayout *layout = new QVBoxLayout(this);
        
        // 创建标签
        label = new QLabel("Select options:", this);
        layout->addWidget(label);

        // 创建复选框
        QCheckBox *checkBox1 = new QCheckBox("Option 1", this);
        QCheckBox *checkBox2 = new QCheckBox("Option 2", this);
        QCheckBox *checkBox3 = new QCheckBox("Option 3", this);

        // 添加复选框到布局
        layout->addWidget(checkBox1);
        layout->addWidget(checkBox2);
        layout->addWidget(checkBox3);

        // 连接信号与槽
        connect(checkBox1, &QCheckBox::toggled, this, &CheckBoxExample::updateLabel);
        connect(checkBox2, &QCheckBox::toggled, this, &CheckBoxExample::updateLabel);
        connect(checkBox3, &QCheckBox::toggled, this, &CheckBoxExample::updateLabel);

        // 设置布局
        setLayout(layout);
        setWindowTitle("QCheckBox Example");
    }

private slots:
    void updateLabel() {
        QString selectedOptions;
        
        // 更新选中的选项
        if (findChild<QCheckBox *>("Option 1")->isChecked()) {
            selectedOptions += "Option 1 ";
        }
        if (findChild<QCheckBox *>("Option 2")->isChecked()) {
            selectedOptions += "Option 2 ";
        }
        if (findChild<QCheckBox *>("Option 3")->isChecked()) {
            selectedOptions += "Option 3 ";
        }
        
        label->setText("Selected: " + selectedOptions);
    }

private:
    QLabel *label;
};

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

    CheckBoxExample window;
    window.resize(250, 150);
    window.show();

    return app.exec();
}

#include "main.moc"

代码解析

1. 创建布局：使用 QVBoxLayout 创建一个垂直布局，方便放置多个复选框。
2. 创建标签：初始化一个标签，用于显示所选择的选项。
3. 创建复选框：使用 QCheckBox 创建多个复选框，并添加到布局中。
4. 信号连接：将每个复选框的 toggled(bool checked) 信号连接到槽函数 updateLabel() ，当用户选中或取消选择复选框时，该函数被调用。
5. 状态更新：在 updateLabel() 槽函数中，检查每个复选框的状态并更新标签的文本，显示用户选择的选项。

运行结果：

QDialogButtonBox

QDialogButtonBox 是 Qt 6 中用于对话框的一种按钮容器，方便管理和组织标准的操作按钮，如 "OK"、"Cancel"、"Apply" 等。

主要特性

1. 按钮类型：可以自动生成常用的标准按钮，例如 QDialogButtonBox::Ok 、 QDialogButtonBox::Cancel 、 QDialogButtonBox::Apply 等。
2. 布局管理：通过灵活的布局方式，自动管理按钮的排列和外观。
3. 信号和槽：提供方便的信号，能够响应按钮的点击事件。
4. 自定义按钮：可以添加任意自定义按钮。

使用方法

1. 创建 QDialogButtonBox：实例化一个 QDialogButtonBox 对象。
2. 添加按钮：可以使用 addButton 方法添加自定义按钮，或使用 setStandardButtons 方法设置标准按钮。
3. 连接信号：连接按钮的点击信号到相应的槽函数。
4. 将按钮框添加到对话框中：通常将 QDialogButtonBox 添加到 QDialog 的布局中。

示例：如何使用 QDialogButtonBox

#include <QApplication>
#include <QDialog>
#include <QDialogButtonBox>
#include <QVBoxLayout>
#include <QLabel>

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

    QDialog dialog;
    dialog.setWindowTitle("Dialog with Button Box");

    // 创建一个布局
    QVBoxLayout *layout = new QVBoxLayout(&dialog);

    // 添加一个标签
    QLabel *label = new QLabel("Do you want to proceed?", &dialog);
    layout->addWidget(label);

    // 创建 QDialogButtonBox
    QDialogButtonBox *buttonBox = new QDialogButtonBox(&dialog);

    // 设置标准按钮
    buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
    
    // 连接信号和槽
    QObject::connect(buttonBox, &QDialogButtonBox::accepted, [&dialog]() {
        // 处理 OK 按钮
        dialog.accept();
    });
    QObject::connect(buttonBox, &QDialogButtonBox::rejected, [&dialog]() {
        // 处理 Cancel 按钮
        dialog.reject();
    });

    // 将按钮添加到布局
    layout->addWidget(buttonBox);
    
    dialog.setLayout(layout);

    dialog.exec();  // 显示对话框

    return app.exec();
}

代码解析

1. 创建 QApplication：标准的 Qt 应用程序初始化。
2. 创建 QDialog：定义我们的对话框，并设置窗口标题。
3. 布局：创建一个 QVBoxLayout 布局，将其设置为对话框的布局。
4. 添加 QLabel：在布局中添加一个标签，用于显示对话框内容。
5. 创建 QDialogButtonBox：
   • 使用 new QDialogButtonBox(&dialog) 创建按钮框。
   • 使用 setStandardButtons 方法添加 "OK" 和 "Cancel" 按钮。
6. 连接信号：
   • 将 accepted 信号连接到一个 lambda 函数，调用 dialog.accept() ，处理 OK 按钮的点击。
   • 将 rejected 信号连接到另一个 lambda 函数，调用 dialog.reject() ，处理 Cancel 按钮的点击。
7. 布局管理：将按钮框添加到布局中，最终布局会呈现两个按钮。
8. 显示对话框：通过调用 dialog.exec() 显示对话框，直到用户关闭它。

运行结果：

日期时间数据

处理日期时间数据

QTime

QTime 是 Qt 框架中的一个类，用于处理和表示时间。它使得时间的操作变得简单方便，包括获取当前时间、时间的加减、格式化输出等。 QTime 只关注时间的小时、分钟和秒，不涉及日期。

常用属性：

属性	描述
hour()	返回小时（0-23）。
minute()	返回分钟（0-59）。
second()	返回秒（0-59）。
msec()	返回毫秒（0-999）。
isValid()	检查时间是否有效。
addSecs(int)	增加指定的秒数并返回新的 QTime 对象。
setHMS()	设置小时、分钟和秒及可选的毫秒。
toString()	将时间转换为字符串，根据格式化字符串。

常用方法：

方法	描述
QTime()	默认构造函数，创建一个无效的时间对象。
QTime(int hour, int minute, int second = 0, int msec = 0)	使用指定的小时、分钟、秒和毫秒构造时间对象。
isValid()	检查时间是否有效（返回 true 或 false）。
hour()	返回当前时间的小时部分（0-23）。
minute()	返回当前时间的分钟部分（0-59）。
second()	返回当前时间的秒部分（0-59）。
msec()	返回当前时间的毫秒部分（0-999）。
setHMS(int hour, int minute, int second = 0, int msec = 0)	设置当前时间的小时、分钟、秒和毫秒。
addSecs(int seconds)	增加指定的秒数，并返回新的 QTime 对象。
secsTo(const QTime &time)	返回当前时间与指定时间之间的秒数。
toString(const QString &format)	将时间格式化为字符串，支持多种格式。
start()	记录当前时间，用于计时。
elapsed()	返回自 start() 调用以来经过的毫秒数。

示例：如何使用 QTime 类。

#include <QCoreApplication>
#include <QTime>
#include <QtDebug>

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

    // 创建一个 QTime 对象，表示 14:30:15
    QTime time(14, 30, 15);
    
    // 打印原始时间
    qDebug() << "Original time:" << time.toString("HH:mm:ss");

    // 获取当前时间
    QTime currentTime = QTime::currentTime();
    qDebug() << "Current time:" << currentTime.toString("HH:mm:ss");

    // 时间加操作
    QTime newTime = time.addSecs(3600); // 加一小时
    qDebug() << "Time after adding one hour:" << newTime.toString("HH:mm:ss");

    // 时间减操作
    newTime = time.addMSecs(-5000); // 减五秒
    qDebug() << "Time after subtracting five seconds:" << newTime.toString("HH:mm:ss");

    // 时间比较
    if (time < currentTime) {
        qDebug() << "The original time is earlier than the current time.";
    } else {
        qDebug() << "The original time is later than or equal to the current time.";
    }

    // 解析字符串为时间
    QTime parseTime = QTime::fromString("10:15:30", "HH:mm:ss");
    qDebug() << "Parsed time:" << parseTime.toString("HH:mm:ss");

    return a.exec();
}

代码解析

1. 创建 QTime 对象：使用 QTime time(14, 30, 15); 创建一个表示特定时间的对象，表示 14:30:15。
2. 获取当前时间：使用 QTime::currentTime() 方法获取当前系统时间。
3. 时间加法：使用 addSecs(3600) 方法将时间加一小时。
4. 时间减法：使用 addMSecs(-5000) 方法将时间减去五秒。
5. 时间比较：使用 < 运算符比较两个 QTime 对象。
6. 解析字符串：使用 fromString() 方法将字符串解析为 QTime 对象。

运行结果：

Original time: "14:30:15"
Current time: "20:44:25"
Time after adding one hour: "15:30:15"
Time after subtracting five seconds: "14:30:10"
The original time is earlier than the current time.
Parsed time: "10:15:30"

QDate

QDate 是 Qt 框架中的一个类，用于处理和表示日期。它提供了一些方便的方法来创建、比较、修改和格式化日期，同时也处理日期相关的计算，比如获取日期的开始和结束、计算日期之间的差异等。

常用属性：

属性	描述
year()	返回年份（4位数）
month()	返回月份（1-12）
day()	返回日期（1-31）
dayOfWeek()	返回星期几（1=星期一，7=星期天）
dayOfYear()	返回该年的第几天（1-366）
isValid()	检查日期是否有效（返回 true 或 false）
daysInMonth()	返回当前月份的天数

常用方法：

方法	描述
QDate()	默认构造函数，创建一个无效的日期对象
QDate(int year, int month, int day)	使用指定的年、月、日构造日期对象
isValid()	检查日期是否有效（返回 true 或 false）
year()	返回年份
month()	返回月份（1-12）
day()	返回日期（1-31）
daysInMonth()	返回当前月份的天数
addDays(int days)	增加指定的天数，并返回新的 QDate 对象
daysTo(const QDate &date)	返回当前日期与指定日期之间的天数
toString(const QString &format)	将日期格式化为字符串，支持多种格式
currentDate()	返回当前日期

示例：如何使用 QDate 类。

#include <QCoreApplication>
#include <QDate>
#include <QtDebug>

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

    // 创建一个 QDate 对象，表示 2023年10月25日
    QDate date(2023, 10, 25);
    qDebug() << "Original date:" << date.toString("yyyy-MM-dd");

    // 获取当前日期
    QDate currentDate = QDate::currentDate();
    qDebug() << "Current date:" << currentDate.toString("yyyy-MM-dd");

    // 日期加操作
    QDate newDate = date.addDays(30); // 加30天
    qDebug() << "Date after adding 30 days:" << newDate.toString("yyyy-MM-dd");

    // 日期减操作
    newDate = date.addMonths(-2); // 减2个月
    qDebug() << "Date after subtracting 2 months:" << newDate.toString("yyyy-MM-dd");

    // 日期比较
    if (date < currentDate) {
        qDebug() << "The original date is earlier than the current date.";
    } else {
        qDebug() << "The original date is later than or equal to the current date.";
    }

    // 解析字符串为日期
    QDate parseDate = QDate::fromString("2023-10-01", "yyyy-MM-dd");
    qDebug() << "Parsed date:" << parseDate.toString("yyyy-MM-dd");

    // 计算日期差异
    int daysDifference = date.daysTo(currentDate);
    qDebug() << "Days difference to current date:" << daysDifference;

    return a.exec();
}

代码解析

1. 创建 QDate 对象：使用 QDate date(2023, 10, 25); 创建一个表示特定日期的对象，表示 2023年10月25日。
2. 获取当前日期：使用 QDate::currentDate() 方法获取当前系统日期。
3. 日期加法：使用 addDays(30) 方法将日期加30天。
4. 日期减法：使用 addMonths(-2) 方法将日期减去2个月。
5. 日期比较：使用 < 运算符比较两个 QDate 对象。
6. 解析字符串：使用 fromString() 方法将字符串解析为 QDate 对象。
7. 计算日期差异：使用 daysTo() 方法计算两个日期之间的天数差异。

运行结果：

Original time: "14:30:15"
Current time: "20:44:25"
Time after adding one hour: "15:30:15"
Time after subtracting five seconds: "14:30:10"
The original time is earlier than the current time.
Parsed time: "10:15:30"

QDateTime

QDateTime 是 Qt 框架中用于处理和表示日期和时间的类。它结合了 QDate 和 QTime 的功能，提供了一种简单而灵活的方式来管理和计算日期和时间。

主要特性

1. 表示日期和时间：QDateTime 用于表示特定的日期和时间。它可以存储从公元 1970 年 1 月 1 日至 9999 年的日期时间。
2. 获取当前日期时间：可以使用静态方法 currentDateTime() 获取当前系统的日期和时间。
3. 日期时间比较：提供了比较不同 QDateTime 对象的功能，例如 QDateTime::operator==() 、 QDateTime::operator<() 等。
4. 日期时间计算：提供多种方法用于日期和时间的加减，比如 addDays(int days) 、 addSecs(int seconds) 和 addMSecs(int msecs) 。
5. 格式化输出：可以使用 toString(const QString &format) 方法以指定格式输出日期和时间。
6. 解析字符串为日期时间：可以使用 fromString(const QString &dateTimeString, const QString &format) 方法将字符串解析为 QDateTime 对象。
7. 时区处理：QDateTime 支持时区，可以使用 setTimeSpec(Qt::TimeZone) 方法设置时区，并通过 QTimeZone 处理不同的时区。

示例：如何使用 QDateTime 类

#include <QCoreApplication>
#include <QDateTime>
#include <QtDebug>

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

    // 创建一个 QDateTime 对象，表示 2023年10月25日 14:30:15
    QDateTime dateTime(QDate(2023, 10, 25), QTime(14, 30, 15));
    qDebug() << "Original date and time:" << dateTime.toString("yyyy-MM-dd HH:mm:ss");

    // 获取当前日期和时间
    QDateTime currentDateTime = QDateTime::currentDateTime();
    qDebug() << "Current date and time:" << currentDateTime.toString("yyyy-MM-dd HH:mm:ss");

    // 日期时间加操作
    QDateTime newDateTime = dateTime.addDays(30); // 加30天
    qDebug() << "Date and time after adding 30 days:" << newDateTime.toString("yyyy-MM-dd HH:mm:ss");

    // 日期时间减操作
    newDateTime = dateTime.addSecs(-3600); // 减1小时
    qDebug() << "Date and time after subtracting 1 hour:" << newDateTime.toString("yyyy-MM-dd HH:mm:ss");

    // 日期时间比较
    if (dateTime < currentDateTime) {
        qDebug() << "The original date and time is earlier than the current date and time.";
    } else {
        qDebug() << "The original date and time is later than or equal to the current date and time.";
    }

    // 解析字符串为日期时间
    QDateTime parsedDateTime = QDateTime::fromString("2023-10-01 12:00:00", "yyyy-MM-dd HH:mm:ss");
    qDebug() << "Parsed date and time:" << parsedDateTime.toString("yyyy-MM-dd HH:mm:ss");

    // 计算日期时间差异
    qint64 secondsDifference = dateTime.secsTo(currentDateTime);
    qDebug() << "Seconds difference to current date and time:" << secondsDifference;

    return a.exec();
}

代码解析

1. 创建 QDateTime 对象：使用 QDateTime dateTime(QDate(2023, 10, 25), QTime(14, 30, 15)); 创建一个表示特定日期和时间的对象。
2. 获取当前日期和时间：使用 QDateTime::currentDateTime() 方法获取当前系统日期和时间。
3. 日期时间加法：使用 addDays(30) 方法将日期时间加30天。
4. 日期时间减法：使用 addSecs(-3600) 方法将日期时间减去一小时。
5. 日期时间比较：使用 < 运算符比较两个 QDateTime 对象。
6. 解析字符串：使用 fromString() 方法将字符串解析为 QDateTime 对象。
7. 计算日期时间差异：使用 secsTo() 方法计算两个 QDateTime 之间的秒数差异。

运行结果：

Original date and time: "2023-10-25 14:30:15"
Current date and time: "2025-01-23 20:45:42"
Date and time after adding 30 days: "2023-11-24 14:30:15"
Date and time after subtracting 1 hour: "2023-10-25 13:30:15"
The original date and time is earlier than the current date and time.
Parsed date and time: "2023-10-01 12:00:00"
Seconds difference to current date and time: 39420927

日期时间数据界面

QDateEdit

QDateEdit 是 Qt 框架中用于处理日期输入的一个小部件（widget）。它允许用户通过文本框输入日期，同时提供一个可选择的日历。这使得用户可以方便地选择或手动输入日期，适用于各种需要用户选择日期的场景，如表单、设定、日历等。

主要特性

1. 日期格式：QDateEdit 支持自定义日期格式，可以根据需要设置日期的显示格式。用户输入的日期会自动解析为正确的格式。
2. 日历选择：提供一个下拉日历控件，用户可以通过点击日历图标选择日期。这使得用户选择日期更为直观和方便。
3. 数据验证：QDateEdit 可以进行数据验证，确保用户输入的日期是有效的。若用户输入无效日期，控件可以给出反馈。
4. 可选择时间：在具有时间选择功能的情况下， QDateEdit 也可以显示时间（即 QDateTimeEdit ），可以选择具体的时分秒。
5. 限制日期范围：可以通过 setMinimumDate() 和 setMaximumDate() 方法来限制用户可选择的日期范围。
6. 信号和槽：QDateEdit 发送诸多信号，例如 dateChanged(const QDate &date) 信号，方便开发者响应用户的输入行为。

示例：如何使用 QDateEdit 小部件

#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>
#include <QDateEdit>
#include <QLabel>
#include <QDate>
#include <QtDebug>

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

    QWidget window;
    window.setWindowTitle("QDateEdit Example");

    QVBoxLayout *layout = new QVBoxLayout();

    // 创建 QDateEdit 小部件
    QDateEdit *dateEdit = new QDateEdit();
    dateEdit->setDate(QDate::currentDate()); // 设置当前日期
    dateEdit->setDisplayFormat("yyyy-MM-dd"); // 设置日期格式
    dateEdit->setMinimumDate(QDate(2000, 1, 1)); // 设置最小日期
    dateEdit->setMaximumDate(QDate(2100, 12, 31)); // 设置最大日期

    // 创建一个标签用于显示用户选择的日期
    QLabel *label = new QLabel();
    label->setText("Selected Date: " + dateEdit->date().toString("yyyy-MM-dd"));

    // 连接信号和槽
    QObject::connect(dateEdit, &QDateEdit::dateChanged, [&label](const QDate &date) {
        label->setText("Selected Date: " + date.toString("yyyy-MM-dd"));
    });

    // 将小部件添加到布局中
    layout->addWidget(dateEdit);
    layout->addWidget(label);
    window.setLayout(layout);

    window.show();
    return app.exec();
}

代码解析

1. 创建 QDateEdit 小部件：使用 new QDateEdit() 创建一个日期编辑控件，并设置其初始日期为当前日期。
2. 设置日期格式：使用 setDisplayFormat("yyyy-MM-dd") 设置日期的显示格式为"年-月-日"。
3. 设置日期范围：通过 setMinimumDate() 和 setMaximumDate() 方法限制用户选择的日期范围。
4. 连接信号和槽：连接 QDateEdit::dateChanged 信号到一个槽函数，当用户选择新日期时更新标签显示。
5. 布局：使用 QVBoxLayout 布局将 QDateEdit 和标签添加到窗口中。

运行结果：

QTimeEdit

QTimeEdit 是 Qt 框架中用于时间输入的一个小部件。它允许用户通过文本框手动输入时间，同时提供了一个可选择的时间的下拉弹窗，用户可以方便地设置小时和分钟。 QTimeEdit 主要用于那些需要精确时间输入的应用场景，如闹钟、日程安排、表单等。

主要特性

• 时间格式：QTimeEdit 支持自定义时间格式，允许开发者指定时间的显示方式，例如 24 小时制或 12 小时制。
• 时间选择界面：提供下拉时间选择界面，用户可以通过点击箭头按钮选择时间，避免手动输入错误。
• 数据验证：QTimeEdit 自动验证用户输入的时间。如果输入的时间不合法，控件会给出视觉上的反馈，确保用户输入的正确性。
• 限制时间范围：可以通过 setMinimumTime() 和 setMaximumTime() 方法限制用户可选择的时间范围。
• 信号和槽机制：QTimeEdit 支持信号和槽机制，能够在时间改变时发出信号，便于开发者做出相应反应。

示例：

#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>
#include <QTimeEdit>
#include <QLabel>
#include <QtDebug>

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

    QWidget window;
    window.setWindowTitle("QTimeEdit Example");

    QVBoxLayout *layout = new QVBoxLayout();

    // 创建 QTimeEdit 小部件
    QTimeEdit *timeEdit = new QTimeEdit();
    timeEdit->setTime(QTime::currentTime()); // 设置当前时间
    timeEdit->setDisplayFormat("hh:mm:ss"); // 设置时间格式
    timeEdit->setMinimumTime(QTime(0, 0)); // 设置最小时间
    timeEdit->setMaximumTime(QTime(23, 59)); // 设置最大时间

    // 创建一个标签用于显示用户选择的时间
    QLabel *label = new QLabel();
    label->setText("Selected Time: " + timeEdit->time().toString("hh:mm:ss"));

    // 连接信号和槽
    QObject::connect(timeEdit, &QTimeEdit::timeChanged, [&label](const QTime &time) {
        label->setText("Selected Time: " + time.toString("hh:mm:ss"));
    });

    // 将小部件添加到布局中
    layout->addWidget(timeEdit);
    layout->addWidget(label);
    window.setLayout(layout);

    window.show();
    return app.exec();
}

代码解析

1. 创建 QTimeEdit 小部件：使用 new QTimeEdit() 创建一个时间编辑控件，并设置其初始时间为当前时间。
2. 设置时间格式：使用 setDisplayFormat("hh:mm:ss") 设置时间的显示格式为"时:分:秒"。
3. 设置时间范围：通过 setMinimumTime() 和 setMaximumTime() 方法限制用户选择的时间范围，确保输入的时间为有效时间。
4. 连接信号和槽：连接 QTimeEdit::timeChanged 信号到一个槽函数，当用户选择新时间时更新标签显示。
5. 布局：使用 QVBoxLayout 布局将 QTimeEdit 和标签添加到窗口中。

运行结果：

QDateTimeEdit

QDateTimeEdit 是 Qt 框架中用于同时处理日期和时间输入的小部件。它结合了 QDateEdit 和 QTimeEdit 的特性，允许用户通过文本框输入日期和时间，并提供一个可选择的日历和时间选择界面。这使得用户能够方便地选择或手动输入日期和时间，适用于许多需要同时选择日期和时间的应用，例如日历、事件计划、定时任务等。

主要特性

• 日期和时间格式：QDateTimeEdit 允许设置日期和时间的显示格式，可以根据需要自定义格式，比如"yyyy-MM-dd hh:mm:ss"等。
• 日历和时间选择：组合了日期选择小部件和时间选择小部件，用户可以通过点击图标选择日期和时间。
• 数据验证：自动对用户输入的日期和时间进行验证，确保输入的值是有效的。
• 限制日期和时间范围：可以通过 setMinimumDateTime() 和 setMaximumDateTime() 方法限制用户可选择的日期和时间范围。
• 信号和槽机制：QDateTimeEdit 支持信号与槽机制，能在日期或时间改变时发出信号，方便开发者做出相应的处理。

示例：

#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>
#include <QDateTimeEdit>
#include <QLabel>
#include <QDateTime>

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

    QWidget window;
    window.setWindowTitle("QDateTimeEdit Example");

    QVBoxLayout *layout = new QVBoxLayout();

    // 创建 QDateTimeEdit 小部件
    QDateTimeEdit *dateTimeEdit = new QDateTimeEdit();
    dateTimeEdit->setDateTime(QDateTime::currentDateTime()); // 设置当前日期和时间
    dateTimeEdit->setDisplayFormat("yyyy-MM-dd hh:mm:ss"); // 设置日期和时间格式
    dateTimeEdit->setMinimumDateTime(QDateTime(QDate(2000, 1, 1), QTime(0, 0))); // 设置最小日期时间
    dateTimeEdit->setMaximumDateTime(QDateTime(QDate(2100, 12, 31), QTime(23, 59))); // 设置最大日期时间

    // 创建一个标签用于显示用户选择的日期和时间
    QLabel *label = new QLabel();
    label->setText("Selected DateTime: " + dateTimeEdit->dateTime().toString("yyyy-MM-dd hh:mm:ss"));

    // 连接信号和槽
    QObject::connect(dateTimeEdit, &QDateTimeEdit::dateTimeChanged, [&label](const QDateTime &dateTime) {
        label->setText("Selected DateTime: " + dateTime.toString("yyyy-MM-dd hh:mm:ss"));
    });

    // 将小部件添加到布局中
    layout->addWidget(dateTimeEdit);
    layout->addWidget(label);
    window.setLayout(layout);

    window.show();
    return app.exec();
}

代码解析

1. 创建 QDateTimeEdit 小部件：使用 new QDateTimeEdit() 创建一个日期时间编辑控件，并设置其初始值为当前日期和时间。
2. 设置日期和时间格式：使用 setDisplayFormat("yyyy-MM-dd hh:mm:ss") 设置日期和时间的显示格式。
3. 设置日期和时间范围：通过 setMinimumDateTime() 和 setMaximumDateTime() 方法限制用户选择的日期和时间范围，确保输入的日期时间是有效的。
4. 连接信号和槽：连接 QDateTimeEdit::dateTimeChanged 信号到一个槽函数，当用户选择新日期和时间时更新标签显示。
5. 布局：使用 QVBoxLayout 布局将 QDateTimeEdit 和标签添加到窗口中。

运行结果：

QCalendarWidget

QCalendarWidget 是 Qt 框架中的一个小部件，用于显示和选择日期。它为用户提供了一个月历视图，用户可以通过点击日期来选择特定的日期。这个控件非常适合用于需要日期选择的应用，比如日程安排、活动创建、预约系统等。

主要特性

1. 可视化的日期选择：QCalendarWidget 显示一个月的日历，并允许用户通过直观的界面选择日期。
2. 支持多种日期选择模式：用户可以选择单个日期，或者通过设置多选模式来选择一系列日期。
3. 自定义显示：可以自定义显示的日期格式和当前日期的高亮显示样式。
4. 信号和槽机制：支持 Qt 的信号与槽机制，可以在用户选择日期时捕获相关事件，并执行相应的动作。
5. 显示时间范围：可以通过设置最小和最大日期来限制用户可选择的日期范围。

示例：

#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>
#include <QCalendarWidget>
#include <QLabel>
#include <QDate>

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

    QWidget window;
    window.setWindowTitle("QCalendarWidget Example");

    QVBoxLayout *layout = new QVBoxLayout();

    // 创建 QCalendarWidget 小部件
    QCalendarWidget *calendar = new QCalendarWidget();
    calendar->setGridVisible(true); // 设置网格可见
    calendar->setMinimumDate(QDate(2000, 1, 1)); // 设置最小日期
    calendar->setMaximumDate(QDate(2100, 12, 31)); // 设置最大日期

    // 创建标签用于显示用户选择的日期
    QLabel *label = new QLabel("Selected Date: ");

    // 连接信号和槽
    QObject::connect(calendar, &QCalendarWidget::clicked, [&label](const QDate &date) {
        label->setText("Selected Date: " + date.toString("yyyy-MM-dd"));
    });

    // 将小部件添加到布局中
    layout->addWidget(calendar);
    layout->addWidget(label);
    window.setLayout(layout);

    window.show();
    return app.exec();
}

代码解析

1. 创建 QCalendarWidget 小部件：使用 new QCalendarWidget() 创建一个日历控件，并设置网格线可见，增强可视性。
2. 设置日期范围：使用 setMinimumDate() 和 setMaximumDate() 方法来限制用户可以选择的日期范围。
3. 连接信号与槽：连接 QCalendarWidget::clicked 信号到一个槽函数，在用户选择日期时更新标签显示所选日期。
4. 布局：使用 QVBoxLayout 布局将 QCalendarWidget 和标签添加到主窗口中。

运行结果：

定时器

QTimer

QTimer 是 Qt 框架中用于定时操作的类，它提供了一种简单的方式来执行周期性或延迟的任务。通过 QTimer，开发者可以在指定的时间间隔后执行特定的操作，或者按照一定的时间周期重复执行操作。这在许多应用场景中非常有用，如动画更新、轮询机制、定时器控制等。

主要特性

1. 定时功能：QTimer 可以设置一个定时器，在指定的毫秒数后发出一个信号。
2. 单次或重复定时：可以选择将定时器设置为单次定时（一次性）或重复定时（周期性），通过 setSingleShot() 方法进行配置。
3. 信号与槽机制：当定时器到达设置的时间后，会发出 timeout() 信号，开发者可以连接这个信号到任意槽函数，以执行相应的操作。
4. 线程安全：QTimer 可以在任何线程中使用，但其信号发射和接收通常在主线程中执行，因此通常建议在主线程中创建和使用 QTimer 。
5. 暂停和恢复：可以通过 stop() 和 start() 方法暂停和恢复定时器的计时。

示例：

#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>
#include <QLabel>
#include <QTimer>

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

    QWidget window;
    window.setWindowTitle("QTimer Example");

    QVBoxLayout *layout = new QVBoxLayout();

    // 创建一个标签，用于显示计时信息
    QLabel *label = new QLabel("Timer not started");

    // 创建 QTimer 对象
    QTimer *timer = new QTimer();

    // 连接定时器的 timeout 信号到标签更新的槽
    QObject::connect(timer, &QTimer::timeout, [&label]() {
        static int count = 0;
        count++;
        label->setText("Timer timeout! Count: " + QString::number(count));
    });

    // 启动定时器
    timer->start(1000); // 每隔1000毫秒（1秒）触发一次

    // 将小部件添加到布局中
    layout->addWidget(label);
    window.setLayout(layout);

    window.show();
    return app.exec();
}

代码解析

1. 创建 QTimer 对象：使用 new QTimer() 创建一个定时器对象。
2. 连接信号与槽：将 QTimer::timeout 信号连接到一个槽函数，其中更新标签显示的内容。每当定时器超时时（每隔1秒），就会执行该槽函数。
3. 启动定时器：使用 start(1000) 方法启动定时器，设置计时间隔为1000毫秒（即1秒）。
4. 布局：使用 QVBoxLayout 将标签添加到主窗口中。

运行结果：

QElapsedTimer

QElapsedTimer 是 Qt 框架中的一个类，用于测量经过的时间。它提供了一种简单而高效的方式来计算代码段的执行时间或分析性能。与其他计时类不同， QElapsedTimer 主要用于高精度的时间测量，而不是用于创建定时器或发出信号。

主要特性

• 高精度计时：QElapsedTimer 提供高精度的时间测量，适用于需要精确计时的场景，如性能分析和基准测试。
• 简单易用：该类的接口设计简单，使用直观，便于开发者快速集成到项目中。
• 使用纳秒精度：QElapsedTimer 可以以毫秒、秒或纳秒为单位返回经过的时间，适用于多种测量需求。
• 支持多线程：QElapsedTimer 可以在多线程环境中安全使用，计时和测量是线程安全的。

示例：

#include <QCoreApplication>
#include <QElapsedTimer>
#include <QDebug>
#include <thread>

void performLongTask() {
    // 模拟一个耗时的任务
    std::this_thread::sleep_for(std::chrono::seconds(2));
}

int main(int argc, char *argv[]) {
    QCoreApplication app(argc, argv);
    
    QElapsedTimer timer;  // 创建 QElapsedTimer 对象
    timer.start();  // 开始计时
    
    performLongTask();  // 执行长时间任务

    qint64 elapsed = timer.elapsed();  // 获取经过的时间（毫秒）
    
    qDebug() << "Elapsed time:" << elapsed << "milliseconds";  // 输出经过的时间

    return 0;
}

代码解析

1. 创建 QElapsedTimer 对象：使用 QElapsedTimer timer; 创建一个计时器对象。
2. 开始计时：通过 timer.start(); 方法开始计时，这会记录当前的时间点。
3. 执行耗时任务：在示例中， performLongTask() 函数模拟了一个耗时的操作，它使当前线程休眠2秒。
4. 获取经过的时间：使用 timer.elapsed(); 方法获取自开始计时以来经过的时间（以毫秒为单位）。
5. 输出结果：使用 qDebug() 输出经过的时间到控制台。

运行结果：

Elapsed time: 2010 milliseconds

下拉列表框

QComboBox

QComboBox 是 Qt 框架中的一个控件，提供了一个下拉列表，用户可以从中选择一个项目。它结合了文本框和列表框的功能，允许用户直接在文本框中输入或从提供的下拉列表中选择一个值，常用于数据输入、过滤和设置选项的场景。

主要特性

• 下拉列表：QComboBox 提供了一个可下拉的列表，其中包含用户可选择的项目。
• 用户输入：用户可以直接在文本框中输入值，如果当前文本未在列表中，仍然可以提交。
• 方便的项目管理：提供方法添加、插入、删除、获取项目，以及清空列表等操作。
• 可自定样式：通过样式表， QComboBox 可以应用自定义样式，以满足不同应用的界面需求。
• 支持图标和文本：可以在下拉列表中显示带有图标的项目，增强用户界面的可读性和美观性。
• 信号与槽机制：当用户选择不同的项目时，会发出 currentIndexChanged 信号，可以连接到处理函数来响应用户的选择。

示例：

#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>
#include <QComboBox>
#include <QLabel>

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

    QWidget window;
    window.setWindowTitle("QComboBox Example");

    QVBoxLayout *layout = new QVBoxLayout();

    // 创建 QComboBox 对象
    QComboBox *comboBox = new QComboBox();
    
    // 添加项目
    comboBox->addItem("Option 1");
    comboBox->addItem("Option 2");
    comboBox->addItem("Option 3");

    // 创建 QLabel 用于显示选择的信息
    QLabel *label = new QLabel("Selected Option: ");

    // 连接信号和槽
    QObject::connect(comboBox, &QComboBox::currentIndexChanged, [&label, comboBox](int index) {
        label->setText("Selected Option: " + comboBox->itemText(index));
    });

    // 将 QComboBox 和 QLabel 添加到布局中
    layout->addWidget(comboBox);
    layout->addWidget(label);

    window.setLayout(layout);
    window.show();

    return app.exec();
}

代码解析

1. 创建 QComboBox 对象：使用 new QComboBox() 创建一个下拉框控件。
2. 添加项目：通过 addItem() 方法向组合框中添加多个选项。
3. 创建 QLabel：创建一个标签，用于显示当前选中的选项。
4. 连接信号与槽：将 currentIndexChanged 信号与一个匿名槽函数连接，以更新标签的显示内容。每当用户选择不同的选项时，标签内容将自动更新。
5. 布局：使用 QVBoxLayout 将 QComboBox 和 QLabel 添加到主窗口中。

运行结果：

界面窗口组件

QMainWindow

• QMainWindow是Qt框架中的主窗口类。
• QMainWindow具有菜单栏、工具栏、状态栏等主窗口常见的界面元素。

QAction类

• QAction是用于设计主窗口上的菜单栏、工具栏、按钮的下拉菜单、组件的快捷菜单等的重要类。
• QAction对象代表实现某个功能的"动作"，称为Action。
• 在UI可视化设计时，可以设计多个Action，然后用这些Action创建菜单项和工具按钮。

QMainWindow

QMainWindow 是 Qt 框架中的一个类，用于创建主应用窗口。它是一个功能强大的窗口部件，提供了许多标准界面元素，如菜单栏、工具栏、状态栏和中心区域，方便开发者快速构建复杂的桌面应用程序。

主要特性：

特性	描述	方法/功能
中心区域	允许开发者设置一个中心部件，作为主工作区域。	通过 setCentralWidget() 方法指定中心部件。例如 QTextEdit、QPlainTextEdit 或其他 QWidget 的子类。
菜单栏	提供窗口的顶部菜单栏，用于组织菜单项。	可以创建多个菜单项，并使用 QAction 来定义每个功能的动作。
工具栏	用于放置常用的操作按钮，提供快速访问功能。	通过 addToolBar() 方法添加多个工具栏，并添加 QAction 对象作为工具按钮。
状态栏	显示应用程序的状态信息。	通过 statusBar() 方法获取状态栏的指针，然后在其中显示文本或进度条等。
停靠窗口	创建可停靠的窗口，用户可以根据需要停靠在主窗口的不同位置。	使用 QDockWidget 来创建可停靠的窗口。
支持布局	允许在各个区域内使用布局管理器来组织部件的显示。	在中心区域或其他自定义区域使用布局管理器如 QHBoxLayout、QVBoxLayout 等。

示例：

#include <QApplication>
#include <QMainWindow>
#include <QMenuBar>
#include <QToolBar>
#include <QAction>
#include <QTextEdit>

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

    // 创建 QMainWindow 对象
    QMainWindow mainWindow;
    mainWindow.setWindowTitle("Simple Text Editor");

    // 创建中心部件并设置为一个 QTextEdit
    QTextEdit *textEdit = new QTextEdit;
    mainWindow.setCentralWidget(textEdit);

    // 创建菜单栏
    QMenuBar *menuBar = mainWindow.menuBar();
    QMenu *fileMenu = menuBar->addMenu("File");

    // 创建菜单项
    QAction *newAction = new QAction("New", &mainWindow);
    fileMenu->addAction(newAction);

    QAction *openAction = new QAction("Open", &mainWindow);
    fileMenu->addAction(openAction);

    QAction *saveAction = new QAction("Save", &mainWindow);
    fileMenu->addAction(saveAction);

    // 创建工具栏
    QToolBar *toolBar = mainWindow.addToolBar("Main Toolbar");
    toolBar->addAction(newAction);
    toolBar->addAction(openAction);
    toolBar->addAction(saveAction);

    // 显示主窗口
    mainWindow.resize(800, 600);
    mainWindow.show();

    return app.exec();
}

代码解析

1. 创建 QMainWindow 对象：通过 QMainWindow mainWindow; 创建主窗口对象。
2. 设置中心部件：创建并设置 QTextEdit 作为中心工作区，用户将在此处输入文本。
3. 创建菜单栏：使用 menuBar() 方法获取菜单栏，并添加一个 "File" 菜单。
4. 创建 QAction 对象：创建新建、打开和保存的操作，使用 QAction 对象来实现功能，并将这些操作添加到菜单和工具栏中。
5. 创建工具栏：通过 addToolBar() 方法添加工具栏，并将之前创建的 QAction 添加到工具栏中，方便用户快速访问。
6. 显示主窗口：设置窗口大小并调用 show() 方法显示窗口，最后进入应用程序的事件循环。

运行结果：

QAction

QAction 是 Qt 框架中定义用户界面动作的类。

• 代表一个特定的操作或行为，比如菜单项、工具栏按钮或快捷键操作。
• 使用 QAction ，开发者可以将同一动作关联到多个 UI 元素，无需重复代码，同时实现一致的功能和外观。

主要特性：

特点	描述
多功能性	QAction 可用于菜单、工具栏、上下文菜单（右键菜单）等多个界面元素。
状态管理	QAction 可以具有不同的状态，如启用、禁用、选中，以及可以显示图标和文本。
信号与槽机制	QAction 使用 Qt 的信号与槽机制，方便连接到执行动作的任意函数或方法上。
快捷键支持	可以为每个 QAction 设置键盘快捷键，快速触发相应动作。
图标和提示	可以为 QAction 设置图标和工具提示，改善用户界面的可用性。

常用方法：

方法/属性名称	描述
setText()	用于设置动作在用户界面上显示的文本内容。
setIcon()	用于设置动作显示的图标，以便用户在用户界面上更容易识别。
setShortcut()	用于设置触发动作的快捷键组合。
setEnabled()	通过此方法可以启用或禁用动作，使其变为可点击或不可点击状态。
setCheckable()	允许用户选中或取消选中该动作，常用于表示动作的开关状态。
triggered()	当动作被用户触发（例如点击按钮）时，会发出此信号。

示例：如何使用 QAction 类创建一个简单的菜单项和工具按钮，它们会执行相同的操作。

#include <QApplication>
#include <QMainWindow>
#include <QMenuBar>
#include <QToolBar>
#include <QAction>
#include <QMessageBox>

class MainWindow : public QMainWindow {
    Q_OBJECT

public:
    MainWindow() {
        // 创建 "About" 动作
        QAction *aboutAction = new QAction("About", this);
        connect(aboutAction, &QAction::triggered, this, &MainWindow::showAboutDialog);

        // 创建菜单栏
        QMenu *helpMenu = menuBar()->addMenu("Help");
        helpMenu->addAction(aboutAction);

        // 创建工具栏
        QToolBar *toolBar = addToolBar("Main Toolbar");
        toolBar->addAction(aboutAction);
    }

private slots:
    void showAboutDialog() {
        QMessageBox::information(this, "About", "This is a sample application using QAction.");
    }
};

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

    MainWindow mainWindow;
    mainWindow.setWindowTitle("QAction Example");
    mainWindow.resize(400, 300);
    mainWindow.show();

    return app.exec();
}

#include "main.moc"

代码解析

1. 创建 QAction 对象：通过 new QAction("About", this); 创建一个名为 "About" 的动作。
2. 连接信号和槽：使用 connect() 方法将动作的 triggered() 信号连接到槽 showAboutDialog() ，以便在用户选择该动作时执行相应的代码。
3. 添加到菜单和工具栏：将该动作添加到菜单栏的 "Help" 菜单和工具栏中。
4. 显示对话框：在 showAboutDialog() 槽中，使用 QMessageBox::information() 显示关于对话框。

运行结果：

QStatusBar

QStatusBar 是 Qt 框架中用于显示状态信息的类，通常位于应用程序主窗口的底部。

• 主要用于提供应用程序当前状态、操作的反馈或其他重要信息。
• QStatusBar 的内容可以动态更新，因此它非常适合在用户与应用程序交互时提供实时反馈。

主要特性：

特性	描述
动态信息展示	QStatusBar 可以显示多种信息，从简单的文本到复杂的进度条，能够根据应用程序的运行状态进行更新。
支持多部件	可以在状态栏中添加多个部件，如文本、图标、进度条或其他 QWidget 的子类，这些部件可以以不同的方式排列。
自定义信息	QStatusBar 支持显示简单的文本消息、特定信息，如操作进度或状态提示。开发者可以根据需要自定义显示内容。
简易的布局管理	状态栏自动管理内部部件的位置和大小，开发者只需关注添加和更新内容，无需处理复杂的布局问题。

常用方法：

方法/函数名称	详细说明
showMessage()	调用此方法可以在状态栏上显示一条消息，并可以设置显示的持续时间。
addPermanentWidget()	使用此方法可以在状态栏的永久位置添加一个不会消失的小部件，如进度条等。
addWidget()	通过此方法添加的小部件不是永久性的，它们会被自动管理，并在一段时间后消失。
clearMessage()	调用此方法可以清除状态栏上当前显示的消息。

示例：使用 QStatusBar 来显示一些状态信息。

#include <QApplication>
#include <QMainWindow>
#include <QStatusBar>
#include <QAction>
#include <QMessageBox>
#include <QToolBar>
#include <QPushButton>

class MainWindow : public QMainWindow {
    Q_OBJECT

public:
    MainWindow() {
        // 创建状态栏
        QStatusBar *statusBar = new QStatusBar(this);
        setStatusBar(statusBar);
        
        // 创建菜单和工具栏
        QAction *aboutAction = new QAction("About", this);
        connect(aboutAction, &QAction::triggered, this, &MainWindow::showAboutDialog);
        
        QToolBar *toolBar = addToolBar("Main Toolbar");
        toolBar->addAction(aboutAction);

        // 设置初始状态信息
        statusBar->showMessage("Welcome to the application!", 5000); // 显示5秒
        statusBar->addPermanentWidget(new QPushButton("Info")); // 添加一个按钮
    }

private slots:
    void showAboutDialog() {
        QMessageBox::information(this, "About", "This is a sample application using QStatusBar.");
        statusBar()->showMessage("About dialog shown.", 2000); // 显示状态信息
    }
};

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

    MainWindow mainWindow;
    mainWindow.setWindowTitle("QStatusBar Example");
    mainWindow.resize(400, 300);
    mainWindow.show();

    return app.exec();
}

#include "main.moc"

代码解析

1. 创建 QStatusBar ：在构造函数中，通过 setStatusBar() 设置一个 QStatusBar 作为窗口的状态栏。
2. 显示初始消息：使用 showMessage("Welcome to the application!", 5000); 在状态栏上显示一条欢迎信息，持续5秒。
3. 添加永久部件：使用 addPermanentWidget() 方法将一个 QPushButton 添加到状态栏，允许用户进行操作。
4. 连接信号和槽：将 "About" 动作连接到 showAboutDialog() 插槽，当用户选择该动作时会弹出对话框，并更新状态栏中的消息。
5. 清晰的用户反馈：当显示对话框时，使用 statusBar()->showMessage("About dialog shown.", 2000); 更新状态栏，让用户知道状态发生了变化。

运行结果：

%5Cimage-20250123170110633.png&pos_id=img-iRCj7Fku-1779019229710)

QListWidget

QListWidget 是 Qt 框架中的一个类，属于 Qt Widgets 模块，用于提供一个简单的列表视图，可以用来显示和管理一组项。

• QListWidget 是 QListView 和 QStringListModel 的一个方便实现，简化了对项目的管理和操作。
• QListWidget 支持多种交互形式，例如选择、拖放、上下文菜单等。

常用属性：

属性名称	描述
count	返回列表中项的数量。
currentItem	获取当前选中的项。
items	返回列表中的所有项的列表。
selectionMode	设置选中模式（如单选、多选）。
horizontalScrollBarPolicy	设置水平滚动条的策略（如自动、始终显示）。
verticalScrollBarPolicy	设置垂直滚动条的策略（如自动、始终显示）。
sortingEnabled	启用或禁用排序功能。
dragEnabled	设置是否允许拖动列表项。
dropIndicatorShown	设置是否显示拖放指示器。
itemWidget	获取或设置用于显示项的自定义小部件。
alternatingRowColors	启用交替行颜色以提高可读性。
verticalScrollBar	返回垂直滚动条的指针。
horizontalScrollBar	返回水平滚动条的指针。

常用方法：

方法名	描述
addItem(QString text)	向列表中添加一个新项，显示指定的文本。
insertItem(int row, QString text)	在指定位置插入一个新项。
takeItem(int row)	移除并返回指定行的项。
clear()	清空列表中的所有项。
item(int row)	返回指定行的项指针。
count()	返回列表中项的数量。
currentItem()	获取当前选中的项。
setCurrentItem(QListWidgetItem *item)	设置当前选中的项。
selectedItems()	返回当前选中项的列表。
sortItems()	按字母顺序排序列表中的项。
clearSelection()	取消所有选中状态。
setSelectionMode	设置选中模式。
setDragEnabled(bool enabled)	设置是否允许拖动项。

信号：

信号函数	功 能
itemClicked(QListWidgetItem *item)	用户点击某个列表项时会触发此信号函数，item 参数指的就是被用户点击的列表项。
itemDoubleClicked(QListWidgetItem *item)	用户双击某个列表项时会触发此信号函数，item 参数指的就是被用户双击的列表项。
itemPressed(QListWidgetItem *item)	鼠标按下某个列表项时会触发此信号函数，item 参数指的就是被鼠标按下的列表项，
itemSelectionChanged()	当选择的列表项发生变化时会触发此信号函数。
currentItemChanged(QListWidgetItem *current, QListWidgetItem *previous)	当前列表项发生变化时会触发此信号函数，current 参数指的是新选择的列表项；previous 参数指的是先前选择的列表项。

槽函数

槽函数	功 能
clear()	删除列表中的所有列表项。
scrollToItem(const QListWidgetItem *item, QAbstractItemView::ScrollHint hint = EnsureVisible)	用 hint 参数指定的滑动方式，让用户看到指定的 item 列表项。
selectAll()	选择所有的列表项。
scrollToBottom() scrollToTop()	分别将列表滑动到底部和顶部。

示例：如何创建一个列表并添加项目、选择和删除操作

#include <QApplication>
#include <QMainWindow>
#include <QListWidget>
#include <QVBoxLayout>
#include <QPushButton>
#include <QStringList>

class MainWindow : public QMainWindow {
    Q_OBJECT

public:
    MainWindow() {
        // 创建一个中心小部件和布局
        QWidget *centralWidget = new QWidget(this);
        QVBoxLayout *layout = new QVBoxLayout(centralWidget);
        
        // 创建 QListWidget
        QListWidget *listWidget = new QListWidget(this);
        QStringList items = {"Item 1", "Item 2", "Item 3", "Item 4"};
        listWidget->addItems(items);

        // 创建按钮
        QPushButton *removeButton = new QPushButton("Remove Selected Item", this);
        
        // 连接按钮的点击信号与槽
        connect(removeButton, &QPushButton::clicked, [listWidget]() {
            QListWidgetItem *currentItem = listWidget->currentItem();
            if (currentItem) {
                delete currentItem; // 删除选中的项
            }
        });

        layout->addWidget(listWidget);
        layout->addWidget(removeButton);
        centralWidget->setLayout(layout);
        setCentralWidget(centralWidget);
    }
};

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

    MainWindow mainWindow;
    mainWindow.setWindowTitle("QListWidget Example");
    mainWindow.resize(300, 200);
    mainWindow.show();

    return app.exec();
}

#include "main.moc"

代码解析

1. 创建 QListWidget ：在 MainWindow 类中的构造函数创建 QListWidget ，并添加一些预定义的项目。
2. 布局：使用 QVBoxLayout 将 QListWidget 和一个按钮垂直排列。
3. 删除选中项：按钮的点击信号连接到一个匿名槽，获取当前选中的项，如果存在则删除它。
4. 用户交互：用户可以通过点击列表项选择，然后点击"Remove Selected Item"按钮来删除选中的项。

运行结果：

示例2：

//main.cpp
#include <QApplication>
#include <QWidget>
#include <QListWidget>
#include <QLabel>
#include <QListWidgetItem>
using namespace std;

class QMyLabel:public QLabel{
    Q_OBJECT
public slots:
    void rsetText(QListWidgetItem *item);
};

void QMyLabel::rsetText(QListWidgetItem *item){
    this->setText(item->text());
}

int main(int argc, char *argv[]){
    QApplication a(argc, argv);    //创建一个窗口，作为输入框的父窗口
    QWidget widget;    //设置窗口的标题
    widget.setWindowTitle("QListWidget 示例");    widget.resize(500,500);
    QListWidget listWidget(&widget);
    listWidget.resize(500,400);
    listWidget.setFont(QFont("宋体",14));
    listWidget.addItem("A");
    listWidget.addItem("B");
    listWidget.addItem(new QListWidgetItem("Qt笔记"));
    QMyLabel print;
    print.setText("选中内容");
    print.setParent(&widget);
    print.resize(500,100);
    print.move(0,400);
    print.setAlignment(Qt::AlignCenter);
    QObject::connect(&listWidget,&QListWidget::itemClicked,&print,&QMyLabel::rsetText);
    widget.show();
    return a.exec();
}

#include "main.moc"

运行结果：

Item Widget 组件

QTreeWidget

QTreeWidget 是 Qt 框架中用来表示树形结构的一个类，属于 Qt Widgets 模块。它是 QTreeView 的一个方便的实现，并具有内置的节点管理功能。

• QTreeWidget 是一种 Item Widget 组件
• QTreeWidget 被称作为树形组件
• 树形组件中的项（item）被称为节点树形组件内所有节点组成的结构称为目录树树形组件适合用于显示具有层级结构的数据

常用属性：

属性	描述
addTopLevelItem(QTreeWidgetItem *item)	添加一个顶层项。
topLevelItem(int index)	获取指定索引的顶层项。
child(int index)	获取当前项的子项。
itemAt(QPoint pos)	根据坐标获取指定位置的项。
setHeaderLabels(QStringList labels)	设置表头标签。
setItemExpanded(QTreeWidgetItem *item)	展开指定项。
setItemCollapsed(QTreeWidgetItem *item)	收起指定项。
expandAll()	展开所有项。
collapseAll()	收起所有项。
selectedItems()	返回当前选中的所有项。
invisibleRootItem()	获取隐形根项，通常用于访问整个树。
currentItem()	获取当前选中的项。
setSortingEnabled(bool enable)	启用或禁用排序功能。
sortItems(int column, Qt::SortOrder order)	根据指定列进行排序。
setDragEnabled(bool enable)	启用或禁用拖拽功能。
setDropIndicatorShown(bool show)	是否显示拖放指示器。

常用方法：

功能函数	描述
addTopLevelItem()	向树中添加一个顶层节点。
addChild()	向父节点添加子节点。
removeItemWidget()	从树中删除指定的节点。
currentItem()	获取当前选中的节点。
expandAll()	展开树的所有节点。
collapseAll()	折叠树的所有节点。
setItemWidget()	为某个节点设置自定义的QWidget，允许更复杂的内容显示。

创建树形控件时，使用

QTreeWidget(QWidget *parent = Q_NULLPTR)

当为新建 QTreeWidget 对象指定父窗口后，它将作为该窗口中的一个控件）；反之，新建 QTreeWidget 控件将作为一个独立的窗口。

QTreeWidget 类继承自 QTreeView 类，QTreeView 类也可以用来创建树形控件。

• QTreeWidget 仅适用于构建简单的树形结构，当实际场景中需要构建数据量大、结构复杂的树形结构时，还是应该选择 QTreeView。

示例：如何创建一个树形结构并操作节点

#include <QApplication>
#include <QMainWindow>
#include <QTreeWidget>
#include <QVBoxLayout>
#include <QPushButton>
#include <QMessageBox>

class MainWindow : public QMainWindow {
    Q_OBJECT

public:
    MainWindow() {
        // 创建中心小部件和布局
        QWidget *centralWidget = new QWidget(this);
        QVBoxLayout *layout = new QVBoxLayout(centralWidget);

        // 创建 QTreeWidget
        QTreeWidget *treeWidget = new QTreeWidget(this);
        treeWidget->setHeaderLabel("File System");

        // 添加顶层节点
        QTreeWidgetItem *rootItem = new QTreeWidgetItem(treeWidget, QStringList() << "Root");
        QTreeWidgetItem *childItem1 = new QTreeWidgetItem(rootItem, QStringList() << "Child 1");
        QTreeWidgetItem *childItem2 = new QTreeWidgetItem(rootItem, QStringList() << "Child 2");

        // 向树中添加更多结构
        new QTreeWidgetItem(childItem1, QStringList() << "Sub Child 1");
        new QTreeWidgetItem(childItem2, QStringList() << "Sub Child 2");
        
        // 创建按钮
        QPushButton *showButton = new QPushButton("Show Selected Item", this);
        
        // 连接点击信号与槽函数
        connect(showButton, &QPushButton::clicked, [treeWidget]() {
            QTreeWidgetItem *currentItem = treeWidget->currentItem();
            if (currentItem) {
                QMessageBox::information(nullptr, "Selected Item", currentItem->text(0));
            }
        });

        layout->addWidget(treeWidget);
        layout->addWidget(showButton);
        centralWidget->setLayout(layout);
        setCentralWidget(centralWidget);
    }
};

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

    MainWindow mainWindow;
    mainWindow.setWindowTitle("QTreeWidget Example");
    mainWindow.resize(300, 200);
    mainWindow.show();

    return app.exec();
}

#include "main.moc"

代码解析

1. 创建 QTreeWidget：在 MainWindow 中初始化 QTreeWidget ，并设置表头标签。
2. 添加节点：使用 QTreeWidgetItem 创建根节点及其子节点，形成层级结构。
3. 显示选中节点：创建一个按钮，通过点击按钮显示当前选中节点的名称（通过消息框）。
4. 用户交互：用户可以选择树中的节点并点击"Show Selected Item"按钮来查看所选节点的内容。

运行结果：

QTreeWidgetItem

通常情况下，我们习惯将树形结构中的每份数据称为一个结点。QTreeWidget 控件中，每个结点都是 QTreeWidgetItem 类的实例对象。也就是说，QTreeWidget 类对象代表整个树形控件，而 QTreeWidgetItem 类对象代表树形控件中的结点。

使用 QTreeWidgetItem 类创建结点之前，项目中需引入头文件。QTreeWidgetItem 类提供的构造函数有很多，常用的有如下几个：

//创建一个新结点，设置结点中包含的数据（strings），将该结点添加到指定的 parent 树形结构中
QTreeWidgetItem(QTreeWidget *parent, const QStringList &strings, int type = Type)
//创建一个新结点，将其插入到 parent 树形结构中 preceding 结点之后的位置
QTreeWidgetItem(QTreeWidget *parent, QTreeWidgetItem *preceding, int type = Type)
//创建一个新结点，将其添加到指定 parent 结点中，作为 parent 结点的子结点
QTreeWidgetItem(QTreeWidgetItem *parent, int type = Type)
//创建一个新结点，指定结点中包含的文本内容（strings），将其添加到指定 parent 结点中，作为 parent 的子结点
QTreeWidgetItem(QTreeWidgetItem *parent, const QStringList &strings, int type = Type)
//创建一个新结点，将其插入到 parent 结点中 preceding 结点之后的位置。
QTreeWidgetItem(QTreeWidgetItem *parent, QTreeWidgetItem *preceding, int type = Type)

QTreeWidgetItem 还提供了很多实用的成员方法，下表罗列了一些常用的方法。借助它们，我们可以轻松地管理 QTreeWidget 控件中的各个结点。

成员方法	功 能
void QTreeWidgetItem::addChild(QTreeWidgetItem *child)	为当前结点添加子结点。
void QTreeWidgetItem::addChildren(const QList<QTreeWidgetItem *> &children)	一次性为当前结点添加多个子结点。
QTreeWidgetItem *QTreeWidgetItem::child(int index) const	获得当前结点的第 index 个子结点。
int QTreeWidgetItem::childCount() const	获得当前结点拥有的子结点数。
QTreeWidgetItem *QTreeWidgetItem::parent() const	获得当前结点的父结点。
void QTreeWidgetItem::setCheckState(int column, Qt::CheckState state)	设置当前结点第 column 列的复选框状态。
void QTreeWidgetItem::setIcon(int column, const QIcon &icon)	设置当前结点第 column 列的 icon 图标。
void QTreeWidgetItem::setText(int column, const QString &text)	设置当前结点第 column 列的文本。

QTableWidget

QTableWidget 是 Qt 框架中的一个用于显示和管理表格数据的控件，属于 Qt Widgets 模块。它提供了一个方便的界面来创建和操作类似于电子表格的数据结构，适合用于展示二维表格数据，例如数据库内容、统计数据、配置选项等。

常用属性：

属性	描述
rowCount	表示表格中的行数。
columnCount	表示表格中的列数。
setItem(int row, int column, QTableWidgetItem *item)	设置指定单元格的内容，使用 QTableWidgetItem 对象。
item(int row, int column)	获取指定单元格的 QTableWidgetItem 对象。
setHorizontalHeaderLabels(QStringList labels)	设置列标题。
setVerticalHeaderLabels(QStringList labels)	设置行标题。
horizontalHeaderItem(int column)	获取指定列的标题项。
verticalHeaderItem(int row)	获取指定行的标题项。
setCellWidget(int row, int column, QWidget *widget)	在指定单元格中添加小部件。
clear()	清空表格的所有内容。
resizeColumnToContents(int column)	根据内容自动调整指定列的宽度。
resizeRowToContents(int row)	根据内容自动调整指定行的高度。
setSortingEnabled(bool enable)	启用或禁用排序功能。
sortItems(int column, Qt::SortOrder order)	根据指定列进行排序。
isSortingEnabled()	返回排序功能是否被启用。

常用方法：

方法	描述
setRowCount()	设置表格的行数。
setColumnCount()	设置表格的列数。
setItem()	设置特定单元格的内容。
item()	获取指定单元格的项。
removeRow()	删除指定的行。
removeColumn()	删除指定的列。
clear()	清空表格中的所有内容和格式设置。
setHorizontalHeaderLabels()	设置表格的水平方向（顶部）表头标签。
setVerticalHeaderLabels()	设置表格的垂直方向（左侧）表头标签。

示例：如何创建一个表格并向其添加数据。

#include <QApplication>
#include <QMainWindow>
#include <QTableWidget>
#include <QVBoxLayout>
#include <QPushButton>
#include <QHBoxLayout>
#include <QMessageBox>

class MainWindow : public QMainWindow {
    Q_OBJECT

public:
    MainWindow() {
        // 创建中心小部件和布局
        QWidget *centralWidget = new QWidget(this);
        QVBoxLayout *layout = new QVBoxLayout(centralWidget);

        // 创建 QTableWidget
        QTableWidget *tableWidget = new QTableWidget(this);
        tableWidget->setRowCount(3); // 设置行数
        tableWidget->setColumnCount(2); // 设置列数
        
        // 设置表头标签
        tableWidget->setHorizontalHeaderLabels(QStringList() << "Name" << "Age");

        // 向单元格添加数据
        tableWidget->setItem(0, 0, new QTableWidgetItem("Alice"));
        tableWidget->setItem(0, 1, new QTableWidgetItem("30"));
        tableWidget->setItem(1, 0, new QTableWidgetItem("Bob"));
        tableWidget->setItem(1, 1, new QTableWidgetItem("25"));
        tableWidget->setItem(2, 0, new QTableWidgetItem("Charlie"));
        tableWidget->setItem(2, 1, new QTableWidgetItem("35"));

        // 创建按钮
        QPushButton *showButton = new QPushButton("Show Selected Row", this);
        
        // 连接点击信号与槽函数
        connect(showButton, &QPushButton::clicked, [tableWidget]() {
            QItemSelectionModel *select = tableWidget->selectionModel();
            QModelIndexList selectedRows = select->selectedRows();
            if (!selectedRows.isEmpty()) {
                int row = selectedRows.first().row();
                QString name = tableWidget->item(row, 0)->text();
                QString age = tableWidget->item(row, 1)->text();
                QMessageBox::information(nullptr, "Selected Row", "Name: " + name + "\nAge: " + age);
            } else {
                QMessageBox::warning(nullptr, "No Selection", "Please select a row.");
            }
        });

        layout->addWidget(tableWidget);
        layout->addWidget(showButton);
        centralWidget->setLayout(layout);
        setCentralWidget(centralWidget);
    }
};

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

    MainWindow mainWindow;
    mainWindow.setWindowTitle("QTableWidget Example");
    mainWindow.resize(300, 200);
    mainWindow.show();

    return app.exec();
}

#include "main.moc"

代码解析

1. 创建 QTableWidget：在 MainWindow 中初始化 QTableWidget ，设置行数和列数，并定义表头标签。
2. 添加数据：使用 setItem() 方法向单元格添加数据，通过 QTableWidgetItem 来设置单元格的内容。
3. 显示选中行：创建一个按钮，通过点击按钮获取当前选中行的内容，并使用消息框显示姓名和年龄信息。
4. 用户交互：用户可以选择表格中的行并点击"Show Selected Row"按钮来查看所选行的内容。

运行结果：

QTableWidgetItem

QTableWidget 表格中，每个单元格都是 QTableWidgetItem 类的实例对象。

定义 QTableWidgetItem 类的实例对象之前，程序中要引入头文件。QTableWidgetItem 类提供了 4 个构造函数：

QTableWidgetItem(int type = Type)
QTableWidgetItem(const QString &text, int type = Type)
QTableWidgetItem(const QIcon &icon, const QString &text, int type = Type)
QTableWidgetItem(const QTableWidgetItem &other)    //复制（拷贝）构造函数

text 参数用于指定单元格要显示的文本（字符串），icon 参数用于指定单元格要显示的图标，type 参数配有默认值，很少用到。

QTableWidgetItem 单元格通常用来存放 text 文本和 icon 图标，借助该类提供的 setBackground()、setTextAlignment() 等成员方法，我们可以轻松设置每个单元格的字体、颜色、背景等。

QTableWidgetItem 类还对<小于运算符进行了重载，根据各个单元格存储的文本内容（字符串），多个单元格之间可以直接比较大小。借助这一特性，我们可以很轻易地实现"单元格排序"功能。

默认情况下，用户可以选中 QTableWidget 表格中的某个单元格，还可以对目标单元格中的文本内容进行修改。通过设置 QTableWidget 表格，可以禁止用户编辑所有单元格。

QTableWidgetItem 类提供了很多实用的成员方法，其中比较常用的方法如下表所示：

成员方法	功 能
setText(const QString &text)	设置单元格中的文本。
setIcon(const QIcon &icon)	给单元格添加图标。
setBackground(const QBrush &brush)	设置单元格的背景。
setFont(const QFont &font)	设置单元格中文本的字体。
setForeground(const QBrush &brush)	设置单元格中字体的颜色。
setTextAlignment(int alignment)	设置单元格中文本的对齐方式。
setToolTip(const QString &toolTip)	给单元格设置提示信息。