QT入门看这一篇就够（详解含qt源码）

2024-06-21 1869阅读

Qt入门看这一篇就够

一、Qt概述
- 1.1 什么是Qt
- 1.2 Qt的发展史
- 1.3 Qt的优势
- 1.4 Qt版本
- 1.5 成功案例
- 二、创建Qt项目
- - 2.1 创建项目
  - 2.2 Kits构建套件
  - 2.3 .pro文件
  - 2.4 命名规范
  - 2.5 QtCreator常用快捷键
  - 三、Qt类关系
  - - 3.1 Qt父子关系
    - 3.2 Qt坐标系
    - 3.3 Qt对象树模型
    - 四、信号与槽机制
    - - 4.1 默认信号和槽
      - 4.2 Qt自定义信号和槽
      - 4.3 Qt中的lambda表达式
      - 五、QMainWindow
      - 5.1 QMainWindow
        5.2 菜单栏
        5.3 工具栏
        5.4 状态栏
        5.5 停靠部件
        5.6 中心部件
        六、QDialog 对话框
        6.1 基本概念
        6.2 模态对话框
        6.3 标准对话框
        6.3.1 文件对话框（QFileDialog）
        6.3.2 颜色对话框（QColorDialog）
        6.3.3 字体对话框（QFontDialog）
        6.3.4 消息框（QMessageBox）
        6.3.5 输入对话框（QInputDialog）
        6.4 Qt自定义对话框
        七、布局
        7.1 水平布局（QHBoxLayout）
        7.2 垂直布局（QVBoxLayout）
        7.3 网格布局（QGridLayout）
        7.4 栈布局（QStackedLayout）
        7.5 表单布局（QFormLayout）
        八、常用控件
        8.1 QPushButton（按钮）
        8.2 QLabel（标签）
        8.3 QLineEdit（单行文本框）
        8.4 QTextEdit（多行文本框）
        8.5 QSpinBox（数值输入框）
        8.6 QDoubleSpinBox（双精度浮点数输入框）
        8.7 QComboBox（下拉框）
        8.8 QCheckBox（复选框）
        8.9 QRadioButton（单选按钮）
        8.10 QSlider（滑块）
        8.11 QProgressBar（进度条）
        8.12 QDateEdit（日期输入框）
        8.13 QTimeEdit（时间输入框）
        8.14 QDateTimeEdit（日期时间输入框）
        8.15 QTabWidget（选项卡窗口）
        8.16 QListWidget（列表框）
        8.17 QTreeWidget（树形列表框）
        九、Qt消息事件机制
        9.1 Qt事件类别
        9.1.1 键盘事件 (QKeyEvent)
        9.1.2 鼠标事件 (QMouseEvent)
        9.1.3 定时器事件 (QTimerEvent)
        9.1.4 自定义事件 (QEvent 的子类)
        9.2 Qt事件处理函数
        9.3 Qt事件过滤器
        9.4 Qt事件分发
        9.5 Qt事件对象(QEvent)
        9.6 Qt定时器事件
        9.7 Qt自定义事件
        9.8 Qt事件循环
        十、文件操作
        10.1 文件和目录的读写
        10.1.1 文件的读写操作
        10.1.2 目录的操作
        10.2 二进制文件的读写
        10.2.1 Qt二进制文件的写入
        10.2.2 Qt二进制文件的读取
        10.3 文件对话框
        10.4 文件状态和信息
        十一、源码地址
        十二、Qt开发实例
        一、Qt概述
        
        1.1 什么是Qt
        
        Qt是一个跨平台的C++应用程序开发框架。它由Qt Company（前身为Nokia）开发，用于开发图形用户界面、嵌入式系统、以及其他应用程序，支持Windows、macOS、Linux、Android和iOS等多个操作系统。
        
        Qt框架提供了丰富的功能和工具，包括图形用户界面设计、数据库操作、网络编程、文件处理等。它还包括了一个广泛的类库，开发者可以使用这些类来加速应用程序的开发过程。Qt还具有良好的文档和社区支持，因此广泛用于各种类型的应用程序开发，包括桌面应用、移动应用、嵌入式系统等。
        实际项目开发学习路径Qt项目实战
        
        1.2 Qt的发展史
        
        Qt的发展史可以追溯到1991年，由挪威的程序员Haavard Nord和Eirik Chambe-Eng共同创建。起初，Qt是一个用于开发X Window系统上的应用程序的工具集。在1994年，Qt被Nokia收购，并在此基础上继续发展。
        
        以下是Qt的主要发展阶段和事件：
        
        1991年： Haavard Nord和Eirik Chambe-Eng创建了Qt工具集。
        
        1994年： Qt被Nokia收购，成为Nokia的子公司。Nokia推动了Qt的跨平台特性，使其能够在不同的操作系统上运行。
        
        2008年： Qt的所有权由Nokia转移到了Qt Software（之后更名为Qt Company）。Qt Company继续发展Qt，将其打造成一个跨平台的应用程序开发框架。
        
        2011年： Qt的开发遭遇了一些波折，包括Nokia的战略变化和Qt的开发者社区担忧Qt的未来。这一时期，Qt的发展由社区驱动。
        
        2012年： Qt Project成立，该项目由Qt的爱好者和开发者组成，致力于Qt的开发和推广。
        
        2014年： Digia宣布收购Qt商业版的所有权，成为Qt的新所有者。
        
        2016年： The Qt Company宣布Qt的开源版本将采用GPLv3协议。Qt 5.6发布，引入了许多新特性和改进。
        
        2017年： Qt 5.9发布，增加了对3D图形的支持和Qt Quick Controls 2。
        
        2018年： Qt 5.11发布，引入了Qt Quick 2D Renderer，提供了在没有OpenGL支持的系统上运行Qt Quick应用的能力。
        
        2019年： Qt 5.12发布，引入了Qt for WebAssembly，使得开发者可以将Qt应用程序编译成WebAssembly格式，可以在现代Web浏览器中运行。
        
        2020年： Qt 6发布，这是Qt的一个重大版本，引入了许多新特性和改进，包括模块化架构、C++17支持、图形API的改进等。
        
        2021年： Qt 6.2发布，引入了Qt Quick 3D，使得开发者可以更轻松地在Qt应用中添加3D图形。
        
        Qt的发展一直在不断地推进，它仍然是一个受欢迎的跨平台应用程序开发框架，在桌面、移动设备、嵌入式系统等多个领域得到广泛应用。
        
        1.3 Qt的优势
        
        Qt拥有许多优势，使其成为一个受欢迎的应用程序开发框架。以下是一些Qt的主要优势：
        
        跨平台性： Qt是一个跨平台框架，可以在多个操作系统上运行，包括Windows、macOS、Linux、Android和iOS。这意味着开发者可以编写一份代码，然后在不同的平台上部署应用程序，减少了开发的工作量。
        
        丰富的类库： Qt提供了丰富的类库，涵盖了图形用户界面、网络、数据库、文件处理、XML处理等多个领域。这些类库可以帮助开发者加速应用程序的开发过程，减少了从头开始编写代码的需求。
        
        易用性： Qt提供了直观且易用的API，使得开发者能够快速上手，并且能够高效地开发功能丰富的应用程序。
        
        强大的社区和支持： Qt拥有一个庞大的开发者社区和支持团队，开发者可以在社区中获取帮助、分享经验，并且有大量的文档、示例和教程可供参考。
        
        灵活性： Qt是一个非常灵活的框架，允许开发者使用C++编程语言进行开发，同时也提供了Qt Quick，这是一个基于QML（Qt Meta-Object Language）的框架，用于快速开发移动应用和嵌入式应用的用户界面。
        
        开源和商业许可： Qt提供了开源版本（遵循LGPL协议），同时也提供了商业版本，开发者可以根据项目的需求选择合适的许可类型。
        
        现代化： Qt不断更新和演进，保持与时俱进，支持最新的C++标准，提供了现代化的开发体验。
        
        高性能： Qt框架经过优化，能够提供高性能的应用程序，同时它还提供了内置的工具和API，用于性能分析和调优。
        
        总的来说，Qt是一个功能强大、易用性高、跨平台性好、支持广泛的应用程序开发框架，适用于各种规模和类型的项目。
        
        1.4 Qt版本
        
        Qt 6 是Qt框架的一个重大版本，引入了许多新特性和改进。在Qt 6发布之前，Qt 5系列也是非常常用的，特别是Qt 5.12和Qt 5.15版本。
        
        以下是Qt的一些主要版本：
        
        Qt 1.x系列：最早的版本，于1995年发布。
        
        Qt 2.x系列： 1999年发布，引入了许多新特性。
        
        Qt 3.x系列： 2001年发布，引入了跨平台的支持和更多功能。
        
        Qt 4.x系列： 2005年发布，引入了Qt的现代外观和更多功能，也是第一个支持Windows Vista的版本。
        
        Qt 5.x系列： 2012年发布，引入了Qt Quick框架，使得开发者能够更容易地创建现代化的用户界面。Qt 5.6、5.9、5.12和5.15等版本是该系列的一些重要版本。
        
        Qt 6.x系列： 2020年发布，引入了模块化架构、C++17支持、图形API的改进等新特性。
        
        1.5 成功案例
        
        KDE桌面环境： KDE是一个使用Qt构建的开源桌面环境，它是Linux系统中最受欢迎的桌面环境之一。
        
        Autodesk Maya： Autodesk Maya是一款专业的3D计算机图形应用程序，用于建模、动画、仿真和渲染。它的用户界面是使用Qt构建的。
        
        VirtualBox： VirtualBox是一款由Oracle开发的开源虚拟机软件，它的用户界面也是使用Qt开发的。
        
        VLC媒体播放器： VLC是一个流行的开源媒体播放器，它的Qt界面版本被广泛用于不同平台。
        
        Telegram桌面客户端： Telegram是一个知名的即时通讯应用，它的桌面客户端使用Qt进行开发。
        
        Autodesk AutoCAD： AutoCAD是一款专业的计算机辅助设计（CAD）软件，它的Mac版本使用Qt构建用户界面。
        
        Adobe Photoshop Elements： Adobe Photoshop Elements是Adobe公司的一款图像编辑软件，它的某些版本的用户界面是使用Qt构建的。
        
        MATLAB Simulink： Simulink是MATLAB的一部分，用于进行多域仿真和模型驱动的设计，它的用户界面使用了Qt技术。
        
        这些成功案例表明了Qt框架在各种领域中的应用广泛性，包括图形设计、媒体播放、虚拟化、通讯等。Qt的跨平台性和易用性使得它成为许多开发者的首选框架之一。
        
        二、创建Qt项目
        
        2.1 创建项目
        
        打开QtCreator,文件->新建文件或项目，如下图
        
        项目->Application->Qt console Application
        不带界面的应用程序，如下图
        
        修改项目名称，修改项目存储路径，如下图：
        这样就创建了额一个简单的QT应用
        
        2.2 Kits构建套件
        
        
        
        2.3 .pro文件
        
        在Qt项目中，.pro 文件是一个项目文件，用于配置和管理Qt应用程序的构建过程。这个文件通常是由Qt的qmake工具使用的，qmake会根据.pro文件的内容来生成适用于不同平台和编译器的构建脚本。
        
        下面是一个典型的Qt项目文件（.pro文件）的结构和一些常见的内容：
        
        # 注释行，以#开头 # 定义项目名称 TARGET = MyApplication # 指定项目类型（应用程序、库等） TEMPLATE = app # 指定源代码文件 SOURCES += main.cpp \ myclass.cpp # 指定头文件 HEADERS += myclass.h # 指定需要链接的库 LIBS += -lmylibrary # 指定项目所需的Qt模块（例如Widgets、Network等） QT += widgets network # 预处理宏定义 DEFINES += MY_DEFINE # 编译器选项 QMAKE_CXXFLAGS += -std=c++11 # 指定目标平台（例如Windows、Linux、macOS等） win32 { # Windows特定配置 } unix { # Unix（包括Linux和macOS）特定配置 } macx { # macOS特定配置 }
        
        上述示例展示了一个简单的Qt项目文件，不同的项目会有不同的配置，具体的内容会根据项目的需要而变化。以下是一些常见的.pro文件的配置项：
        
        TARGET：指定生成的可执行文件的名称。
        TEMPLATE：指定项目的类型，例如应用程序（app）、库（lib）等。
        SOURCES：指定源代码文件的列表。
        HEADERS：指定头文件的列表。
        LIBS：指定需要链接的库。
        QT：指定项目所需的Qt模块。
        DEFINES：定义预处理宏。
        QMAKE_CXXFLAGS：指定编译器选项。
        win32/unix/macx：平台特定的配置，用于针对不同的操作系统设置特定的编译选项。
        通过编辑.pro文件，开发者可以定制项目的构建过程，包括指定源文件、链接库、定义宏、设置编译选项等。在Qt项目中，.pro文件的灵活性和可定制性使得开发者能够更好地管理项目的构建和依赖关系。
        
        2.4 命名规范
        
        Qt开发中通常遵循一些命名规范，以提高代码的可读性和可维护性。以下是一些常见的Qt开发命名规范：
        
        类名命名规范：类名使用驼峰命名法（Camel Case），例如：MyClass, MainWindow。
        
        变量名命名规范：变量名使用驼峰命名法，但通常以小写字母开头，例如：myVariable, buttonClicked。
        
        常量名命名规范：常量名通常使用大写字母和下划线（大写蛇形命名法），例如：MAX_SIZE, PI_VALUE。
        
        函数名命名规范：函数名使用驼峰命名法，以小写字母开头，例如：calculateArea(), setWindowTitle()。
        
        信号和槽函数名命名规范：信号和槽函数使用驼峰命名法，但通常以signal和slot结尾，例如：buttonClickedSignal(), saveFileSlot()。
        
        枚举类型命名规范：枚举类型使用驼峰命名法，以大写字母开头，例如：ColorType, ButtonType。
        
        命名空间命名规范：命名空间使用驼峰命名法，以大写字母开头，例如：MyNamespace, QtWidgets。
        
        文件名命名规范：文件名通常使用小写字母，单词之间用下划线分隔，例如：main_window.cpp, my_class.h。
        
        目录名命名规范：目录名通常使用小写字母，单词之间用下划线分隔，例如：widgets, utilities_functions。
        
        私有成员变量前缀：私有成员变量通常以小写字母m_开头，后面跟随驼峰命名法，例如：m_privateVariable。
        
        布尔类型的变量名：布尔类型的变量通常以is、has、can等前缀开头，例如：isVisible, hasData。
        
        以上规范并不是强制性的，但它们是一些常见的实践，遵循这些规范可以使你的代码更易读、易懂，并且有助于与其他开发者协作。在团队中，通常会有特定的命名规范，应该根据团队内部的规范来统一命名。
        
        2.5 QtCreator常用快捷键
        
        常规操作快捷键：
        
        Ctrl + N：新建文件。
        Ctrl + O：打开文件。
        Ctrl + S：保存文件。
        Ctrl + P：打印文件。
        Ctrl + Z：撤销上一步操作。
        Ctrl + Shift + Z 或 Ctrl + Y：重做上一步操作。
        Ctrl + X：剪切所选内容。
        Ctrl + C：复制所选内容。
        Ctrl + V：粘贴剪切板上的内容。
        Ctrl + F：查找。
        Ctrl + H：替换。
        
        编辑快捷键：
        
        Ctrl + Space：代码自动完成。
        Ctrl + I：格式化文本。
        F2：跳转到下一个错误或警告。
        Shift + F2：跳转到上一个错误或警告。
        Ctrl + /：注释或取消注释所选行。
        
        导航快捷键：
        
        Ctrl + K：跳转到定义。
        Ctrl + E：打开最近的文件。
        Ctrl + Shift + E：打开最近的项目。
        Ctrl + F12：显示当前文件的类或函数列表。
        F4：跳转到包含光标所在文本的定义。
        Ctrl + Shift + F4：返回上一个查看的位置。
        
        项目和构建快捷键：
        
        Ctrl + R：构建项目。
        Ctrl + B：构建并运行项目。
        Ctrl + D：调试项目。
        Ctrl + Shift + B：构建所有项目。
        Ctrl + T：运行单元测试。
        F5：重新运行应用程序。
        这只是Qt Creator中一些常用的快捷键，实际上还有很多其他快捷键和功能。你可以在Qt Creator的帮助文档中找到完整的快捷键列表，以便更好地利用这个强大的IDE。
        
        三、Qt类关系
        
        3.1 Qt父子关系
        
        在Qt中，对象之间的父子关系是非常重要的概念，它对于对象的内存管理和事件传递有着重要的影响。以下是关于Qt类的父子关系的知识点：
        
        父子关系的建立：
        
        通过在对象的构造函数中传递父对象的指针，可以建立父子关系。
        QObject的子类通常在构造函数中传入父对象指针，以建立父子关系，这样父对象会负责管理子对象的内存。
        MyChildClass::MyChildClass(QObject *parent) : QObject(parent) { // 构造函数中传入父对象指针 }
        
        父子关系的影响：
        
        当父对象被销毁时，它的所有子对象也会被自动销毁。
        父对象的位置和大小变化也会影响到子对象。
        
        QObject的parent()函数：
        
        通过parent()函数可以获取对象的父对象指针。
        QObject *parent = myObject->parent();
        
        父子关系的适用范围：
        
        父子关系通常在GUI编程中用得比较多，例如窗口和窗口上的控件之间建立父子关系。
        父子关系在对象的内存管理方面非常有用，能够简化内存释放的过程。
        
        QObject的findChild函数：
        
        通过findChild函数可以在父对象的子对象中查找特定名称的子对象。
        QObject *childObject = parentObject->findChild("childObjectName");
        
        事件传递中的父子关系：
        
        在事件传递中，父子关系也很重要。事件通常从父对象传递到子对象，父对象可以拦截事件，也可以选择传递给子对象处理。
        bool MyObject::event(QEvent *event) { if (event->type() == QEvent::KeyPress) { // 处理键盘事件 return true; } return QObject::event(event); // 默认事件处理方式 }
        
        通过建立父子关系，Qt能够有效地管理对象的生命周期，简化内存管理的复杂性。这种关系也使得事件的传递和处理更加方便和灵活。
        
        3.2 Qt坐标系
        
        在Qt中，有两种主要的坐标系：窗口坐标系（或者称为客户区坐标系）和屏幕坐标系。理解这两种坐标系非常重要，因为它们在窗口绘制、事件处理和布局等方面有着重要作用。
        
        1. 窗口坐标系（客户区坐标系）：
        窗口坐标系是相对于窗口的左上角而言的。窗口坐标系用于描述窗口内部的位置和大小。在窗口坐标系中，窗口的左上角是原点（0, 0）。当你绘制窗口的内容、布局控件或者处理鼠标事件时，通常会使用窗口坐标系。
        
        Qt中的大部分坐标系统默认使用窗口坐标系。
        
        2. 屏幕坐标系：
        屏幕坐标系是相对于屏幕左上角而言的，用于描述整个屏幕上的位置和大小。在屏幕坐标系中，屏幕的左上角是原点（0, 0）。当你需要获取鼠标在屏幕上的位置、进行截图、或者进行窗口的全屏和移动等操作时，通常会使用屏幕坐标系。
        
        坐标系转换：
        在Qt中，你可以使用QWidget类的成员函数进行窗口坐标系和屏幕坐标系之间的转换。例如：
        
        QWidget::mapToGlobal(const QPoint &)：将窗口坐标转换为屏幕坐标。
        QWidget::mapFromGlobal(const QPoint &)：将屏幕坐标转换为窗口坐标。
        这些函数允许你在不同坐标系之间进行转换，使得你可以在需要时轻松地在窗口和屏幕坐标系之间切换。
        
        3.3 Qt对象树模型
        
        Qt中的对象树模型是一种管理QObject及其派生类对象关系的模型。对象树模型用于管理对象的父子关系，即一个QObject对象可以有一个父对象和多个子对象。Qt的对象树模型是一种递归的结构，其中一个对象可以拥有多个子对象，而每个子对象又可以拥有自己的子对象，以此类推。
        
        在对象树模型中，父对象的销毁会导致所有子对象的自动销毁。当一个QObject对象被销毁时，它的所有子对象也会被递归地销毁。这种自动内存管理机制使得在Qt中不需要手动管理对象的生命周期，提高了代码的简洁性和可维护性。
        
        以下是Qt对象树模型的关键概念和特点：
        
        QObject及其子类的继承关系：
        
        所有使用Qt对象模型的类都必须继承自QObject类，包括QWidget、QMainWindow等。
        
        父子关系的建立：
        
        通过在对象的构造函数中传递父对象的指针，可以建立父子关系。
        父对象的销毁会导致所有子对象的自动销毁。
        MyChildClass::MyChildClass(QObject *parent) : QObject(parent) { // 构造函数中传入父对象指针 }
        
        parent()函数：
        
        通过parent()函数可以获取对象的父对象指针。
        QObject *parent = myObject->parent();
        
        对象树的遍历：
        
        通过children()函数可以获取对象的所有子对象，从而实现对象树的遍历。
        QList children = parentObject->children();
        
        QObject的findChild和findChildren函数：
        
        通过findChild函数可以在父对象的子对象中查找特定名称的子对象。
        通过findChildren函数可以获取符合特定条件的所有子对象。
        QObject *childObject = parentObject->findChild("childObjectName"); QList children = parentObject->findChildren("childObjectName");
        
        事件传递中的父子关系：
        
        在事件传递中，父子关系也很重要。事件通常从父对象传递到子对象，父对象可以拦截事件，也可以选择传递给子对象处理。
        bool MyObject::event(QEvent *event) { if (event->type() == QEvent::KeyPress) { // 处理键盘事件 return true; } return QObject::event(event); // 默认事件处理方式 }
        
        Qt的对象树模型提供了一种方便的方式来管理对象的生命周期和组织对象的关系，特别适用于GUI编程和事件处理。
        
        四、信号与槽机制
        
        4.1 默认信号和槽
        
        在Qt中，可以使用默认信号和槽的机制，它允许
        你不需要手动声明信号和槽，而是使用Qt提供的默认信号和槽来进行连接。默认信号和槽的机制在Qt的部分组件中内置，例如QPushButton的点击事件等。
        
        使用说明：
        
        默认信号和槽的连接：
        
        对于某些Qt组件，比如QPushButton，它们内置了一些默认的信号和槽，无需手动声明，可以直接连接它们的信号和槽。
        示例：
        
        QPushButton *button = new QPushButton("Click Me"); QObject::connect(button, &QPushButton::clicked, [=]() { qDebug() qDebug() QApplication app(argc, argv); // QPushButton的默认信号（clicked）与槽的连接 QPushButton *button = new QPushButton("Click Me"); QObject::connect(button, &QPushButton::clicked, [=]() { qInfo() qInfo() Q_OBJECT public: MyObject() {} signals: void mySignal(int value); }; Q_OBJECT public: MyObject() {} public slots: void mySlot(int value) { qDebug() Q_OBJECT public: MyObject() {} signals: void mySignal(int value); public slots: void triggerSignal() { emit mySignal(42); // 触发信号并传递参数 } }; // Lambda表达式内的代码 }); 1, 2, 3, 4, 5}; std::for_each(numbers.begin(), numbers.end(), [](int number) { qDebug() 5, 2, 8, 1, 3}; std::sort(numbers.begin(), numbers.end(), [](int a, int b) { return a addWidget(statusBarLabel); }; #include "main.moc" int main(int argc, char *argv[]) { QApplication app(argc, argv); MainWindow mainWindow; mainWindow.show(); return app.exec(); }
        
        当用户点击工具栏上的按钮时，将会弹出一个文件选择对话框，选择文件后，文件的路径将会显示在状态栏上。
        
        5.4 状态栏
        
        在 QMainWindow 中，状态栏（Status Bar）是一个用于显示应用程序状态信息、提示信息和用户交互的底部区域。状态栏通常用于向用户提供反馈、进度信息或一般性的应用程序状态。以下是如何在 QMainWindow 中使用状态栏的说明和一个简单的实例讲解。
        
        状态栏的使用说明：
        在 QMainWindow 中，你可以通过以下步骤在状态栏上添加标签、消息和控件：
        
        创建状态栏：
        
        QStatusBar 类通常已经作为 QMainWindow 的一部分存在，你可以使用 statusBar() 函数来获取当前的状态栏对象。
        
        添加标签或消息到状态栏：
        
        statusBar()->showMessage("Ready", 3000); // 在状态栏上显示消息，持续时间为3秒
        
        在状态栏上添加控件：
        
        QLabel *statusLabel = new QLabel("Status Label", this); statusBar()->addPermanentWidget(statusLabel);
        
        这将在状态栏的最右侧添加一个标签。
        
        示例代码：
        以下是一个简单的Qt应用程序，演示了如何在 QMainWindow 中使用状态栏。在这个示例中，状态栏会在应用程序启动时显示"Ready"消息，然后在用户点击按钮时显示相应的消息。
        
        #include #include #include #include #include class MainWindow : public QMainWindow { Q_OBJECT public: MainWindow(QWidget *parent = nullptr) : QMainWindow(parent) { // 创建一个标签并将其添加到状态栏 statusLabel = new QLabel("Ready", this); statusBar()->addWidget(statusLabel); // 创建一个按钮 QPushButton *button = new QPushButton("Show Message", this); connect(button, SIGNAL(clicked()), this, SLOT(showMessage())); setCentralWidget(button); } private slots: void showMessage() { statusBar()->showMessage("Button clicked", 3000); // 显示消息，持续时间为3秒 } private: QLabel *statusLabel; }; #include "main.moc" int main(int argc, char *argv[]) { QApplication app(argc, argv); MainWindow mainWindow; mainWindow.show(); return app.exec(); }
        
        在这个示例中，当应用程序启动时，状态栏会显示"Ready"消息。当用户点击"Show Message"按钮时，状态栏会显示"Button clicked"消息，并在3秒后清除。这个示例演示了如何在 QMainWindow 中使用状态栏来提供应用程序的状态信息。
        
        5.5 停靠部件
        
        在 QMainWindow 中，停靠部件（Dock Widgets）是指可以在主窗口中停靠、浮动和关闭的窗口部件。这些停靠部件通常用于显示工具、属性编辑器、文件导航器等，为用户提供更丰富的交互体验。以下是如何在 QMainWindow 中使用停靠部件的说明和一个简单的实例讲解。
        
        停靠部件的使用说明：
        
        创建停靠部件：
        
        QDockWidget *dockWidget = new QDockWidget("Dock Widget", this);
        
        这里，“Dock Widget” 是停靠部件的标题。
        
        设置停靠部件的内容：
        
        QWidget *dockWidgetContent = new QWidget(dockWidget); dockWidget->setWidget(dockWidgetContent);
        
        在 dockWidgetContent 中添加你需要的控件，例如按钮、标签等。
        
        将停靠部件添加到主窗口：
        
        addDockWidget(Qt::LeftDockWidgetArea, dockWidget);
        
        Qt::LeftDockWidgetArea 指定了停靠部件的默认位置，你也可以选择其他位置，例如 Qt::RightDockWidgetArea、Qt::TopDockWidgetArea 或 Qt::BottomDockWidgetArea。
        
        示例代码：
        以下是一个简单的Qt应用程序，演示了如何在 QMainWindow 中使用停靠部件。在这个示例中，主窗口中包含一个按钮，点击按钮后会在左侧停靠一个带有标签的窗口。
        
        #include #include #include #include class MainWindow : public QMainWindow { Q_OBJECT public: MainWindow(QWidget *parent = nullptr) : QMainWindow(parent) { // 创建一个按钮 QPushButton *button = new QPushButton("Show Dock Widget", this); connect(button, SIGNAL(clicked()), this, SLOT(showDockWidget())); setCentralWidget(button); } private slots: void showDockWidget() { // 创建停靠部件 QDockWidget *dockWidget = new QDockWidget("Dock Widget", this); // 在停靠部件中添加一个标签 QLabel *label = new QLabel("This is a dock widget", dockWidget); dockWidget->setWidget(label); // 将停靠部件添加到左侧停靠区域 addDockWidget(Qt::LeftDockWidgetArea, dockWidget); } }; #include #include "main.moc" int main(int argc, char *argv[]) { QApplication app(argc, argv); MainWindow mainWindow; mainWindow.show(); return app.exec(); }
        
        在这个示例中，当用户点击"Show Dock Widget"按钮时，一个带有标签的停靠部件会从左侧停靠。你可以将停靠部件放置在不同的停靠区域，并且可以通过用户界面手动调整它们的位置。这个示例演示了如何在 QMainWindow 中使用停靠部件提供额外的功能。
        
        5.6 中心部件
        
        在 QMainWindow 中，中心部件（Central Widget）是主窗口的中间区域，通常用于显示应用程序的主要内容，例如绘图区域、文本编辑器、图形视图等。中心部件通常是一个继承自 QWidget 的自定义部件，但也可以是其他 QWidget 派生类的实例。以下是如何在 QMainWindow 中使用中心部件的说明和一个简单的实例讲解。
        
        中心部件的使用说明：
        
        创建中心部件：
        
        QWidget *centralWidget = new QWidget(this); setCentralWidget(centralWidget);
        
        这里，centralWidget 是一个继承自 QWidget 的自定义部件，或者是其他 QWidget 派生类的实例。
        
        将控件添加到中心部件：
        
        QVBoxLayout *layout = new QVBoxLayout(centralWidget); QLabel *label = new QLabel("This is the central widget content", centralWidget); layout->addWidget(label);
        
        在这个示例中，我们创建了一个垂直布局管理器，并将一个标签添加到其中。这个布局将会显示在中心部件的中间区域。
        
        示例代码：
        以下是一个简单的Qt应用程序，演示了如何在 QMainWindow 中使用中心部件。在这个示例中，主窗口的中心部件包含一个标签，显示一条消息。
        
        #include #include #include #include class MainWindow : public QMainWindow { Q_OBJECT public: MainWindow(QWidget *parent = nullptr) : QMainWindow(parent) { // 创建中心部件 QWidget *centralWidget = new QWidget(this); setCentralWidget(centralWidget); // 创建布局管理器 QVBoxLayout *layout = new QVBoxLayout(centralWidget); // 在中心部件中添加标签 QLabel *label = new QLabel("This is the central widget content", centralWidget); layout->addWidget(label); } }; #include int main(int argc, char *argv[]) { QApplication app(argc, argv); MainWindow mainWindow; mainWindow.show(); return app.exec(); }
        
        在这个示例中，主窗口的中心部件包含一个标签，标签显示文本"This is the central widget content"。你可以将任何需要显示的控件添加到中心部件中，从而在主窗口的中心区域显示应用程序的主要内容。
        
        六、QDialog 对话框
        
        6.1 基本概念
        
        QDialog 是Qt框架中的一个类，用于创建对话框窗口。对话框是一种与用户进行简短交互、提供特定信息或执行特定任务的窗口。QDialog 提供了一种方便的方式来创建标准对话框，例如消息框、输入框、文件选择框等。
        
        以下是QDialog的一些基本概念和特点：
        
        基本特点：
        
        模态和非模态： QDialog 可以是模态（Modal）或非模态（Modeless）。模态对话框阻止用户与应用程序的其他部分进行交互，直到对话框关闭。非模态对话框允许用户同时与应用程序的其他部分进行交互。
        
        布局管理：可以使用布局管理器（如QVBoxLayout、QHBoxLayout等）来组织对话框中的控件。
        
        内建按钮： QDialog 可以包含内建的标准按钮，例如“确定”、“取消”、“应用”等。这些按钮通常用于执行常见的操作。
        
        自定义控件：可以将自定义的控件（例如标签、文本框、按钮等）添加到对话框中，以满足特定需求。
        
        基本用法：
        
        创建对话框：
        
        QDialog *dialog = new QDialog(parent);
        
        这里，parent 是可选的，表示对话框的父窗口。
        
        设置对话框的标题：
        
        dialog->setWindowTitle("Dialog Title");
        
        添加控件到对话框：
        
        QVBoxLayout *layout = new QVBoxLayout(dialog); QLabel *label = new QLabel("Dialog Content", dialog); layout->addWidget(label);
        
        显示对话框：
        
        dialog->exec(); // 模态对话框，阻塞用户输入，直到对话框关闭 // 或者 dialog->show(); // 非模态对话框，允许用户同时与应用程序的其他部分进行交互
        
        示例代码：
        以下是一个简单的Qt应用程序，演示了如何创建一个模态对话框。在这个示例中，点击按钮将会弹出一个对话框。
        
        #include #include #include #include #include int main(int argc, char *argv[]) { QApplication app(argc, argv); QDialog dialog; dialog.setWindowTitle("Dialog Example"); QVBoxLayout *layout = new QVBoxLayout(&dialog); QLabel *label = new QLabel("This is a dialog", &dialog); layout->addWidget(label); QPushButton *button = new QPushButton("Close", &dialog); layout->addWidget(button); QObject::connect(button, &QPushButton::clicked, [&dialog]() { dialog.close(); }); dialog.exec(); // 显示模态对话框 return app.exec(); }
        
        在这个示例中，点击按钮将会弹出一个包含标签和按钮的对话框。这个对话框是模态的，阻塞用户与主窗口的交互，直到对话框关闭。
        
        6.2 模态对话框
        
        在Qt中，QDialog 是一个用于创建对话框的类。模态对话框（Modal Dialog）是一种阻塞式对话框，当用户与对话框交互时，阻止用户与应用程序的其他部分进行交互。在用户关闭模态对话框之前，主窗口和其他窗口将无法响应用户输入。
        
        以下是如何创建和使用模态对话框的基本步骤：
        
        创建QDialog对象：
        
        QDialog *dialog = new QDialog(parent);
        
        这里，parent 是可选的，表示对话框的父窗口。
        
        设置对话框的标题和内容：
        
        dialog->setWindowTitle("Modal Dialog Example"); QLabel *label = new QLabel("This is a modal dialog.", dialog);
        
        添加按钮或其他控件：
        
        QPushButton *okButton = new QPushButton("OK", dialog);
        
        你可以连接按钮的点击信号（clicked()信号）到一个槽函数，以便在用户点击按钮时执行相应的操作。
        
        显示对话框：
        
        int result = dialog->exec();
        
        exec() 函数是一个阻塞函数，当对话框关闭时，它返回 QDialog::Accepted 或 QDialog::Rejected，分别表示用户点击了“确定”按钮或“取消”按钮。
        
        完整示例：
        以下是一个完整的Qt应用程序，演示了如何创建一个简单的模态对话框：
        
        #include #include #include #include #include #include int main(int argc, char *argv[]) { QApplication app(argc, argv); QDialog dialog; dialog.setWindowTitle("Modal Dialog Example"); QVBoxLayout *layout = new QVBoxLayout(&dialog); QLabel *label = new QLabel("This is a modal dialog.", &dialog); layout->addWidget(label); QPushButton *okButton = new QPushButton("OK", &dialog); layout->addWidget(okButton); QPushButton *closeButton = new QPushButton("close", &dialog); layout->addWidget(closeButton); QObject::connect(okButton, &QPushButton::clicked, [&dialog]() { dialog.accept(); // 关闭对话框并返回 QDialog::Accepted }); QObject::connect(closeButton, &QPushButton::clicked, [&dialog]() { dialog.reject(); // 关闭对话框并返回 QDialog::Rejected }); int result = dialog.exec(); // 显示模态对话框 if (result == QDialog::Accepted) { qInfo() qInfo() Q_OBJECT public: CustomDialog(QWidget *parent = nullptr); // 添加自定义的成员函数和变量 }; QVBoxLayout *layout = new QVBoxLayout(this); QLabel *label = new QLabel("This is a custom dialog.", this); layout-addWidget(label); QPushButton *okButton = new QPushButton("OK", this); layout-addWidget(okButton); connect(okButton, SIGNAL(clicked()), this, SLOT(accept())); }
        
        在这个例子中，我们创建了一个包含标签和“OK”按钮的自定义对话框。
        
        在应用程序中使用自定义对话框：
        
        CustomDialog dialog; dialog.exec(); // 显示自定义对话框
        
        这个代码将创建自定义对话框的实例，并显示它。
        
        这是一个非常基本的例子，你可以根据需要在自定义对话框中添加更多的控件和逻辑。
        
        完整示例：
        以下是一个完整的Qt应用程序，演示了如何创建一个简单的自定义对话框：
        
        #include #include #include #include #include class CustomDialog : public QDialog { Q_OBJECT public: CustomDialog(QWidget *parent = nullptr); ~CustomDialog(){} }; CustomDialog::CustomDialog(QWidget *parent ): QDialog(parent) { QVBoxLayout *layout = new QVBoxLayout(this); QLabel *label = new QLabel("This is a custom dialog.", this); layout->addWidget(label); QPushButton *okButton = new QPushButton("OK", this); layout->addWidget(okButton); connect(okButton, SIGNAL(clicked()), this, SLOT(accept())); }; int main(int argc, char *argv[]) { QApplication app(argc, argv); CustomDialog dialog; dialog.exec(); // 显示自定义对话框 return app.exec(); } #include "main.moc"
        
        在这个示例中，当你运行应用程序时，它将显示一个自定义对话框，包含一个标签和一个“OK”按钮。当用户点击“OK”按钮时，对话框将关闭。你可以根据自己的需求进一步扩展和定制自定义对话框。
        
        七、布局
        
        在Qt中，布局（Layout）用于自动安排窗口部件（例如按钮、文本框、标签等）的位置和大小，以便在不同尺寸的窗口中保持良好的外观和用户体验。Qt提供了几种常见的布局管理器，用于在窗口中创建各种复杂的布局。以下是一些常用的布局管理器：
        
        7.1 水平布局（QHBoxLayout）
        
        在Qt中，水平布局（QHBoxLayout）是一种常用的布局管理器，用于将窗口部件水平排列。以下是如何使用水平布局的基本步骤：
        
        创建水平布局：
        #include QWidget *widget = new QWidget(); QHBoxLayout *layout = new QHBoxLayout(widget);
        
        在这个例子中，我们创建了一个QWidget实例，然后为这个窗口部件设置了一个水平布局。
        
        向水平布局中添加窗口部件：
        QPushButton *button1 = new QPushButton("Button 1"); QPushButton *button2 = new QPushButton("Button 2"); layout->addWidget(button1); layout->addWidget(button2);
        
        使用addWidget函数，将按钮button1和button2添加到水平布局中。这些按钮将会水平排列，从左到右。
        
        设置父窗口部件的布局为水平布局：
        widget->setLayout(layout);
        
        将水平布局设置为widget窗口部件的布局管理器。
        
        完整的示例代码如下：
        
        #include #include #include #include int main(int argc, char *argv[]) { QApplication app(argc, argv); QWidget *widget = new QWidget(); QHBoxLayout *layout = new QHBoxLayout(widget); QPushButton *button1 = new QPushButton("Button 1"); QPushButton *button2 = new QPushButton("Button 2"); layout->addWidget(button1); layout->addWidget(button2); widget->setLayout(layout); widget->show(); return app.exec(); }
        
        在这个示例中，两个按钮Button 1和Button 2水平排列在窗口中。你可以根据需要在水平布局中添加更多的窗口部件，它们将会从左到右水平排列。
        
        7.2 垂直布局（QVBoxLayout）
        
        在Qt中，垂直布局（QVBoxLayout）是一种常用的布局管理器，用于将窗口部件垂直排列。以下是如何使用垂直布局的基本步骤：
        
        创建垂直布局：
        #include QWidget *widget = new QWidget(); QVBoxLayout *layout = new QVBoxLayout(widget);
        
        在这个例子中，我们创建了一个QWidget实例，然后为这个窗口部件设置了一个垂直布局。
        
        向垂直布局中添加窗口部件：
        QPushButton *button1 = new QPushButton("Button 1"); QPushButton *button2 = new QPushButton("Button 2"); layout->addWidget(button1); layout->addWidget(button2);
        
        使用addWidget函数，将按钮button1和button2添加到垂直布局中。这些按钮将会垂直排列，从上到下。
        
        设置父窗口部件的布局为垂直布局：
        widget->setLayout(layout);
        
        将垂直布局设置为widget窗口部件的布局管理器。
        
        完整的示例代码如下：
        
        #include #include #include #include int main(int argc, char *argv[]) { QApplication app(argc, argv); QWidget *widget = new QWidget(); QVBoxLayout *layout = new QVBoxLayout(widget); QPushButton *button1 = new QPushButton("Button 1"); QPushButton *button2 = new QPushButton("Button 2"); layout->addWidget(button1); layout->addWidget(button2); widget->setLayout(layout); widget->show(); return app.exec(); }
        
        在这个示例中，两个按钮Button 1和Button 2垂直排列在窗口中。你可以根据需要在垂直布局中添加更多的窗口部件，它们将会从上到下垂直排列。
        
        7.3 网格布局（QGridLayout）
        
        在Qt中，网格布局（QGridLayout）是一种常用的布局管理器，用于将窗口部件按行和列排列在一个二维网格中。以下是如何使用网格布局的基本步骤：
        
        *创建网格布局：
        #include QWidget *widget = new QWidget(); QGridLayout *layout = new QGridLayout(widget);
        
        在这个例子中，我们创建了一个QWidget实例，然后为这个窗口部件设置了一个网格布局。
        
        向网格布局中添加窗口部件：
        QPushButton *button1 = new QPushButton("Button 1"); QPushButton *button2 = new QPushButton("Button 2"); QPushButton *button3 = new QPushButton("Button 3"); layout->addWidget(button1, 0, 0); // 第一行，第一列 layout->addWidget(button2, 0, 1); // 第一行，第二列 layout->addWidget(button3, 1, 0, 1, 2); // 第二行，从第一列开始，占据两列
        
        使用addWidget函数，将按钮button1、button2和button3添加到网格布局中。这些按钮将会在网格的相应位置上排列。
        
        设置父窗口部件的布局为网格布局：
        widget->setLayout(layout);
        
        将网格布局设置为widget窗口部件的布局管理器。
        
        完整的示例代码如下：
        
        #include #include #include #include int main(int argc, char *argv[]) { QApplication app(argc, argv); QWidget *widget = new QWidget(); QGridLayout *layout = new QGridLayout(widget); QPushButton *button1 = new QPushButton("Button 1"); QPushButton *button2 = new QPushButton("Button 2"); QPushButton *button3 = new QPushButton("Button 3"); layout->addWidget(button1, 0, 0); // 第一行，第一列 layout->addWidget(button2, 0, 1); // 第一行，第二列 layout->addWidget(button3, 1, 0, 1, 2); // 第二行，从第一列开始，占据两列 widget->setLayout(layout); widget->show(); return app.exec(); }
        
        在这个示例中，三个按钮按照网格布局排列在窗口中。你可以根据需要在网格布局中添加更多的窗口部件，它们将会在网格的相应位置上排列。
        
        7.4 栈布局（QStackedLayout）
        
        在Qt中，栈布局（QStackedLayout）是一种布局管理器，用于在同一个位置上显示一次只一个窗口部件。只有当前可见的窗口部件会被显示，其他的窗口部件会被隐藏。栈布局类似于堆栈的行为，允许你在同一区域快速切换不同的窗口内容。
        
        以下是如何使用栈布局的基本步骤：
        
        创建栈布局：
        #include QWidget *widget = new QWidget(); QStackedLayout *layout = new QStackedLayout(widget);
        
        在这个例子中，我们创建了一个QWidget实例，然后为这个窗口部件设置了一个栈布局。
        
        向栈布局中添加窗口部件：
        QPushButton *button1 = new QPushButton("Page 1"); QPushButton *button2 = new QPushButton("Page 2"); QPushButton *button3 = new QPushButton("Page 3"); layout->addWidget(button1); layout->addWidget(button2); layout->addWidget(button3);
        
        使用addWidget函数，将按钮button1、button2和button3添加到栈布局中。它们将会成为栈布局的页面。
        
        切换显示的窗口部件：
        layout->setCurrentIndex(1); // 显示第二个窗口部件（索引从0开始）
        
        使用setCurrentIndex函数，你可以指定要显示的窗口部件的索引。在这个例子中，它将会显示第二个窗口部件。
        
        设置父窗口部件的布局为栈布局：
        widget->setLayout(layout);
        
        将栈布局设置为widget窗口部件的布局管理器。
        
        完整的示例代码如下：
        
        #include #include #include #include int main(int argc, char *argv[]) { QApplication app(argc, argv); QWidget *widget = new QWidget(); QStackedLayout *layout = new QStackedLayout(widget); QPushButton *button1 = new QPushButton("Page 1"); QPushButton *button2 = new QPushButton("Page 2"); QPushButton *button3 = new QPushButton("Page 3"); layout->addWidget(button1); layout->addWidget(button2); layout->addWidget(button3); layout->setCurrentIndex(1); // 初始显示第二个窗口部件 widget->setLayout(layout); widget->show(); return app.exec(); }
        
        在这个示例中，按钮Page 1、Page 2和Page 3成为栈布局的页面，初始时显示第二个页面（索引为1）。你可以通过调用setCurrentIndex来切换显示不同的页面。
        
        7.5 表单布局（QFormLayout）
        
        在Qt中，表单布局（QFormLayout）是一种常用的布局管理器，用于创建标签-字段的布局。表单布局通常用于显示标签和与之相关联的输入字段，提供一种简洁且易于阅读的界面设计。
        
        以下是如何使用表单布局的基本步骤：
        
        创建表单布局：
        #include QWidget *widget = new QWidget(); QFormLayout *layout = new QFormLayout(widget);
        
        在这个例子中，我们创建了一个QWidget实例，然后为这个窗口部件设置了一个表单布局。
        
        向表单布局中添加标签和输入字段：
        QLabel *label1 = new QLabel("Label 1:"); QLineEdit *lineEdit1 = new QLineEdit(); QLabel *label2 = new QLabel("Label 2:"); QLineEdit *lineEdit2 = new QLineEdit(); layout->addRow(label1, lineEdit1); layout->addRow(label2, lineEdit2);
        
        使用addRow函数，将标签和输入字段作为一行添加到表单布局中。每一行的第一个参数是标签，第二个参数是相应的输入字段（例如文本框、下拉框等）。
        
        设置父窗口部件的布局为表单布局：
        widget->setLayout(layout);
        
        将表单布局设置为widget窗口部件的布局管理器。
        
        完整的示例代码如下：
        
        #include #include #include #include #include int main(int argc, char *argv[]) { QApplication app(argc, argv); QWidget *widget = new QWidget(); QFormLayout *layout = new QFormLayout(widget); QLabel *label1 = new QLabel("Label 1:"); QLineEdit *lineEdit1 = new QLineEdit(); QLabel *label2 = new QLabel("Label 2:"); QLineEdit *lineEdit2 = new QLineEdit(); layout->addRow(label1, lineEdit1); layout->addRow(label2, lineEdit2); widget->setLayout(layout); widget->show(); return app.exec(); }
        
        在这个示例中，标签和输入字段被组织成为一个简单的表单布局。你可以根据需要添加更多的标签和输入字段，它们将会以表单的形式显示在窗口中。
        
        八、常用控件
        
        Qt 提供了丰富的控件（Widgets）库，可以用于构建各种不同类型的应用程序界面。以下是一些常用的 Qt 控件：
        
        8.1 QPushButton（按钮）
        
        QPushButton 是 Qt 中用于创建按钮的类。它允许用户触发特定的操作或者执行功能。下面是如何使用 QPushButton 的说明和一个简单的示例：
        
        QPushButton 的基本用法：
        
        创建 QPushButton 对象：
        
        #include
        
        初始化 QPushButton：
        
        QPushButton *button = new QPushButton("Click Me", this);
        
        这里创建了一个按钮，按钮上的文字是 “Click Me”。
        
        连接按钮的点击事件到槽函数：
        
        connect(button, SIGNAL(clicked()), this, SLOT(onButtonClicked()));
        
        这里使用 connect() 函数将按钮的 clicked() 信号连接到一个槽函数 onButtonClicked()。当按钮被点击时，onButtonClicked() 函数将会被调用。
        
        实现槽函数：
        
        void MyClass::onButtonClicked() { qDebug() show();
        
        最后，记得要将按钮显示在窗口上。
        
        完整的示例：
        下面是一个完整的例子，演示了如何创建一个窗口，包含一个按钮，当按钮被点击时，输出一条信息。
        
        #include #include #include #include class MyWidget : public QWidget { Q_OBJECT public: MyWidget(QWidget *parent = nullptr) : QWidget(parent) { QPushButton *button = new QPushButton("Click Me", this); connect(button, SIGNAL(clicked()), this, SLOT(onButtonClicked())); } private slots: void onButtonClicked() { qDebug() QApplication app(argc, argv); MyWidget widget; widget.show(); return app.exec(); }
        p在这个示例中，创建了一个 MyWidget 类，它继承自 QWidget。在构造函数中，创建了一个按钮并将其点击信号连接到了 onButtonClicked() 槽函数。当按钮被点击时，槽函数将会被调用，输出 “Button Clicked!”。最后，widget.show() 显示了窗口和按钮。/p p在你的实际应用程序中，你可以将按钮的点击事件连接到任何你需要执行的函数，使得按钮的点击触发相关的操作。/ppimg src="https://img-blog.csdnimg.cn/1cf01c12b8e1462db3115e773bdaacfd.png" //p h38.2 QLabel（标签）/h3 pQLabel 是 Qt 中用于显示文本或图像的控件。它可以显示纯文本、HTML 格式的文本，或者显示图像。下面是如何使用 QLabel 的说明和一个简单的示例：/p ulliQLabel 的基本用法： olli p创建 QLabel 对象：/p pre class="brush:python;toolbar:false"#include QLabel /pre /lili p初始化 QLabel：/p pre class="brush:python;toolbar:false"QLabel *label = new QLabel("Hello, World!", this); /pre p这里创建了一个 QLabel，显示文本 “Hello, World!”。/p /lili p设置文本：/p pre class="brush:python;toolbar:false"label->setText("New Text");
        你可以使用 setText() 函数设置 QLabel 的文本内容。
        
        显示图像：
        
        label->setPixmap(QPixmap("path/to/your/image.png"));
        
        如果你想显示图像，你可以使用 setPixmap() 函数，传入一个 QPixmap 对象或者一个图像文件的路径。
        
        显示 HTML 格式的文本：
        
        label->setText("Bold Text");
        
        你可以使用 HTML 标签来设置 QLabel 的文本，这使得你可以显示粗体、斜体等样式。
        
        自动换行：
        
        label->setWordWrap(true);
        
        如果文本内容过长，你可以启用自动换行，使得文本在 QLabel 内自动换行显示。
        
        设置对齐方式：
        
        label->setAlignment(Qt::AlignCenter);
        
        你可以使用 setAlignment() 函数设置文本的对齐方式，例如居中对齐。
        
        设置链接：
        
        label->setText("Click Here"); label->setOpenExternalLinks(true);
        
        你可以将文本设置为一个超链接，当用户点击时，会在默认的浏览器中打开链接。
        
        完整的示例：
        下面是一个完整的例子，演示了如何创建一个窗口，包含一个 QLabel，并设置文本和图像：
        
        #include #include #include #include #include int main(int argc, char *argv[]) { QApplication app(argc, argv); QWidget *window = new QWidget(); window->setWindowTitle("QLabel Example"); window->setMinimumSize(500,500); QLabel *label1 = new QLabel(window); label1->setText("Hello, World!"); // 设置加粗文本 label1->setAlignment(Qt::AlignCenter); // 居中对齐 label1->setWordWrap(true); // 自动换行 QLabel *label2 = new QLabel(window); label2->setPixmap(QPixmap(":/pikaqiu.jpeg")); // 显示图像 QVBoxLayout *layout = new QVBoxLayout(window); layout->addWidget(label1); layout->addWidget(label2); window->setLayout(layout); window->show(); return app.exec(); }
        
        在这个示例中，创建了一个窗口 window 和一个 QLabel 控件 label。label 显示了加粗的文本和一个图像。你可以根据需要修改文本内容和图像路径。
        
        8.3 QLineEdit（单行文本框）
        
        QLineEdit 是 Qt 中用于单行文本输入的控件。它允许用户在单行中输入和编辑文本。以下是如何使用 QLineEdit 的说明和一个简单的示例：
        
        QLineEdit 的基本用法：
        
        创建 QLineEdit 对象：
        
        #include
        
        初始化 QLineEdit：
        
        QLineEdit *lineEdit = new QLineEdit(this);
        
        这里创建了一个 QLineEdit 控件。
        
        设置默认文本：
        
        lineEdit->setText("Default Text");
        
        你可以使用 setText() 函数设置 QLineEdit 的默认文本。
        
        获取文本内容：
        
        QString text = lineEdit->text();
        
        使用 text() 函数可以获取 QLineEdit 中的文本内容。
        
        设置输入掩码（例如，只允许输入数字）：
        
        lineEdit->setInputMask("999"); // 只允许输入数字，可以输入三位数字
        
        使用 setInputMask() 函数可以限制输入的格式。
        
        设置占位符文本（Placeholder Text）：
        
        lineEdit->setPlaceholderText("Enter your text here");
        
        使用 setPlaceholderText() 函数可以在 QLineEdit 中显示一个占位符文本，当没有输入时显示。
        
        设置输入限制（例如，最大长度）：
        
        lineEdit->setMaxLength(10); // 最多输入10个字符
        
        使用 setMaxLength() 函数可以限制输入的最大长度。
        
        密码模式：
        
        lineEdit->setEchoMode(QLineEdit::Password); // 将输入内容显示为密码字符（例如，*）
        
        使用 setEchoMode() 函数可以将输入内容显示为密码字符，以保护敏感信息。
        
        完整的示例：
        下面是一个完整的例子，演示了如何创建一个窗口，包含一个 QLineEdit 控件：
        
        #include #include #include int main(int argc, char *argv[]) { QApplication app(argc, argv); QWidget window; window.setWindowTitle("QLineEdit Example"); window.setMinimumSize(500,500); QLineEdit *lineEdit = new QLineEdit(&window); lineEdit->setPlaceholderText("Enter your text here"); // 占位符文本 lineEdit->setMaxLength(10); // 最多输入10个字符 window.show(); return app.exec(); }
        
        在这个示例中，创建了一个窗口 window 和一个 QLineEdit 控件 lineEdit。lineEdit 设置了占位符文本（“Enter your text here”）并且限制了最大输入长度为10个字符。你可以根据需要修改占位符文本和最大输入长度。
        
        8.4 QTextEdit（多行文本框）
        
        QTextEdit 是 Qt 中用于多行文本输入和显示的控件，允许用户输入和编辑多行文本。以下是如何使用 QTextEdit 的说明和一个简单的示例：
        
        使用说明：
        
        创建 QTextEdit 对象：
        
        #include
        
        初始化 QTextEdit：
        
        QTextEdit *textEdit = new QTextEdit(this);
        
        这里创建了一个 QTextEdit 控件。
        
        设置文本内容：
        
        textEdit->setText("Default Text");
        
        使用 setText() 函数可以设置 QTextEdit 的默认文本内容。
        
        获取文本内容：
        
        QString text = textEdit->toPlainText();
        
        使用 toPlainText() 函数可以获取 QTextEdit 中的文本内容。
        
        添加文本内容：
        
        textEdit->append("New Line");
        
        使用 append() 函数可以在现有文本的末尾添加新的文本行。
        
        清空文本内容：
        
        textEdit->clear();
        
        使用 clear() 函数可以清空 QTextEdit 中的文本内容。
        
        插入文本：
        
        textEdit->insertPlainText("Inserted Text");
        
        使用 insertPlainText() 函数可以在当前光标位置插入文本。
        
        字体和格式设置：
        
        QTextCursor cursor = textEdit->textCursor(); QTextCharFormat format; format.setFontWeight(QFont::Bold); cursor.mergeCharFormat(format);
        
        使用 QTextCursor 可以进行更高级的文本格式化，例如设置字体、颜色、加粗等。
        
        示例代码：
        
        下面是一个简单的示例，演示了如何创建一个窗口，包含一个 QTextEdit 控件：
        
        #include #include #include int main(int argc, char *argv[]) { QApplication app(argc, argv); QWidget window; window.setWindowTitle("QTextEdit Example"); window.setMinimumSize(400,400); QTextEdit *textEdit = new QTextEdit(&window); textEdit->setText("Default Text"); window.show(); return app.exec(); }
        
        在这个示例中，创建了一个窗口 window 和一个 QTextEdit 控件 textEdit。textEdit 设置了默认文本内容为 “Default Text”。你可以在 QTextEdit 中输入新的文本，也可以使用 setText()、append()、clear() 等函数来操作文本内容。
        
        8.5 QSpinBox（数值输入框）
        
        QSpinBox 是 Qt 中用于输入整数值的控件，用户可以通过上下箭头或手动输入的方式选择整数值。以下是如何使用 QSpinBox 的说明和一个简单的示例：
        
        使用说明：
        
        创建 QSpinBox 对象：
        
        #include
        
        初始化 QSpinBox：
        
        QSpinBox *spinBox = new QSpinBox(this);
        
        这里创建了一个 QSpinBox 控件。
        
        设置范围：
        
        spinBox->setMinimum(0); spinBox->setMaximum(100);
        
        使用 setMinimum() 和 setMaximum() 函数可以设置 QSpinBox 允许的最小和最大值。
        
        获取当前值：
        
        int value = spinBox->value();
        
        使用 value() 函数可以获取 QSpinBox 中的当前值。
        
        设置步长：
        
        spinBox->setSingleStep(1);
        
        使用 setSingleStep() 函数可以设置每次点击上下箭头时增减的步长值。
        
        示例代码：
        
        下面是一个简单的示例，演示了如何创建一个窗口，包含一个 QSpinBox 控件：
        
        #include #include #include #include int main(int argc, char *argv[]) { QApplication app(argc, argv); QWidget window; window.setWindowTitle("QSpinBox Example"); QVBoxLayout *layout = new QVBoxLayout(&window); QSpinBox *spinBox = new QSpinBox(&window); spinBox->setRange(0, 100); // 设置范围为 0 到 100 spinBox->setSingleStep(1); // 步长为 1 layout->addWidget(spinBox); window.setLayout(layout); window.show(); return app.exec(); }
        
        在这个示例中，创建了一个窗口 window 和一个 QSpinBox 控件 spinBox。spinBox 设置了范围为 0 到 100，步长为 1。你可以通过上下箭头或手动输入的方式选择整数值。
        
        8.6 QDoubleSpinBox（双精度浮点数输入框）
        
        QDoubleSpinBox 是 Qt 中用于输入双精度浮点数（即小数）的控件。它允许用户通过上下箭头或手动输入的方式选择浮点数值。以下是如何使用 QDoubleSpinBox 的说明和一个简单的示例：
        
        使用说明：
        
        创建 QDoubleSpinBox 对象：
        
        #include
        
        初始化 QDoubleSpinBox：
        
        QDoubleSpinBox *doubleSpinBox = new QDoubleSpinBox(this);
        
        这里创建了一个 QDoubleSpinBox 控件。
        
        设置范围和精度：
        
        doubleSpinBox->setMinimum(0.0); doubleSpinBox->setMaximum(100.0); doubleSpinBox->setSingleStep(0.1); // 设置步长为0.1 doubleSpinBox->setDecimals(2); // 设置小数点后的位数
        
        使用 setMinimum() 和 setMaximum() 函数可以设置 QDoubleSpinBox 允许的最小和最大值。setSingleStep() 函数设置了步长，setDecimals() 函数设置了显示的小数点后的位数。
        
        获取当前值：
        
        double value = doubleSpinBox->value();
        
        使用 value() 函数可以获取 QDoubleSpinBox 中的当前值。
        
        示例代码：
        
        下面是一个简单的示例，演示了如何创建一个窗口，包含一个 QDoubleSpinBox 控件：
        
        #include #include #include #include int main(int argc, char *argv[]) { QApplication app(argc, argv); QWidget window; window.setWindowTitle("QDoubleSpinBox Example"); QVBoxLayout *layout = new QVBoxLayout(&window); QDoubleSpinBox *doubleSpinBox = new QDoubleSpinBox(&window); doubleSpinBox->setRange(0.0, 100.0); // 设置范围为 0 到 100 doubleSpinBox->setSingleStep(0.1); // 步长为 0.1 doubleSpinBox->setDecimals(2); // 小数点后保留两位 layout->addWidget(doubleSpinBox); window.setLayout(layout); window.show(); return app.exec(); }
        
        在这个示例中，创建了一个窗口 window 和一个 QDoubleSpinBox 控件 doubleSpinBox。doubleSpinBox 设置了范围为 0 到 100，步长为 0.1，小数点后保留两位。你可以通过上下箭头或手动输入的方式选择浮点数值。
        
        8.7 QComboBox（下拉框）
        
        QComboBox 是 Qt 中用于显示下拉菜单的控件，用户可以从预定义的选项中选择一个。以下是如何使用 QComboBox 的说明和一个简单的示例：
        
        使用说明：
        
        创建 QComboBox 对象：
        
        #include
        
        初始化 QComboBox：
        
        QComboBox *comboBox = new QComboBox(this);
        
        这里创建了一个 QComboBox 控件。
        
        添加选项：
        
        comboBox->addItem("Option 1"); comboBox->addItem("Option 2");
        
        使用 addItem() 函数可以添加选项。你也可以使用 addItems() 函数同时添加多个选项。
        
        获取当前选中的文本或索引：
        
        QString selectedText = comboBox->currentText(); int selectedIndex = comboBox->currentIndex();
        
        使用 currentText() 函数可以获取当前选中的文本，currentIndex() 函数可以获取当前选中的索引。
        
        设置默认选中的选项：
        
        comboBox->setCurrentIndex(1); // 默认选中第二个选项
        
        使用 setCurrentIndex() 函数可以设置默认选中的选项索引。
        
        处理选中事件：
        
        connect(comboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onComboBoxIndexChanged(int)));
        
        使用 currentIndexChanged(int) 信号可以捕获选项改变的事件，将其连接到一个槽函数中以处理选中事件。
        
        示例代码：
        
        下面是一个简单的示例，演示了如何创建一个窗口，包含一个 QComboBox 控件：
        
        #include #include #include #include #include class MyWidget : public QWidget { Q_OBJECT public: MyWidget(QWidget *parent = nullptr) : QWidget(parent) { QVBoxLayout *layout = new QVBoxLayout(this); QComboBox *comboBox = new QComboBox(this); comboBox->addItem("Option 1"); comboBox->addItem("Option 2"); comboBox->addItem("Option 3"); connect(comboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onComboBoxIndexChanged(int))); layout->addWidget(comboBox); setLayout(layout); } private slots: void onComboBoxIndexChanged(int index) { qDebug() QApplication app(argc, argv); MyWidget widget; widget.setWindowTitle("QComboBox Example"); widget.show(); return app.exec(); } Q_OBJECT public: MyWidget(QWidget *parent = nullptr) : QWidget(parent) { QVBoxLayout *layout = new QVBoxLayout(this); QCheckBox *checkBox = new QCheckBox("Enable Option", this); connect(checkBox, SIGNAL(stateChanged(int)), this, SLOT(onCheckBoxStateChanged(int))); layout-addWidget(checkBox); setLayout(layout); } private slots: void onCheckBoxStateChanged(int state) { if (state == Qt::Checked) { qDebug() qDebug() QApplication app(argc, argv); MyWidget widget; widget.setWindowTitle("QCheckBox Example"); widget.show(); return app.exec(); } #include "main.moc" Q_OBJECT public: MyWidget(QWidget *parent = nullptr) : QWidget(parent) { QVBoxLayout *layout = new QVBoxLayout(this); QRadioButton *radioButton1 = new QRadioButton("Option 1", this); QRadioButton *radioButton2 = new QRadioButton("Option 2", this); connect(radioButton1, SIGNAL(clicked()), this, SLOT(onRadioButtonClicked())); connect(radioButton2, SIGNAL(clicked()), this, SLOT(onRadioButtonClicked())); layout-addWidget(radioButton1); layout->addWidget(radioButton2); setLayout(layout); } private slots: void onRadioButtonClicked() { QRadioButton *radioButton = qobject_cast(sender()); if (radioButton) { qDebug() QApplication app(argc, argv); MyWidget widget; widget.setWindowTitle("QRadioButton Example"); widget.show(); return app.exec(); } #include "main.moc"
        p在这个示例中，创建了一个窗口 widget 和两个 QRadioButton 控件 radioButton1 和 radioButton2。当用户点击其中一个单选按钮时，onRadioButtonClicked() 槽函数将会被调用，输出被选中的选项文本。/ppimg src="https://img-blog.csdnimg.cn/ba9518cfd0f9427c96516bc2b1784f21.png" //p h38.10 QSlider（滑块）/h3 pQSlider 是 Qt 中用于选择一个数值范围内的整数值的滑动条控件。它允许用户在一个范围内滑动滑块，选择一个整数值。以下是如何使用 QSlider 的说明和一个简单的示例：/p p使用说明：/p olli p创建 QSlider 对象：/p pre class="brush:python;toolbar:false"#include QSlider /pre /lili p初始化 QSlider：/p pre class="brush:python;toolbar:false"QSlider *slider = new QSlider(Qt::Horizontal, this); // 水平滑动条 // 或者 // QSlider *slider = new QSlider(Qt::Vertical, this); // 垂直滑动条 /pre p这里创建了一个 QSlider 控件，可以选择水平或垂直方向的滑动条。/p /lili p设置范围和步长：/p pre class="brush:python;toolbar:false"slider->setMinimum(0); slider->setMaximum(100); slider->setSingleStep(1); // 步长为1
        使用 setMinimum() 和 setMaximum() 函数可以设置滑动条的最小和最大值。使用 setSingleStep() 函数可以设置滑动条的步长。
        
        获取当前值：
        
        int value = slider->value();
        
        使用 value() 函数可以获取 QSlider 中的当前值。
        
        处理值变化事件：
        
        connect(slider, SIGNAL(valueChanged(int)), this, SLOT(onSliderValueChanged(int)));
        
        使用 valueChanged(int) 信号可以捕获滑动条值的变化，将其连接到一个槽函数中以处理值变化事件。
        
        示例代码：
        
        下面是一个简单的示例，演示了如何创建一个窗口，包含一个水平的 QSlider 控件：
        
        #include #include #include #include #include class MyWidget : public QWidget { Q_OBJECT public: MyWidget(QWidget *parent = nullptr) : QWidget(parent) { QVBoxLayout *layout = new QVBoxLayout(this); QSlider *slider = new QSlider(Qt::Horizontal, this); slider->setRange(0, 100); // 设置范围为 0 到 100 slider->setSingleStep(1); // 步长为 1 connect(slider, SIGNAL(valueChanged(int)), this, SLOT(onSliderValueChanged(int))); layout->addWidget(slider); setLayout(layout); } private slots: void onSliderValueChanged(int value) { qDebug() QApplication app(argc, argv); MyWidget widget; widget.setWindowTitle("QSlider Example"); widget.show(); return app.exec(); } #include "main.moc"
        p在这个示例中，创建了一个窗口 widget 和一个水平的 QSlider 控件 slider。当用户滑动滑块时，onSliderValueChanged(int value) 槽函数将会被调用，输出滑块的当前值。/ppimg src="https://img-blog.csdnimg.cn/14590a83d8184e798ec3071848385496.png" //p h38.11 QProgressBar（进度条）/h3 pQProgressBar 是 Qt 中用于显示任务进度的控件，它可以用来展示任务的完成百分比或进度。以下是如何使用 QProgressBar 的说明和一个简单的示例：/p p使用说明：/p olli p创建 QProgressBar 对象：/p pre class="brush:python;toolbar:false"#include QProgressBar /pre /lili p初始化 QProgressBar：/p pre class="brush:python;toolbar:false"QProgressBar *progressBar = new QProgressBar(this); /pre p这里创建了一个 QProgressBar 控件。/p /lili p设置范围和当前值：/p pre class="brush:python;toolbar:false"progressBar-setRange(0, 100); // 设置范围为 0 到 100 progressBar->setValue(50); // 设置当前值为 50
        使用 setRange() 函数可以设置进度条的范围，setValue() 函数可以设置当前的进度值。
        
        更新进度：
        
        progressBar->setValue(newValue);
        
        使用 setValue() 函数可以更新进度条的值，以反映任务的当前进度。
        
        示例代码：
        
        下面是一个简单的示例，演示了如何创建一个窗口，包含一个 QProgressBar 控件：
        
        #include #include #include #include #include class MyWidget : public QWidget { Q_OBJECT public: MyWidget(QWidget *parent = nullptr) : QWidget(parent) { QVBoxLayout *layout = new QVBoxLayout(this); QProgressBar *progressBar = new QProgressBar(this); progressBar->setRange(0, 100); // 设置范围为 0 到 100 progressBar->setValue(0); // 初始值为 0 layout->addWidget(progressBar); setLayout(layout); // 模拟任务进度的更新 QTimer *timer = new QTimer(this); connect(timer, SIGNAL(timeout()), this, SLOT(updateProgress())); timer->start(1000); // 每秒更新一次进度 } private slots: void updateProgress() { QProgressBar *progressBar = findChild(); if (progressBar) { int currentValue = progressBar->value(); if (currentValue setValue(currentValue + 10); // 每次增加 10 } } } }; int main(int argc, char *argv[]) { QApplication app(argc, argv); MyWidget widget; widget.setWindowTitle("QProgressBar Example"); widget.show(); return app.exec(); } #include "main.moc"
        
        在这个示例中，创建了一个窗口 widget 和一个 QProgressBar 控件 progressBar。使用 QTimer 模拟任务的进度更新，每秒钟增加 10。你可以根据需要修改更新的速度和增加的数值。
        
        8.12 QDateEdit（日期输入框）
        
        QDateEdit 是 Qt 中用于选择日期的控件，它允许用户通过图形界面选择特定的日期。以下是如何使用 QDateEdit 的说明和一个简单的示例：
        
        使用说明：
        
        创建 QDateEdit 对象：
        
        #include
        
        初始化 QDateEdit：
        
        QDateEdit *dateEdit = new QDateEdit(this);
        
        这里创建了一个 QDateEdit 控件。
        
        设置日期范围和默认日期：
        
        dateEdit->setDateRange(QDate(2000, 1, 1), QDate(2100, 12, 31)); // 设置日期范围 dateEdit->setDate(QDate::currentDate()); // 设置默认日期为当前日期
        
        使用 setDateRange() 函数可以设置日期的范围。使用 setDate() 函数可以设置默认的日期。
        
        获取选择的日期：
        
        QDate selectedDate = dateEdit->date();
        
        使用 date() 函数可以获取用户选择的日期。
        
        示例代码：
        
        下面是一个简单的示例，演示了如何创建一个窗口，包含一个 QDateEdit 控件：
        
        #include #include #include #include #include class MyWidget : public QWidget { Q_OBJECT public: MyWidget(QWidget *parent = nullptr) : QWidget(parent) { QVBoxLayout *layout = new QVBoxLayout(this); QDateEdit *dateEdit = new QDateEdit(this); dateEdit->setDateRange(QDate(2000, 1, 1), QDate(2100, 12, 31)); // 设置日期范围 dateEdit->setDate(QDate::currentDate()); // 设置默认日期为当前日期 connect(dateEdit, SIGNAL(dateChanged(const QDate&)), this, SLOT(onDateChanged(const QDate&))); layout->addWidget(dateEdit); setLayout(layout); } private slots: void onDateChanged(const QDate &date) { qDebug() QApplication app(argc, argv); MyWidget widget; widget.setWindowTitle("QDateEdit Example"); widget.show(); return app.exec(); }
        p在这个示例中，创建了一个窗口 widget 和一个 QDateEdit 控件 dateEdit。当用户选择不同的日期时，onDateChanged(const QDate &date) 槽函数将会被调用，输出选择的日期。/p pimg src="https://img-blog.csdnimg.cn/01c1f738307c4a279a54885b4d1ba116.png" //p h38.13 QTimeEdit（时间输入框）/h3 pQTimeEdit 是 Qt 中用于选择时间的控件，它允许用户通过图形界面选择特定的时间。以下是如何使用 QTimeEdit 的说明和一个简单的示例：/p p使用说明：/p olli p创建 QTimeEdit 对象：/p pre class="brush:python;toolbar:false"#include QTimeEdit /pre /lili p初始化 QTimeEdit：/p pre class="brush:python;toolbar:false"QTimeEdit *timeEdit = new QTimeEdit(this); /pre p这里创建了一个 QTimeEdit 控件。/p /lili p设置时间范围和默认时间：/p pre class="brush:python;toolbar:false"timeEdit-setTimeRange(QTime(0, 0, 0), QTime(23, 59, 59)); // 设置时间范围 timeEdit->setTime(QTime::currentTime()); // 设置默认时间为当前时间
        使用 setTimeRange() 函数可以设置时间的范围。使用 setTime() 函数可以设置默认的时间。
        
        获取选择的时间：
        
        QTime selectedTime = timeEdit->time();
        
        使用 time() 函数可以获取用户选择的时间。
        
        示例代码：
        
        下面是一个简单的示例，演示了如何创建一个窗口，包含一个 QTimeEdit 控件：
        
        #include #include #include #include #include class MyWidget : public QWidget { Q_OBJECT public: MyWidget(QWidget *parent = nullptr) : QWidget(parent) { QVBoxLayout *layout = new QVBoxLayout(this); QTimeEdit *timeEdit = new QTimeEdit(this); timeEdit->setTimeRange(QTime(0, 0, 0), QTime(23, 59, 59)); // 设置时间范围 timeEdit->setTime(QTime::currentTime()); // 设置默认时间为当前时间 connect(timeEdit, SIGNAL(timeChanged(const QTime&)), this, SLOT(onTimeChanged(const QTime&))); layout->addWidget(timeEdit); setLayout(layout); } private slots: void onTimeChanged(const QTime &time) { qDebug() QApplication app(argc, argv); MyWidget widget; widget.setWindowTitle("QTimeEdit Example"); widget.show(); return app.exec(); } #include "main.moc"
        p在这个示例中，创建了一个窗口 widget 和一个 QTimeEdit 控件 timeEdit。当用户选择不同的时间时，onTimeChanged(const QTime &time) 槽函数将会被调用，输出选择的时间。/ppimg src="https://img-blog.csdnimg.cn/183bdf2f3d734b03be5df9256e6c7d57.png" //p h38.14 QDateTimeEdit（日期时间输入框）/h3 pQDateTimeEdit 是 Qt 中用于选择日期和时间的控件，它允许用户通过图形界面选择特定的日期和时间。以下是如何使用 QDateTimeEdit 的说明和一个简单的示例：/p p使用说明：/p olli p创建 QDateTimeEdit 对象：/p pre class="brush:python;toolbar:false"#include QDateTimeEdit /pre /lili p初始化 QDateTimeEdit：/p pre class="brush:python;toolbar:false"QDateTimeEdit *dateTimeEdit = new QDateTimeEdit(this); /pre p这里创建了一个 QDateTimeEdit 控件。/p /lili p设置日期和时间范围以及默认日期和时间：/p pre class="brush:python;toolbar:false"dateTimeEdit-setDateRange(QDate(2000, 1, 1), QDate(2100, 12, 31)); // 设置日期范围 dateTimeEdit->setTimeRange(QTime(0, 0, 0), QTime(23, 59, 59)); // 设置时间范围 dateTimeEdit->setDateTime(QDateTime::currentDateTime()); // 设置默认日期和时间为当前日期和时间
        使用 setDateRange() 函数可以设置日期的范围，使用 setTimeRange() 函数可以设置时间的范围。使用 setDateTime() 函数可以设置默认的日期和时间。
        
        获取选择的日期和时间：
        
        QDateTime selectedDateTime = dateTimeEdit->dateTime();
        
        使用 dateTime() 函数可以获取用户选择的日期和时间。
        
        示例代码：
        
        下面是一个简单的示例，演示了如何创建一个窗口，包含一个 QDateTimeEdit 控件：
        
        #include #include #include #include #include class MyWidget : public QWidget { Q_OBJECT public: MyWidget(QWidget *parent = nullptr) : QWidget(parent) { QVBoxLayout *layout = new QVBoxLayout(this); QDateTimeEdit *dateTimeEdit = new QDateTimeEdit(this); dateTimeEdit->setDateRange(QDate(2000, 1, 1), QDate(2100, 12, 31)); // 设置日期范围 dateTimeEdit->setTimeRange(QTime(0, 0, 0), QTime(23, 59, 59)); // 设置时间范围 dateTimeEdit->setDateTime(QDateTime::currentDateTime()); // 设置默认日期和时间为当前日期和时间 connect(dateTimeEdit, SIGNAL(dateTimeChanged(const QDateTime&)), this, SLOT(onDateTimeChanged(const QDateTime&))); layout->addWidget(dateTimeEdit); setLayout(layout); } private slots: void onDateTimeChanged(const QDateTime &dateTime) { qDebug() QApplication app(argc, argv); MyWidget widget; widget.setWindowTitle("QDateTimeEdit Example"); widget.show(); return app.exec(); } #include "main.moc"
        p在这个示例中，创建了一个窗口 widget 和一个 QDateTimeEdit 控件 dateTimeEdit。当用户选择不同的日期和时间时，onDateTimeChanged(const QDateTime &dateTime) 槽函数将会被调用，输出选择的日期和时间。/ppimg src="https://img-blog.csdnimg.cn/5b03a8c9feb64e0a9887d65602295092.png" //p h38.15 QTabWidget（选项卡窗口）/h3 pQTabWidget 是 Qt 中用于显示多个标签页的控件，每个标签页都可以包含不同的内容。用户可以通过点击不同的标签页来切换显示的内容。以下是如何使用 QTabWidget 的说明和一个简单的示例：/p p使用说明：/p olli p创建 QTabWidget 对象：/p pre class="brush:python;toolbar:false"#include QTabWidget /pre /lili p初始化 QTabWidget：/p pre class="brush:python;toolbar:false"QTabWidget *tabWidget = new QTabWidget(this); /pre p这里创建了一个 QTabWidget 控件。/p /lili p添加标签页：/p pre class="brush:python;toolbar:false"QWidget *page1 = new QWidget(); QWidget *page2 = new QWidget(); tabWidget-addTab(page1, "Tab 1"); tabWidget->addTab(page2, "Tab 2");
        使用 addTab() 函数可以向 QTabWidget 中添加标签页，第一个参数是标签页的内容，第二个参数是标签页的名称。
        
        设置当前显示的标签页：
        
        tabWidget->setCurrentIndex(0); // 设置显示第一个标签页
        
        使用 setCurrentIndex() 函数可以设置当前显示的标签页的索引。
        
        示例代码：
        
        下面是一个简单的示例，演示了如何创建一个窗口，包含一个 QTabWidget 控件：
        
        #include #include #include #include #include class MyWidget : public QWidget { Q_OBJECT public: MyWidget(QWidget *parent = nullptr) : QWidget(parent) { QVBoxLayout *layout = new QVBoxLayout(this); QTabWidget *tabWidget = new QTabWidget(this); QWidget *page1 = new QWidget(); QLabel *label1 = new QLabel("Content of Tab 1", page1); QVBoxLayout *page1Layout = new QVBoxLayout(page1); page1Layout->addWidget(label1); page1->setLayout(page1Layout); tabWidget->addTab(page1, "Tab 1"); QWidget *page2 = new QWidget(); QLabel *label2 = new QLabel("Content of Tab 2", page2); QVBoxLayout *page2Layout = new QVBoxLayout(page2); page2Layout->addWidget(label2); page2->setLayout(page2Layout); tabWidget->addTab(page2, "Tab 2"); layout->addWidget(tabWidget); setLayout(layout); } }; int main(int argc, char *argv[]) { QApplication app(argc, argv); MyWidget widget; widget.setWindowTitle("QTabWidget Example"); widget.show(); return app.exec(); } #include "main.moc"
        
        在这个示例中，创建了一个窗口 widget 和一个 QTabWidget 控件 tabWidget。tabWidget 包含两个标签页，每个标签页都包含一个 QLabel 控件，用于显示相应标签页的内容。用户可以通过点击不同的标签页来切换显示的内容。
        
        8.16 QListWidget（列表框）
        
        QListWidget 是 Qt 中用于显示一个可选择的列表的控件，可以包含文本、图标等元素。以下是如何使用 QListWidget 的说明和一个简单的示例：
        
        使用说明：
        
        创建 QListWidget 对象：
        
        #include
        
        初始化 QListWidget：
        
        QListWidget *listWidget = new QListWidget(this);
        
        这里创建了一个 QListWidget 控件。
        
        添加条目：
        
        QListWidgetItem *item1 = new QListWidgetItem("Item 1"); QListWidgetItem *item2 = new QListWidgetItem("Item 2"); listWidget->addItem(item1); listWidget->addItem(item2);
        
        使用 addItem() 函数可以向 QListWidget 中添加条目，每个条目可以是一个 QListWidgetItem 对象。
        
        处理条目选择事件：
        
        connect(listWidget, SIGNAL(itemClicked(QListWidgetItem*)), this, SLOT(onItemClicked(QListWidgetItem*)));
        
        使用 itemClicked(QListWidgetItem*) 信号可以捕获条目被点击的事件，将其连接到一个槽函数中以处理条目选择事件。
        
        示例代码：
        
        下面是一个简单的示例，演示了如何创建一个窗口，包含一个 QListWidget 控件：
        
        #include #include #include #include #include #include class MyWidget : public QWidget { Q_OBJECT public: MyWidget(QWidget *parent = nullptr) : QWidget(parent) { QVBoxLayout *layout = new QVBoxLayout(this); QListWidget *listWidget = new QListWidget(this); QListWidgetItem *item1 = new QListWidgetItem("Item 1"); QListWidgetItem *item2 = new QListWidgetItem("Item 2"); listWidget->addItem(item1); listWidget->addItem(item2); connect(listWidget, SIGNAL(itemClicked(QListWidgetItem*)), this, SLOT(onItemClicked(QListWidgetItem*))); layout->addWidget(listWidget); setLayout(layout); } private slots: void onItemClicked(QListWidgetItem *item) { qDebug() QApplication app(argc, argv); MyWidget widget; widget.setWindowTitle("QListWidget Example"); widget.show(); return app.exec(); } #include "main.moc"
        p在这个示例中，创建了一个窗口 widget 和一个 QListWidget 控件 listWidget。listWidget 包含两个条目，当用户点击条目时，onItemClicked(QListWidgetItem *item) 槽函数将会被调用，输出被选中的条目文本。/ppimg src="https://img-blog.csdnimg.cn/b028f0f2cb934d269c07c9e513822b5f.png" //p h38.17 QTreeWidget（树形列表框）/h3 pQTreeWidget 是 Qt 中用于显示树形结构的控件，每个节点可以包含子节点。以下是如何使用 QTreeWidget 的说明和一个简单的示例：/p p使用说明：/p olli p创建 QTreeWidget 对象：/p pre class="brush:python;toolbar:false"#include QTreeWidget /pre /lili p初始化 QTreeWidget：/p pre class="brush:python;toolbar:false"QTreeWidget *treeWidget = new QTreeWidget(this); /pre p这里创建了一个 QTreeWidget 控件。/p /lili p添加根节点：/p pre class="brush:python;toolbar:false"QTreeWidgetItem *rootItem = new QTreeWidgetItem(treeWidget); rootItem->setText(0, "Root Node");
        使用 QTreeWidgetItem 类可以创建树节点，使用 setText() 函数可以设置节点的文本内容。
        
        添加子节点：
        
        QTreeWidgetItem *childItem = new QTreeWidgetItem(rootItem); childItem->setText(0, "Child Node");
        
        使用 QTreeWidgetItem 类创建的节点可以作为父节点传递，形成树形结构。
        
        处理节点选择事件：
        
        connect(treeWidget, SIGNAL(itemClicked(QTreeWidgetItem*, int)), this, SLOT(onItemClicked(QTreeWidgetItem*, int)));
        
        使用 itemClicked(QTreeWidgetItem*, int) 信号可以捕获节点被点击的事件，将其连接到一个槽函数中以处理节点选择事件。
        
        示例代码：
        
        以下是一个简单的示例，演示了如何创建一个窗口，包含一个 QTreeWidget 控件：
        
        #include #include #include #include #include #include class MyWidget : public QWidget { Q_OBJECT public: MyWidget(QWidget *parent = nullptr) : QWidget(parent) { QVBoxLayout *layout = new QVBoxLayout(this); QTreeWidget *treeWidget = new QTreeWidget(this); QTreeWidgetItem *rootItem = new QTreeWidgetItem(treeWidget); rootItem->setText(0, "Root Node"); QTreeWidgetItem *childItem = new QTreeWidgetItem(rootItem); childItem->setText(0, "Child Node"); treeWidget->addTopLevelItem(rootItem); connect(treeWidget, SIGNAL(itemClicked(QTreeWidgetItem*, int)), this, SLOT(onItemClicked(QTreeWidgetItem*, int))); layout->addWidget(treeWidget); setLayout(layout); } private slots: void onItemClicked(QTreeWidgetItem *item, int column) { qDebug() QApplication app(argc, argv); MyWidget widget; widget.setWindowTitle("QTreeWidget Example"); widget.show(); return app.exec(); } #include "main.moc" if(event-key() == Qt::Key_Escape) { qDebug() qDebug() qDebug() public: CustomEvent() : QEvent(QEvent::User) {} }; // 发送自定义事件 void MyWidget::sendCustomEvent() { CustomEvent *event = new CustomEvent(); QCoreApplication::sendEvent(this, event); } // 接收和处理自定义事件 bool MyWidget::event(QEvent *event) { if(event-type() == QEvent::User) { qDebug() if (event-key() == Qt::Key_Escape) { qDebug() qDebug() qDebug() if (event-type() == QEvent::User) { qDebug() Q_OBJECT public: explicit EventFilter(QObject *parent = nullptr) : QObject(parent) {} protected: bool eventFilter(QObject *watched, QEvent *event) override { if (watched-isWidgetType() && event-type() == QEvent::MouseButtonPress) { qDebug() QApplication app(argc, argv); QWidget window; window.setWindowTitle("Event Filter Example"); window.setGeometry(100, 100, 300, 200); QPushButton button("Click Me!", &window); button.setGeometry(100, 50, 100, 30); EventFilter eventFilter; // 创建事件过滤器对象 button.installEventFilter(&eventFilter); // 安装事件过滤器 window.show(); return app.exec(); } #include "main.moc" public: CustomWidget(QWidget *parent = nullptr) : QWidget(parent) {} protected: bool event(QEvent *event) override { if (event-type() == QEvent::MouseButtonPress) { QMouseEvent *mouseEvent = static_cast qDebug() QApplication app(argc, argv); CustomWidget widget; widget.setWindowTitle("Event Dispatching Example"); widget.setGeometry(100, 100, 300, 200); widget.show(); return app.exec(); } public: CustomWidget(QWidget *parent = nullptr) : QWidget(parent) {} protected: void mousePressEvent(QMouseEvent *event) override { if (event-type() == QEvent::MouseButtonPress) { // 获取鼠标按下事件对象的坐标 int x = event-x(); int y = event-y(); qDebug() QApplication app(argc, argv); CustomWidget widget; widget.setWindowTitle("Event Object Example"); widget.setGeometry(100, 100, 300, 200); widget.show(); return app.exec(); } Q_OBJECT public: TimerExample(QWidget *parent = nullptr) : QWidget(parent) { timer = new QTimer(this); timer-setInterval(1000); // 1秒的时间间隔 label = new QLabel("Time: 0", this); label-setGeometry(50, 50, 100, 30); connect(timer, SIGNAL(timeout()), this, SLOT(updateTime())); timer-start(); // 启动定时器 } public slots: void updateTime() { static int time = 0; label-setText("Time: " + QString::number(time)); time++; } private: QTimer *timer; QLabel *label; }; int main(int argc, char *argv[]) { QApplication app(argc, argv); TimerExample widget; widget.setWindowTitle("Timer Example"); widget.setGeometry(100, 100, 300, 200); widget.show(); return app.exec(); } #include "main.moc" public: CustomEvent(int data) : QEvent(QEvent::User), eventData(data) {} int getData() const { return eventData; } private: int eventData; }; class SenderWidget : public QWidget { public: SenderWidget() { QTimer::singleShot(2000, this, &SenderWidget::sendCustomEvent); } void sendCustomEvent() { CustomEvent *event = new CustomEvent(42); QCoreApplication::sendEvent(this, event); } }; class ReceiverWidget : public QWidget { public: ReceiverWidget() { installEventFilter(this); } bool event(QEvent *event) override { if (event-type() == QEvent::User) { CustomEvent *customEvent = static_cast QApplication app(argc, argv); SenderWidget sender; ReceiverWidget receiver; receiver.setGeometry(300, 100, 200, 150); sender.show(); receiver.show(); return app.exec(); } public: CustomWidget(QWidget *parent = nullptr) : QWidget(parent) {} protected: void mousePressEvent(QMouseEvent *event) override { if (event-button() == Qt::LeftButton) { close(); // 当鼠标左键按下时，关闭窗口 } } }; int main(int argc, char *argv[]) { QApplication app(argc, argv); CustomWidget widget; widget.setWindowTitle("Event Loop Example"); widget.setGeometry(100, 100, 300, 200); widget.show(); return app.exec(); // 启动事件循环 } QTextStream out(&file); out QTextStream in(&file); QString line = in.readLine(); qDebug() qDebug() qDebug() qDebug() QDataStream out(&file); // 使用QDataStream关联QFile对象 } QDataStream in(&file); // 使用QDataStream关联QFile对象 } // 写入数据到二进制文件 QFile file("data.bin"); if (file.open(QIODevice::WriteOnly)) { QDataStream out(&file); int intValue = 42; double doubleValue = 3.14; QString stringValue = "Hello, World!"; out QDataStream in(&file); int intValue; double doubleValue; QString stringValue; in intValue doubleValue stringValue; file.close(); qDebug() QApplication app(argc, argv); // 打开文件对话框，获取单个文件的路径 QString filePath = QFileDialog::getOpenFileName(nullptr, "Open File", "/path/to/default/directory", "Text Files (*.txt);;All Files (*)"); // 打开文件对话框，获取多个文件的路径 QStringList filepaths = QFileDialog::getOpenFileNames(nullptr, "Open Files", "/path/to/default/directory", "Text Files (*.txt);;All Files (*)"); // 打开目录对话框，获取目录路径 QString dirPath = QFileDialog::getExistingDirectory(nullptr, "Select Directory", "/path/to/default/directory"); // 打开文件对话框，获取保存文件的路径 QString saveFilePath = QFileDialog::getSaveFileName(nullptr, "Save File", "/path/to/default/directory", "Text Files (*.txt);;All Files (*)"); qDebug() qDebug() qDebug() QCoreApplication app(argc, argv); QString filePath = "example.txt"; QFileInfo fileInfo(filePath); // 获取文件大小 qint64 size = fileInfo.size(); qDebug() qDebug() qDebug()

VPS购买请点击我

免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们，邮箱：ciyunidc@ciyunshuju.com。本站只作为美观性配图使用,无任何非法侵犯第三方意图,一切解释权归图片著作权方,本站不承担任何责任。如有恶意碰瓷者,必当奉陪到底严惩不贷!

相关阅读

目录[+]