Qt【第五篇】——— QMainWindow 核心组件与对话框开发详解
·
目录
QMainWindow 核心属性之 QMenuBar（菜单栏）
QMainWindow 核心属性之 QToolBar（工具栏）
mainwindow.cpp（创建工具栏与菜单项并以图标显示）
QMainWindow 核心属性之 QDialog（对话框）
mainwindow.cpp（消息对话框QMessageBox）
mainwindow.cpp（颜色对话框QColorDialog）
mainwindow.cpp（文件对话框QFileDialog）
mainwindow.cpp（字体对话框QFontDialog）
QMainWindow 核心属性之 QMenuBar（菜单栏）
mainwindow.cpp（创建菜单栏、菜单、菜单项并关联）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// 菜单栏类头文件：QMenuBar 用于创建窗口顶部菜单栏
#include <QMenuBar>
// 本类继承自 QMainWindow（Qt主窗口类，自带菜单栏/工具栏/状态栏区域）
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化UI设计器中的控件（本案例纯代码创建菜单，未使用ui拖拽控件）
ui->setupUi(this);
// ==================== 1. 创建并设置主窗口菜单栏 ====================
// 动态创建菜单栏对象 QMenuBar
QMenuBar* menubar = new QMenuBar();
// 将创建的菜单栏设置为当前主窗口的菜单栏（绑定到窗口顶部）
this->setMenuBar(menubar);
// ==================== 2. 创建菜单，并添加到菜单栏中 ====================
// 创建菜单1：文本为"文件"
QMenu* menu1 = new QMenu("文件");
// 创建菜单2：文本为"编辑"
QMenu* menu2 = new QMenu("编辑");
// 将两个菜单添加到菜单栏中（菜单栏显示：文件 编辑）
menubar->addMenu(menu1);
menubar->addMenu(menu2);
// ==================== 3. 创建菜单项（动作），并添加到对应菜单中 ====================
// QAction 是菜单的具体选项（点击可触发操作）
QAction* action1 = new QAction("新建"); // 新建选项
QAction* action2 = new QAction("打开"); // 打开选项
QAction* action3 = new QAction("退出"); // 退出选项
// 将3个动作添加到【文件】菜单下
menu1->addAction(action1);
menu1->addAction(action2);
menu1->addAction(action3);
// ==================== 4. 绑定菜单项的信号与槽 ====================
// 绑定【退出】动作：
// 信号：&QAction::triggered（点击菜单项时触发）
// 槽：&MainWindow::close（关闭主窗口）
connect(action3, &QAction::triggered, this, &MainWindow::close);
}
// 析构函数：释放UI对象，Qt自动管理菜单/动作的内存（父子对象机制）
MainWindow::~MainWindow()
{
delete ui;
}mainwindow.cpp（给菜单、菜单项添加快捷键）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// Qt菜单栏核心头文件，用于创建和管理窗口顶部菜单栏
#include <QMenuBar>
// 主窗口构造函数
// 继承自QMainWindow：Qt专门的主窗口类，自带菜单栏、工具栏、状态栏区域
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化Qt Designer拖拽生成的UI控件（本案例纯代码创建菜单，未使用ui控件）
ui->setupUi(this);
// ==================== 1. 创建菜单栏 ====================
// 动态创建菜单栏对象，菜单栏是承载所有菜单的顶层容器
QMenuBar* menubar = new QMenuBar();
// 将自定义菜单栏设置为当前主窗口的菜单栏，显示在窗口最顶部
this->setMenuBar(menubar);
// ==================== 2. 创建菜单并添加到菜单栏 ====================
// 创建菜单：文本为"文件"
// (&F)：快捷键标记，按下 Alt+F 可以快速打开该菜单（Qt标准快捷访问方式）
QMenu* menu1 = new QMenu("文件 (&F)");
// 将"文件"菜单添加到菜单栏中
menubar->addMenu(menu1);
// ==================== 3. 创建菜单项并添加到菜单中 ====================
// QAction：菜单项（动作项），是菜单里可点击的具体选项
// (&C)：快捷键标记，菜单展开后，按下 Alt+C 可直接触发该动作
QAction* action1 = new QAction("关闭 (&C)");
// 将"关闭"菜单项添加到"文件"菜单下
menu1->addAction(action1);
// ==================== 4. 绑定信号与槽，实现点击关闭窗口 ====================
// 信号：&QAction::triggered → 点击菜单项时触发
// 槽：&MainWindow::close → 关闭当前主窗口
connect(action1, &QAction::triggered, this, &MainWindow::close);
}
// 主窗口析构函数
// 自动释放ui对象，Qt父子对象机制会自动回收菜单栏、菜单、菜单项的内存，无需手动delete
MainWindow::~MainWindow()
{
delete ui;
}mainwindow.cpp（添加子菜单）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// 菜单栏类头文件，用于创建菜单栏、菜单、菜单项
#include <QMenuBar>
// 主窗口构造函数
// 继承自 QMainWindow：Qt标准主窗口，支持菜单栏/工具栏/状态栏
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化UI设计师创建的控件（本案例纯代码编写菜单，未使用拖拽控件）
ui->setupUi(this);
// ==================== 1. 创建并绑定主窗口菜单栏 ====================
// 动态创建菜单栏对象（窗口最顶部的容器）
QMenuBar* menubar = new QMenuBar();
// 将菜单栏设置到当前主窗口，显示在窗口顶部
this->setMenuBar(menubar);
// ==================== 2. 创建嵌套菜单（级联菜单） ====================
// 创建一级菜单（父菜单）
QMenu* menuparent = new QMenu("父菜单");
// 创建二级菜单（子菜单）
QMenu* menuchild = new QMenu("子菜单");
// 将父菜单添加到菜单栏中
menubar->addMenu(menuparent);
// **核心：菜单嵌套** 将子菜单添加到父菜单中，形成级联下拉效果
menuparent->addMenu(menuchild);
// ==================== 3. 创建菜单项（动作）并绑定到菜单 ====================
// 创建父菜单的菜单项
QAction* action1 = new QAction("父菜单项");
// 创建子菜单的菜单项
QAction* action2 = new QAction("子菜单项");
// 将菜单项添加到对应菜单中
menuparent->addAction(action1); // 父菜单下的选项
menuchild->addAction(action2); // 子菜单下的选项
}
// 主窗口析构函数
// 释放UI对象，Qt父子对象机制自动回收 菜单栏/菜单/菜单项 的内存，无需手动释放
MainWindow::~MainWindow()
{
delete ui;
}mainwindow.cpp（给菜单添加分割线与图标）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// 菜单栏核心头文件，提供QMenuBar/QMenu/QAction 菜单相关类
#include <QMenuBar>
// 补充：使用QIcon需要包含该头文件（代码中用到了图标，建议添加，完整规范）
#include <QIcon>
// 主窗口构造函数
// 继承自QMainWindow：Qt专用主窗口类，内置菜单栏、工具栏、状态栏布局
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化Qt Designer拖拽创建的UI控件（本案例纯代码编写菜单）
ui->setupUi(this);
// ==================== 1. 创建并设置窗口菜单栏 ====================
// 动态创建菜单栏对象（窗口顶部的容器，承载所有菜单）
QMenuBar* menubar = new QMenuBar();
// 将菜单栏绑定到当前主窗口，显示在窗口最上方
this->setMenuBar(menubar);
// ==================== 2. 创建一级菜单并添加到菜单栏 ====================
// 创建菜单对象，显示文本为"菜单1"
QMenu* menuparent = new QMenu("菜单1");
// 将菜单添加到菜单栏中
menubar->addMenu(menuparent);
// ==================== 3. 创建菜单项并添加到菜单中 ====================
// 创建菜单项（可点击的动作选项）
QAction* action1 = new QAction("菜单项1");
QAction* action2 = new QAction("菜单项2");
// 将第一个菜单项添加到菜单
menuparent->addAction(action1);
// ==================== 4. 添加菜单分割线 ====================
// QMenu::addSeparator()：在菜单中添加一条水平分割线
// 作用：对菜单项进行分组，让界面更清晰
menuparent->addSeparator();
// 将第二个菜单项添加到分割线下方
menuparent->addAction(action2);
// ==================== 5. 给菜单、菜单项设置图标 ====================
// 给【菜单】设置图标：资源文件路径 :/open.png
// 注意：给菜单设置图标后，会覆盖原本文字"菜单1"，仅显示图标
menuparent->setIcon(QIcon(":/open.png"));
// 给【菜单项1】设置图标
// 注意：菜单项会预留图标空间，设置图标后**不会覆盖文字**，图标+文字同时显示
action1->setIcon(QIcon(":/open.png"));
// 给【菜单项2】设置图标
action2->setIcon(QIcon(":/close.png"));
}
// 主窗口析构函数
// 释放UI对象，Qt父子对象机制会自动回收菜单栏、菜单、菜单项、图标资源
MainWindow::~MainWindow()
{
delete ui;
}mainwindow.cpp（避免内存泄露）
// 1. 创建菜单栏
QMenuBar* menubar = this->menuBar();
this->setMenuBar(menubar);主窗口最多只有一个菜单栏
定义：QMainWindow 主窗口类的固定设计规范，仅支持绑定一个菜单栏，菜单栏固定显示在窗口顶部区域，无法同时存在多个独立菜单栏。核心规则：重复创建菜单栏会覆盖原有配置，且直接造成内存泄露，单次初始化菜单栏即可满足全部菜单展示需求。
QMenuBar
定义：Qt 框架中的菜单栏容器类，是承载所有菜单的顶层控件，专属适配 QMainWindow 窗口，用于整合管理各类菜单组件。核心特性：通过 Qt 父子对象机制自动管理内存，是构建窗口菜单体系的基础容器。代码示例：
// 动态创建菜单栏对象
QMenuBar* menubar = new QMenuBar();
// 安全获取系统菜单栏，避免内存泄露
QMenuBar* menubar = this->menuBar();
setMenuBar
作用：为 QMainWindow 主窗口绑定指定菜单栏，将菜单栏挂载到窗口顶部并生效。参数说明：参数为QMenuBar* 类型，指向待绑定的菜单栏对象。核心规则：单个主窗口仅能调用一次该函数，重复调用会替换原有菜单栏。代码示例：
// 将菜单栏设置为当前主窗口的菜单栏
this->setMenuBar(menubar);
QMenu
定义：Qt 框架中的菜单类，菜单栏的子级单元，点击后展开下拉列表，用于分组管理菜单项。核心特性：支持文本显示、快捷键绑定、图标设置，可嵌套子菜单形成级联菜单结构。代码示例：
// 创建文本为"文件"的菜单
QMenu* menu1 = new QMenu("文件");
// 创建带快捷键标记的菜单
QMenu* menu1 = new QMenu("文件 (&F)");
addMenu
作用：向菜单栏添加菜单，或向父菜单添加子菜单，完成菜单的层级挂载。参数说明：参数为QMenu* 类型，指向待添加的菜单对象。代码示例：
// 菜单添加至菜单栏
menubar->addMenu(menu1);
// 子菜单嵌套至父菜单
menuparent->addMenu(menuchild);
QAction
定义：Qt 框架中的菜单项类，菜单下拉列表中的可点击操作单元，承载具体业务功能。核心特性：支持文本、快捷键、图标配置，是菜单体系的最小操作单元。代码示例：
// 创建普通菜单项
QAction* action1 = new QAction("新建");
// 创建带快捷键标记的菜单项
QAction* action1 = new QAction("关闭 (&C)");
addAction
作用：向菜单中添加菜单项，将 QAction 对象挂载到指定菜单的下拉列表中。参数说明：参数为QAction* 类型，指向待添加的菜单项对象。代码示例：
// 菜单项添加至文件菜单
menu1->addAction(action1);
triggered
作用：QAction 类的核心信号，点击菜单项、触发对应快捷键时自动发出。核心特性：无参数信号，通过 connect 绑定槽函数，实现菜单项的功能触发。代码示例：
// 绑定菜单项点击信号与窗口关闭槽函数
connect(action3, &QAction::triggered, this, &MainWindow::close);
&F 快捷键设置
定义：Qt 菜单 / 菜单项的快捷访问标记，在文本后添加&+字母即可完成快捷键绑定。触发方式：按下Alt + 对应字母快速打开菜单或触发菜单项，无需鼠标操作。代码示例：
// Alt+F 快速打开文件菜单
QMenu* menu1 = new QMenu("文件 (&F)");
// Alt+C 快速触发关闭菜单项
QAction* action1 = new QAction("关闭 (&C)");
addSeparator
作用：向菜单中添加水平分割线，对菜单项进行视觉分组，优化界面排版清晰度。核心特性：无业务逻辑，仅为界面装饰组件。代码示例：
// 向菜单中添加分割线
menuparent->addSeparator();
分割线添加位置
规则：分割线必须添加到待分组的菜单项中间，先添加首个菜单项，再添加分割线，最后添加后续菜单项。代码示例：
// 第一步：添加第一个菜单项
menuparent->addAction(action1);
// 第二步：中间添加分割线
menuparent->addSeparator();
// 第三步：添加第二个菜单项
menuparent->addAction(action2);
QMenu 与 QAction 设置图标的区别
QMenu 设置图标：调用setIcon后，覆盖菜单原有文本，仅显示图标，无文字展示。代码示例：
// 菜单仅显示图标，隐藏文本
menuparent->setIcon(QIcon(":/open.png"));
QAction 设置图标：调用setIcon后，图标与文本同时显示，文字保留，左侧展示对应图标。代码示例：
// 菜单项同时显示图标和文本
action1->setIcon(QIcon(":/open.png"));
菜单栏内存泄露问题
原因：新建 QMainWindow 项目时，系统自动生成默认菜单栏；手动执行new QMenuBar()会创建新对象，原有默认菜单栏未释放，造成内存泄露。危害：程序运行中累积未释放内存，导致资源占用过高，降低程序稳定性。
this->menuBar()
定义：QMainWindow 的内置成员函数，安全获取菜单栏对象，彻底避免内存泄露。核心逻辑：
- 主窗口未生成菜单栏：自动创建 QMenuBar 对象并返回指针；
- 主窗口已生成默认菜单栏：直接返回默认对象的指针，不重复创建。代码示例：
// 安全获取菜单栏，无内存泄露
QMenuBar* menubar = this->menuBar();
this->setMenuBar(menubar);
QMainWindow 核心属性之 QToolBar（工具栏）
mainwindow.cpp（创建工具栏与菜单项并以图标显示）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// QToolBar：工具栏类头文件，用于创建窗口顶部/侧边的快捷工具栏
#include <QToolBar>
// QIcon：图标类头文件（设置工具栏图标必须包含，代码中已使用）
#include <QIcon>
// 主窗口构造函数
// 继承自 QMainWindow：Qt标准主窗口，内置**菜单栏、工具栏、状态栏**专属区域
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化UI设计师拖拽创建的控件（本案例纯代码编写工具栏）
ui->setupUi(this);
// ==================== 1. 创建工具栏并添加到主窗口 ====================
// 动态创建工具栏对象：快捷操作按钮容器，支持图标+文字显示
QToolBar* toolbar = new QToolBar();
// 将工具栏添加到主窗口（QMainWindow默认将工具栏添加到顶部）
this->addToolBar(toolbar);
// ==================== 2. 创建工具项（动作）并添加到工具栏 ====================
// QAction：工具栏/菜单的通用动作项，是可点击的操作单元
QAction* action1 = new QAction("打开");
QAction* action2 = new QAction("关闭");
// 将动作项添加到工具栏，工具栏会自动渲染为按钮样式
toolbar->addAction(action1);
toolbar->addAction(action2);
// ==================== 3. 给工具项设置图标 ====================
// 从Qt资源文件(:/开头)加载图标，设置给对应动作项
// 工具栏会自动适配：优先显示图标，鼠标悬浮显示文字
action1->setIcon(QIcon(":/open.png"));
action2->setIcon(QIcon(":/close.png"));
// ==================== 4. 绑定信号与槽，实现关闭窗口功能 ====================
// 信号：&QAction::triggered → 点击工具栏按钮时触发
// 槽：&MainWindow::close → 关闭当前主窗口
connect(action2, &QAction::triggered, this, &MainWindow::close);
}
// 主窗口析构函数
// 释放UI对象，Qt父子对象机制**自动回收工具栏、动作项、图标资源**，无需手动delete
MainWindow::~MainWindow()
{
delete ui;
}mainwindow.cpp（创建多个工具栏并设置停靠位置）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// QToolBar：工具栏核心头文件，用于创建、管理工具栏
#include <QToolBar>
// QAction：动作项头文件，工具栏的可操作单元（按钮/文本）
#include <QAction>
// 主窗口构造函数
// 继承自 QMainWindow：Qt标准主窗口，原生支持**多工具栏、自定义停靠位置**
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化UI设计师拖拽创建的控件（本案例纯代码编写工具栏）
ui->setupUi(this);
// ==================== 1. 创建两个工具栏对象 ====================
// 动态创建第一个工具栏
QToolBar* toolbar1 = new QToolBar();
// 动态创建第二个工具栏
QToolBar* toolbar2 = new QToolBar();
// 将第一个工具栏添加到主窗口
// 无参数：默认停靠在窗口**顶部**，且支持自由拖动、停靠
this->addToolBar(toolbar1);
// ==================== 2. 指定工具栏初始停靠位置 ====================
// Qt::LeftToolBarArea：左侧停靠区域
// 将 toolbar2 初始添加到窗口**左侧**停靠
this->addToolBar(Qt::LeftToolBarArea, toolbar2);
// ==================== 3. 设置工具栏允许停靠的区域 ====================
// setAllowedAreas：限制工具栏可停靠的位置
// Qt::LeftToolBarArea | Qt::RightToolBarArea：仅允许停靠在 左侧 / 右侧
// 无法停靠到顶部/底部，也无法拖出窗口
toolbar2->setAllowedAreas(Qt::LeftToolBarArea | Qt::RightToolBarArea);
// ==================== 4. 设置工具栏不允许浮动 ====================
// setFloatable(false)：禁止工具栏脱离主窗口，变成独立的浮动小窗口
// 默认值为 true（允许浮动）
toolbar2->setFloatable(false);
// ==================== 5. 设置工具栏不允许移动 ====================
// setMovable(false)：禁止用户拖动工具栏改变停靠位置
// 工具栏会固定在初始位置，无法拖拽
// 默认值为 true（允许移动）
toolbar2->setMovable(false);
// ==================== 6. 创建动作项（工具按钮）并添加到工具栏 ====================
// 为 toolbar1 创建两个动作项
QAction* action1_1 = new QAction("动作1_1");
QAction* action1_2 = new QAction("动作1_2");
// 为 toolbar2 创建两个动作项
QAction* action2_1 = new QAction("动作2_1");
QAction* action2_2 = new QAction("动作2_2");
// 将动作项添加到对应工具栏
toolbar1->addAction(action1_1);
toolbar1->addAction(action1_2);
toolbar2->addAction(action2_1);
toolbar2->addAction(action2_2);
}
// 主窗口析构函数
// 释放UI对象，Qt父子对象机制自动回收所有工具栏、动作项的内存
MainWindow::~MainWindow()
{
delete ui;
}工具栏创建规则
定义：QMainWindow 主窗口中，工具栏无自动创建机制，必须通过代码手动 new创建对象，与菜单栏的自动生成机制存在本质区别。代码示例：
// 手动创建工具栏对象
QToolBar* toolbar = new QToolBar();
核心特性：无系统默认生成的工具栏实例，所有工具栏组件均需手动初始化、添加。
工具栏与菜单栏共用 QAction 类
定义：QAction为菜单、工具栏的通用操作单元，菜单栏菜单项与工具栏工具项可复用同一 QAction 对象。核心特性：
- 单一 QAction 对象可同时添加至菜单、工具栏
- 触发triggered信号时，绑定的槽函数同步生效
- 图标、文本、快捷键配置全局同步代码示例：
// 创建通用动作项
QAction* action = new QAction("关闭");
// 添加至菜单
menu->addAction(action);
// 添加至工具栏
toolbar->addAction(action);
addToolBar 函数
作用：向 QMainWindow 主窗口添加工具栏，支持多工具栏挂载。参数说明：
- 单参数：传入QToolBar* 对象，默认停靠顶部
- 双参数：指定停靠区域+ 工具栏对象，设置初始位置代码示例：
// 默认顶部添加工具栏
this->addToolBar(toolbar1);
// 指定左侧初始停靠位置
this->addToolBar(Qt::LeftToolBarArea, toolbar2);
setMenuBar 与 addToolBar 语义区别
setMenuBar 语义：设置语义，主窗口仅支持一个菜单栏，新设置的菜单栏会替换旧对象，旧对象脱离对象树，引发内存泄露。代码示例：
// 替换式设置，仅存在一个菜单栏
this->setMenuBar(menubar);
addToolBar 语义：添加语义，主窗口支持多个工具栏，新工具栏直接挂载至对象树，无替换逻辑，无内存泄露风险。代码示例：
// 累加式添加，可存在多个工具栏
this->addToolBar(toolbar1);
this->addToolBar(toolbar2);
工具项设置图标后文字显示规则
作用：QAction 设置图标后，工具栏默认屏蔽文字信息，仅展示图标样式。核心特性：鼠标悬浮至工具项时，文字提示自动显示。代码示例：
// 设置图标后，工具栏仅显示图标
action1->setIcon(QIcon(":/open.png"));
工具栏默认交互特性
定义：工具栏默认具备可浮动、可拖拽特性。核心特性：
- 支持拖拽至窗口上、下、左、右任意停靠区域
- 支持脱离主窗口，形成独立浮动窗口代码示例：
// 默认创建的工具栏，可浮动、可拖拽、可多位置停靠
QToolBar* toolbar1 = new QToolBar();
this->addToolBar(toolbar1);
addToolBar 设置初始停靠位置
作用：调用 addToolBar 时，通过Qt::ToolBarArea枚举参数，指定工具栏的初始停靠位置。常用枚举值：
- Qt::LeftToolBarArea：左侧停靠
- Qt::RightToolBarArea：右侧停靠
- Qt::TopToolBarArea：顶部停靠
- Qt::BottomToolBarArea：底部停靠代码示例：
// 初始停靠至窗口左侧
this->addToolBar(Qt::LeftToolBarArea, toolbar2);
setAllowedAreas 函数
作用：限制工具栏允许停靠的区域，禁止拖拽至未授权位置。参数说明：枚举值组合，通过|拼接多个允许区域。代码示例：
// 仅允许停靠左侧、右侧
toolbar2->setAllowedAreas(Qt::LeftToolBarArea | Qt::RightToolBarArea);
setFloatable 函数
作用：设置工具栏是否可浮动，控制是否能脱离主窗口。参数说明：
- true：允许浮动（默认值）
- false：禁止浮动，固定依附主窗口代码示例：
// 禁止工具栏浮动
toolbar2->setFloatable(false);
setMovable 函数
作用：设置工具栏是否可移动拖拽，控制是否能改变停靠位置。参数说明：
- true：允许移动拖拽（默认值）
- false：禁止移动，固定初始位置代码示例：
// 禁止工具栏拖拽移动
toolbar2->setMovable(false);QMainWindow 核心属性之 QStatusBar（状态栏）
mainwindow.cpp（创建状态栏并添加控件）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// QStatusBar：状态栏类头文件，位于主窗口**底部**，用于显示状态提示、永久控件
#include <QStatusBar>
// QLabel：标签控件，用于在状态栏显示文本状态
#include <QLabel>
// QPushButton：按钮控件，演示状态栏添加普通控件
#include <QPushButton>
// 主窗口构造函数
// 继承自 QMainWindow：Qt标准主窗口，自带**底部状态栏**专属区域
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化UI设计师拖拽创建的控件
ui->setupUi(this);
// ==================== 1. 获取/创建状态栏 ====================
// QMainWindow::statusBar() 核心方法：
// 如果主窗口已有状态栏，直接返回对象；没有则自动创建新状态栏
QStatusBar* statusbar = this->statusBar();
// 将状态栏设置给当前主窗口
// 即使窗口已有状态栏，重复赋值也无任何副作用，安全写法
this->setStatusBar(statusbar);
// ==================== 2. 显示临时提示信息（注释备用） ====================
// showMessage(提示文本, 显示时长ms)：在状态栏左侧显示临时信息
// 5000毫秒=5秒后，信息自动消失，适合临时提示
// statusbar->showMessage("这是一个临时信息", 5000);
// ==================== 3. 向状态栏添加永久控件 ====================
// 创建标签控件，显示固定状态文本
QLabel* label1 = new QLabel("状态1");
// 创建按钮控件，演示状态栏可添加任意Qt控件
QPushButton* button1 = new QPushButton("按钮1");
// QStatusBar::addWidget(控件, 拉伸因子)
// 拉伸因子(stretch)：决定控件在状态栏的**宽度占比**
// 总占比 = 1 + 2 = 3
statusbar->addWidget(label1, 1); // 标签占状态栏宽度的 1/3
statusbar->addWidget(button1, 2); // 按钮占状态栏宽度的 2/3
}
// 主窗口析构函数
// 释放UI对象，Qt父子对象机制自动回收状态栏、标签、按钮的内存
MainWindow::~MainWindow()
{
delete ui;
}QStatusBar 与菜单栏属性一致性
核心特性：QStatusBar自动生成，主窗口最多仅支持一个，setStatusBar为替换语义。
- QMainWindow 创建时自动生成状态栏实例，无需手动
new - 主窗口仅允许存在一个状态栏，与菜单栏数量规则一致
this->setStatusBar()执行替换操作，新状态栏会将旧状态栏从对象树中移除，旧对象未释放造成内存泄露- 安全用法：调用
this->statusBar()获取已有状态栏，避免手动创建代码示例：
// 安全获取状态栏，无内存泄露风险
QStatusBar* statusbar = this->statusBar();
// 替换式设置状态栏，重复调用易造成内存泄露
this->setStatusBar(statusbar);
addWidget
作用：向状态栏左侧区域添加普通控件，控件按从左往右顺序排列。参数说明：
- 第一个参数：待添加的控件指针
- 第二个参数：拉伸因子，控制控件在状态栏的宽度占比核心特性：添加的控件会被
showMessage的临时提示信息覆盖代码示例：
// 从左往右添加控件，标签占1/3宽度，按钮占2/3宽度
statusbar->addWidget(label1, 1);
statusbar->addWidget(button1, 2);
addPermanentWidget
作用：向状态栏右侧区域添加永久控件，控件按从右往左顺序排列。参数说明：
- 第一个参数：待添加的控件指针
- 第二个参数：拉伸因子，控制控件宽度分配比例核心特性：永久显示，不会被
showMessage的临时信息覆盖代码示例：
// 从右往左添加永久显示的标签控件
statusbar->addPermanentWidget(new QLabel("永久状态"), 1);
showMessage
作用：在状态栏左侧显示临时提示文本，超时自动消失。参数说明：
- 第一个参数：需要显示的提示文本
- 第二个参数：显示时长，单位为毫秒，填 0 时永久显示核心特性：临时信息会覆盖
addWidget添加的普通控件代码示例：
// 显示临时提示信息，5000毫秒后自动消失
statusbar->showMessage("这是一个临时信息", 5000);QMainWindow 核心属性之 QDockWidget（浮动窗口）
mainwindow.cpp（创建浮动窗口并关联控件）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// QDockWidget：停靠窗口（浮动窗口）核心头文件，可停靠/浮动的子窗口
#include <QDockWidget>
// QLabel：标签控件，用于展示文本
#include <QLabel>
// QPushButton：按钮控件
#include <QPushButton>
// QVBoxLayout：垂直布局管理器，用于排列停靠窗口内的控件
#include <QVBoxLayout>
// 主窗口构造函数
// 继承自 QMainWindow：Qt标准主窗口，原生支持**停靠窗口、菜单栏、工具栏、状态栏**
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化UI设计师拖拽创建的控件
ui->setupUi(this);
// ==================== 1. 创建停靠窗口对象 ====================
// QDockWidget：停靠窗口（也叫浮动窗口）
// 特点：可以停靠在主窗口四周，也可以拖拽变成独立的浮动窗口
QDockWidget* dockwidget = new QDockWidget();
// ==================== 2. 将停靠窗口添加到主窗口，并设置初始停靠位置 ====================
// Qt::LeftDockWidgetArea：主窗口左侧停靠区域
// 将停靠窗口初始停靠在主窗口**左侧**
this->addDockWidget(Qt::LeftDockWidgetArea, dockwidget);
// ==================== 3. 设置停靠窗口的标题 ====================
// 停靠窗口顶部显示的标题文字
dockwidget->setWindowTitle("这是一个浮动窗口");
// ==================== 4. 给停靠窗口添加内部控件（核心重点） ====================
// ❗ 关键规则：QDockWidget 不能直接添加子控件
// 必须先创建一个 QWidget 作为**容器控件**，将控件放入容器后，再把容器设置给停靠窗口
QWidget* container = new QWidget();
// 创建普通控件
QLabel* label = new QLabel("这是一个label");
QPushButton* button = new QPushButton("按钮");
// 创建垂直布局，将控件从上到下排列
QVBoxLayout* vlayout = new QVBoxLayout();
vlayout->addWidget(label); // 布局添加标签
vlayout->addWidget(button); // 布局添加按钮
// 将布局设置给容器控件（容器接管布局和子控件的内存）
container->setLayout(vlayout);
// 将容器控件设置为停靠窗口的内部核心控件
dockwidget->setWidget(container);
// ==================== 5. 限制停靠窗口允许停靠的区域 ====================
// setAllowedAreas：设置停靠窗口可停靠的位置
// Qt::LeftDockWidgetArea | Qt::TopDockWidgetArea：仅允许停靠在**左侧/顶部**
// 无法停靠到右侧、底部
dockwidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::TopDockWidgetArea);
}
// 主窗口析构函数
// 释放UI对象，Qt父子对象机制自动回收停靠窗口、容器、控件、布局的所有内存
MainWindow::~MainWindow()
{
delete ui;
}QDockWidget 创建规则
定义：QDockWidget 为停靠 / 浮动窗口控件，无自动生成机制，需通过代码手动 new创建，主窗口支持多个QDockWidget 实例共存。核心特性：区别于菜单栏、状态栏的单实例自动生成规则，无数量限制，可自由创建多个停靠窗口。代码示例：
// 手动创建停靠窗口对象
QDockWidget* dockwidget = new QDockWidget();
addDockWidget
作用：向 QMainWindow 主窗口添加停靠窗口，并指定初始停靠位置。参数说明：
- 第一个参数：Qt::DockWidgetArea枚举值，指定停靠区域
- 第二个参数：QDockWidget 指针，待添加的停靠窗口对象常用停靠区域：Qt::LeftDockWidgetArea（左侧）、Qt::TopDockWidgetArea（顶部）、Qt::RightDockWidgetArea（右侧）、Qt::BottomDockWidgetArea（底部）代码示例：
// 将停靠窗口初始添加至主窗口左侧区域
this->addDockWidget(Qt::LeftDockWidgetArea, dockwidget);
setWindowTitle
作用：设置 QDockWidget 的窗口标题，标题显示在停靠窗口顶部区域。参数说明：参数为QString类型，标题文本内容。代码示例：
// 设置停靠窗口标题文本
dockwidget->setWindowTitle("这是一个浮动窗口");
QWidget 容器控件
定义：Qt 通用容器控件，作为 QDockWidget 的内部载体，承载子控件与布局。核心规则：QDockWidget无法直接添加子控件，必须通过 QWidget 作为中间容器完成控件挂载。代码示例：
// 创建停靠窗口专用容器控件
QWidget* container = new QWidget();
多层嵌套关联逻辑
作用：通过层层关联将所有动态创建的对象挂载至 Qt 对象树，实现自动内存管理，无需手动释放。关联流程：
- 子控件（QLabel、QPushButton）添加至QVBoxLayout布局
- 布局设置给QWidget容器控件
- 容器控件设置给QDockWidget停靠窗口
- 停靠窗口添加至主窗口，所有对象纳入对象树核心特性：Qt 父子对象机制自动回收所有 new 创建的对象，杜绝内存泄露。代码示例：
// 控件添加至布局
QVBoxLayout* vlayout = new QVBoxLayout();
vlayout->addWidget(label);
vlayout->addWidget(button);
// 布局关联容器
container->setLayout(vlayout);
// 容器关联停靠窗口
dockwidget->setWidget(container);
setAllowedAreas
作用：限制 QDockWidget允许停靠的区域，禁止拖拽至未授权位置。参数说明：Qt::DockWidgetArea枚举值组合，通过|拼接多个允许区域。核心特性：限定停靠窗口的拖拽范围，固定窗口停靠规则。代码示例：
// 仅允许停靠窗口停靠在左侧、顶部区域
dockwidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::TopDockWidgetArea);
QMainWindow 核心属性之 QDialog（对话框）
mainwindow.cpp（对话框的创建与释放）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// QDialog：Qt标准对话框类，用于创建弹出式子窗口（提示、交互、设置等）
#include <QDialog>
// 主窗口构造函数
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化UI设计师拖拽创建的控件
ui->setupUi(this);
}
// 主窗口析构函数
MainWindow::~MainWindow()
{
delete ui;
}
// ==================== 自动关联槽函数 ====================
// 命名规则：on_<控件名>_<信号名>
// 功能：点击UI设计师中创建的 pushButton 按钮时，触发该函数
void MainWindow::on_pushButton_clicked()
{
// ==================== 1. 创建对话框对象 ====================
// 动态创建QDialog对话框，指定父对象为当前主窗口(this)
// 父对象机制：对话框随主窗口显示，且由Qt统一管理内存
QDialog* dialog = new QDialog(this);
// ==================== 2. 设置对话框的窗口标题 ====================
dialog->setWindowTitle("这是一个对话框");
// ==================== 3. 设置对话框的大小 ====================
// resize(width, height)：设置对话框宽度400，高度300
dialog->resize(400, 300);
// ==================== 4. 显示对话框 ====================
// show()：以**非模态**方式显示对话框
// 非模态特点：对话框弹出后，仍可以操作主窗口（不阻塞）
dialog->show();
// ==================== 5. 关键：设置对话框关闭时自动释放内存 ====================
// Qt::WA_DeleteOnClose：窗口关闭时，自动delete对象，防止内存泄漏
// 解决动态new创建对话框，关闭后内存残留的问题
dialog->setAttribute(Qt::WA_DeleteOnClose);
}mainwindow.cpp（自定义对话框）
第一步：创建新的类
第二步：填写继承的父类为 QDialog
第三步：回自动生成 Dialog.h 和 Dialog.cpp 文件，并且继承自 QDialog
---------------------------------- dialog.h ----------------------------------
#ifndef DIALOG_H
#define DIALOG_H
#include <QWidget>
// QDialog：对话框基类，自定义对话框必须继承
#include <QDialog>
// QPushButton：按钮控件
#include <QPushButton>
// QVBoxLayout：垂直布局管理器
#include <QVBoxLayout>
// 自定义 Dialog 类，继承 Qt 标准对话框 QDialog
// Q_OBJECT 宏：必须添加！支持信号和槽机制
class Dialog : public QDialog
{
Q_OBJECT
public:
// 构造函数：parent 为父窗口指针（主窗口）
explicit Dialog(QWidget* parent = nullptr);
public slots:
// 自定义槽函数：处理按钮点击，关闭对话框
void handle();
};
#endif // DIALOG_H
---------------------------------- dialog.cpp ----------------------------------
#include "dialog.h"
// 构造函数实现
// 初始化列表：调用父类 QDialog 的构造函数，绑定父窗口
Dialog::Dialog(QWidget* parent) : QDialog(parent)
{
// ==================== 动态创建按钮控件 ====================
// 指定父对象为 this（当前自定义对话框），Qt 自动管理内存
QPushButton* button1 = new QPushButton("按钮1", this);
QPushButton* button2 = new QPushButton("关闭", this);
// ==================== 创建垂直布局并管理控件 ====================
QVBoxLayout* layout = new QVBoxLayout();
// 将布局设置给当前对话框，对话框自动适配布局大小
this->setLayout(layout);
// 按钮从上到下垂直排列
layout->addWidget(button1);
layout->addWidget(button2);
// ==================== 信号槽连接 ====================
// 点击【关闭】按钮 → 触发自定义槽函数 handle()
connect(button2, &QPushButton::clicked, this, &Dialog::handle);
}
// 自定义槽函数：关闭当前对话框
void Dialog::handle()
{
// 关闭对话框窗口
this->close();
}
---------------------------------- mainwindow.cpp ----------------------------------
#include "mainwindow.h"
#include "ui_mainwindow.h"
// 包含自定义对话框头文件
#include "dialog.h"
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化 UI 设计师拖拽的控件
ui->setupUi(this);
}
MainWindow::~MainWindow()
{
// 释放 UI 对象
delete ui;
}
// ==================== 自动关联槽函数 ====================
// 点击主窗口按钮：弹出自定义对话框
void MainWindow::on_pushButton_clicked()
{
// 1. 创建**自定义对话框**对象，父对象为主窗口
Dialog* dialog = new Dialog(this);
// 2. 设置对话框大小：宽400，高300
dialog->resize(400, 300);
// 3. 非模态显示对话框
// 特点：对话框弹出后，仍可操作主窗口
dialog->show();
// 4. 关键：对话框关闭时**自动释放内存**
// 防止 new 创建的对象造成内存泄漏
dialog->setAttribute(Qt::WA_DeleteOnClose);
}mainwindow.cpp（模态对话框）
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QDialog>
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
ui->setupUi(this);
}
MainWindow::~MainWindow()
{
delete ui;
}
void MainWindow::on_pushButton_clicked()
{
QDialog* dialog = new QDialog(this);
dialog->setWindowTitle("这是一个对话框");
dialog->resize(400, 300);
// 把show改成exec显示，就能把此对话框改为模态对话框
dialog->exec();
dialog->setAttribute(Qt::WA_DeleteOnClose);
}
mainwindow.cpp（消息对话框QMessageBox）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// QMessageBox：Qt内置标准消息对话框，用于提示、警告、错误、询问等场景
#include <QMessageBox>
// 主窗口构造函数
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化UI设计师拖拽创建的控件（按钮pushButton）
ui->setupUi(this);
}
// 主窗口析构函数
MainWindow::~MainWindow()
{
// 释放UI对象
delete ui;
}
// ==================== 自动关联槽函数 ====================
// 点击主窗口按钮时触发：弹出标准消息对话框
void MainWindow::on_pushButton_clicked()
{
// ==================== 1. 动态创建消息对话框 ====================
// 指定父对象为当前主窗口，由Qt管理基础内存
QMessageBox* messagebox = new QMessageBox(this);
// ==================== 2. 设置消息对话框的窗口标题 ====================
messagebox->setWindowTitle("这是消息对话框标题");
// ==================== 3. 设置对话框核心提示文本 ====================
messagebox->setText("这是消息对话框的文本内容");
// ==================== 4. 设置对话框提示图标（系统自带标准图标） ====================
// QMessageBox::Warning：警告图标（黄色感叹号）
// 常用图标：Information(信息)、Critical(错误)、Question(问号)、NoIcon(无图标)
messagebox->setIcon(QMessageBox::Warning);
// ==================== 5. 设置对话框标准按钮 ====================
// setStandardButtons：添加Qt内置标准按钮，用 | 组合多个按钮
messagebox->setStandardButtons(QMessageBox::Ok | QMessageBox::Save | QMessageBox::Cancel);
// 拓展：自定义按钮（注释示例）
// 可以不使用系统按钮，自定义按钮并添加到对话框
/*
QPushButton* button1 = new QPushButton("按钮1", messagebox);
// addButton：添加自定义按钮，指定按钮角色（确定/取消/应用等）
messagebox->addButton(button1, QMessageBox::AcceptRole);
*/
// ==================== 6. 模态显示对话框（核心） ====================
// exec()：以**模态**方式显示对话框
// 特点：阻塞主窗口，必须关闭对话框才能操作主窗口
// 返回值：用户点击的按钮枚举值，用于判断用户操作
int clickBtn = messagebox->exec();
// ==================== 7. 根据用户点击的按钮执行对应逻辑 ====================
// switch判断返回的按钮枚举，处理不同的用户操作
switch (clickBtn)
{
case QMessageBox::Save: // 用户点击了【保存】按钮
// 此处编写保存业务逻辑
break;
case QMessageBox::Ok: // 用户点击了【确定】按钮
// 此处编写确定业务逻辑
break;
case QMessageBox::Cancel: // 用户点击了【取消】按钮
// 此处编写取消业务逻辑
break;
default:
break;
}
// ==================== 8. 释放对话框内存 ====================
// exec()是阻塞函数，对话框关闭后才会执行到这里，直接delete安全无内存泄漏
delete messagebox;
}mainwindow.cpp（颜色对话框QColorDialog）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// QColorDialog：Qt内置标准颜色选择对话框，用于快速选择颜色
#include <QColorDialog>
// 主窗口构造函数
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化UI设计师拖拽创建的控件（核心是按钮pushButton）
ui->setupUi(this);
}
// 主窗口析构函数
MainWindow::~MainWindow()
{
// 释放UI对象，Qt自动管理内存
delete ui;
}
// ==================== 自动关联槽函数 ====================
// 点击主窗口按钮时触发：弹出颜色选择器，修改窗口背景色
void MainWindow::on_pushButton_clicked()
{
// ==================== 1. 弹出颜色选择对话框（静态函数极简用法） ====================
// QColorDialog::getColor：Qt提供的**静态成员函数**
// 作用：直接弹出模态颜色选择对话框，无需手动new创建对话框对象
// 参数1：QColor(0,255,0) → 对话框默认选中的颜色（绿色，RGB格式）
// 参数2：this → 父窗口为主窗口
// 参数3："选择颜色" → 对话框的标题
// 返回值：用户选择的颜色（QColor类型）
QColor color = QColorDialog::getColor(QColor(0, 255, 0), this, "选择颜色");
// ==================== 2. 拼接QSS样式表字符串，设置窗口背景色 ====================
// QSS：Qt样式表，类似CSS，用于设置控件/窗口的样式
// 拼接格式：background-color: rgb(R, G, B);
QString style = "background-color: rgb(" +
QString::number(color.red()) + // 获取红色分量(0-255)，转字符串
", " +
QString::number(color.green()) + // 获取绿色分量(0-255)，转字符串
", " +
QString::number(color.blue()) + // 获取蓝色分量(0-255)，转字符串
");";
// 将拼接好的样式表应用到**当前主窗口**，修改背景色
this->setStyleSheet(style);
}mainwindow.cpp（文件对话框QFileDialog）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// QFileDialog：Qt内置标准文件对话框，用于打开/保存文件、选择目录
#include <QFileDialog>
// QDebug：Qt调试输出工具，用于在控制台打印日志、文件路径
#include <QDebug>
// 主窗口构造函数
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化UI设计师拖拽创建的控件（两个按钮：pushButton、pushButton_2）
ui->setupUi(this);
}
// 主窗口析构函数
MainWindow::~MainWindow()
{
// 释放UI对象，Qt自动管理内存
delete ui;
}
// ==================== 按钮1点击槽函数：打开文件对话框 ====================
// 功能：点击按钮弹出文件选择框，选择单个文件并打印路径
void MainWindow::on_pushButton_clicked()
{
// ==================== 1. 弹出【打开文件】对话框（静态函数极简用法） ====================
// QFileDialog::getOpenFileName：静态成员函数
// 作用：直接弹出**模态**文件打开对话框，无需手动new/delete对话框
// 参数this：指定父窗口为主窗口，对话框居中显示在主窗口上
// 返回值：用户选择的**文件完整路径**（QString类型）；若取消选择，返回空字符串
QString filePath = QFileDialog::getOpenFileName(this);
// ==================== 2. 控制台打印选中的文件路径 ====================
// qDebug()：Qt调试输出，会在Qt Creator的【应用程序输出】窗口打印路径
qDebug() << filePath;
}
// ==================== 按钮2点击槽函数：保存文件对话框 ====================
// 功能：点击按钮弹出文件保存框，选择保存位置并打印路径
void MainWindow::on_pushButton_2_clicked()
{
// ==================== 1. 弹出【保存文件】对话框（静态函数极简用法） ====================
// QFileDialog::getSaveFileName：静态成员函数
// 作用：弹出**模态**文件保存对话框，用于指定文件保存的路径和名称
// 参数this：指定父窗口为主窗口
// 返回值：用户设置的**保存文件完整路径**；若取消，返回空字符串
QString filePath = QFileDialog::getSaveFileName(this);
// ==================== 2. 控制台打印保存的文件路径 ====================
qDebug() << filePath;
}mainwindow.cpp（字体对话框QFontDialog）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// QFontDialog：Qt内置标准字体选择对话框，用于选择字体、字号、字形
#include <QFontDialog>
// QDebug：Qt调试输出工具，打印字体相关信息
#include <QDebug>
// QFont：Qt字体类，封装字体的家族、大小、加粗、斜体等属性
#include <QFont>
// 主窗口构造函数
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化UI设计师拖拽创建的控件（核心是按钮 pushButton）
ui->setupUi(this);
}
// 主窗口析构函数
MainWindow::~MainWindow()
{
// 释放UI对象，Qt自动管理内存
delete ui;
}
// ==================== 按钮点击槽函数：弹出字体选择对话框 ====================
// 功能：点击按钮选择字体，将字体应用到按钮本身，并打印字体信息
void MainWindow::on_pushButton_clicked()
{
// ==================== 1. 弹出字体选择对话框（静态函数极简用法） ====================
// 定义bool变量，用于接收用户操作结果
// ok = true：用户点击【确定】选择了字体
// ok = false：用户点击【取消】未选择字体
bool ok = false;
// QFontDialog::getFont(&ok)：静态成员函数
// 作用：直接弹出**模态**字体选择对话框，无需手动new/delete
// 参数&ok：传出参数，记录用户是否确认选择字体
// 返回值：用户选择的字体对象（QFont类型）
QFont font = QFontDialog::getFont(&ok);
// ==================== 2. 控制台打印字体详细信息 ====================
qDebug() << "用户是否确认选择：" << ok; // 打印操作结果
qDebug() << "字体家族：" << font.family(); // 打印字体名称（如微软雅黑、宋体）
qDebug() << "字体大小：" << font.pointSize(); // 打印字号（如12、14号）
qDebug() << "是否加粗：" << font.bold(); // 打印是否加粗（true/false）
qDebug() << "是否斜体：" << font.italic(); // 打印是否斜体（true/false）
// ==================== 3. 将选择的字体应用到按钮上 ====================
// 仅在用户**确认选择**字体时，才更新按钮字体
if(ok == true)
ui->pushButton->setFont(font);
}mainwindow.cpp（输入对话框QInputDialog）
#include "mainwindow.h"
#include "ui_mainwindow.h"
// QInputDialog：Qt内置标准输入对话框，支持输入整数、浮点数、选择下拉条目
#include <QInputDialog>
// QDebug：Qt调试输出，打印用户输入/选择的内容
#include <QDebug>
// QStringList：Qt字符串列表，用于存储下拉框的选项（等价于字符串集合）
#include <QStringList>
// 主窗口构造函数
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化UI设计师拖拽的3个按钮控件
ui->setupUi(this);
}
// 主窗口析构函数
MainWindow::~MainWindow()
{
// 释放UI对象，Qt自动管理内存
delete ui;
}
// ==================== 按钮1：弹出【整数输入】对话框 ====================
void MainWindow::on_pushButton_clicked()
{
// QInputDialog::getInt：静态函数，弹出**整数输入对话框**
// 参数含义：
// this -> 父窗口
// "整型对话框" -> 对话框标题
// "请输入一个整型:" -> 提示文字
// -1 -> 默认显示的数值
// 0 -> 输入范围最小值
// 10 -> 输入范围最大值
// 1 -> 调节步长（点击上下箭头每次增减1）
// 返回值：用户输入的整数
int result = QInputDialog::getInt(this, "整型对话框", "请输入一个整型:", -1, 0, 10, 1);
// 控制台打印用户输入的整数
qDebug() << "用户输入的整数：" << result;
}
// ==================== 按钮2：弹出【浮点数输入】对话框 ====================
void MainWindow::on_pushButton_2_clicked()
{
// QInputDialog::getDouble：静态函数，弹出**浮点数输入对话框**
// 参数含义：
// this -> 父窗口
// "浮点型对话框" -> 对话框标题
// "请输入一个浮点型:" -> 提示文字
// -1.0 -> 默认值
// 0.0 -> 最小值
// 10.0 -> 最大值
// 返回值：用户输入的浮点数
double result = QInputDialog::getDouble(this, "浮点型对话框", "请输入一个浮点型:", -1.0, 0.0, 10.0);
// 控制台打印用户输入的浮点数
qDebug() << "用户输入的浮点数：" << result;
}
// ==================== 按钮3：弹出【下拉条目选择】对话框 ====================
void MainWindow::on_pushButton_3_clicked()
{
// 创建字符串列表，存储下拉框的选项
// QStringList 等价于 C++ 的 list<string>，专门存储多个字符串
QStringList items;
items.push_back("条目1");
items.push_back("条目2");
items.push_back("条目3");
// QInputDialog::getItem：静态函数，弹出**下拉选择对话框**
// 参数含义：
// this -> 父窗口
// "条目对话框" -> 标题
// "请选择/输入条目:" -> 提示文字
// items -> 下拉框的选项列表
// 返回值：用户选择/输入的字符串
QString item = QInputDialog::getItem(this, "条目对话框", "请选择/输入条目:", items);
// 控制台打印用户选择的条目
qDebug() << "用户选择的条目：" << item;
}Qt::WA_DeleteOnClose 属性
作用：设置对话框关闭时自动释放内存，解决动态创建对话框的内存泄漏问题。核心说明：QDialog* dialog = new QDialog(this); 将对话框绑定到对象树，仅主窗口销毁时释放内存；频繁创建对话框会导致内存占用持续增加。添加该属性后，对话框关闭瞬间自动执行delete，无需手动释放，简化内存管理流程。代码示例：
// 设置对话框关闭时自动删除
dialog->setAttribute(Qt::WA_DeleteOnClose);
自定义对话框
定义：通过创建自定义类继承 QDialog，实现个性化对话框界面与功能。核心流程：
- 新建类，指定父类为QDialog
- 类中添加
Q_OBJECT宏，支持信号槽机制 - 构造函数内创建控件、布局，绑定信号槽
- 主窗口中实例化自定义类，实现弹窗功能代码示例：
// 自定义对话框头文件
class Dialog : public QDialog
{
Q_OBJECT
public:
explicit Dialog(QWidget* parent = nullptr);
};
模态对话框
定义：弹出后阻塞父窗口的对话框类型。核心特性：必须关闭对话框，完成交互操作后，才能对父窗口进行任何操作；非模态对话框可同时操作父窗口与对话框。代码示例：
// exec() 以模态方式显示对话框
dialog->exec();
QMessageBox
定义：Qt 内置标准消息对话框，用于信息提示、警告、错误、询问等场景。核心功能：支持设置标题、提示文本、系统图标、标准按钮；通过exec()模态显示，返回值可判断用户点击的按钮。代码示例：
QMessageBox* messagebox = new QMessageBox(this);
messagebox->setWindowTitle("提示");
messagebox->setText("操作警告");
messagebox->setIcon(QMessageBox::Warning);
messagebox->setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
int clickBtn = messagebox->exec();
delete messagebox;
QColorDialog
定义：Qt 内置颜色选择对话框，用于可视化选择 RGB 颜色。核心方法：getColor() 静态函数，直接弹出模态对话框，返回选中的QColor对象。代码示例：
QColor color = QColorDialog::getColor(QColor(0, 255, 0), this, "选择颜色");
QSS：Qt 样式表，语法类似 CSS，用于设置窗口、控件的样式。样式字符串拼接：将颜色的 RGB 分量转为字符串，拼接为background-color样式，设置窗口背景色。代码示例：
QString style = "background-color: rgb(" +
QString::number(color.red()) +
", " + QString::number(color.green()) +
", " + QString::number(color.blue()) + ");";
this->setStyleSheet(style);
QFileDialog
定义：Qt 内置文件操作对话框，用于打开文件、保存文件、选择目录。getOpenFileName：静态函数，弹出文件打开对话框，返回选中文件的完整路径。代码示例：
QString filePath = QFileDialog::getOpenFileName(this);
getSaveFileName：静态函数，弹出文件保存对话框，返回指定的保存路径。代码示例：
QString filePath = QFileDialog::getSaveFileName(this);
QFontDialog
定义：Qt 内置字体选择对话框，用于选择字体、字号、加粗、斜体等属性。getFont：静态函数，弹出模态对话框，接收bool参数判断用户是否确认选择，返回QFont字体对象。代码示例：
bool ok = false;
QFont font = QFontDialog::getFont(&ok);
if(ok) ui->pushButton->setFont(font);
QInputDialog
定义：Qt 内置输入对话框，支持整数、浮点数输入，下拉条目选择。getInt：静态函数，弹出整数输入对话框，可设置默认值、数值范围、步长，返回整型数据。代码示例：
int result = QInputDialog::getInt(this, "整型对话框", "请输入整数", -1, 0, 10, 1);
getDouble：静态函数，弹出浮点数输入对话框，设置数值范围，返回浮点型数据。代码示例：
double result = QInputDialog::getDouble(this, "浮点型对话框", "请输入浮点数", -1.0, 0.0, 10.0);
getItem：静态函数，弹出下拉选择对话框，基于字符串列表生成选项，返回选中的字符串。代码示例：
QStringList items;
items << "条目1" << "条目2" << "条目3";
QString item = QInputDialog::getItem(this, "条目对话框", "请选择条目", items);
QStringList
定义：Qt 专用字符串列表容器，用于存储、管理多个QString字符串。核心功能：提供便捷的字符串增删查改操作，适配下拉框、列表控件的数据源。代码示例：
// 创建字符串列表并添加元素
QStringList items;
items.push_back("条目1");
items.push_back("条目2");
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
7
0- 0
已为社区贡献4条内容
所有评论(0)