Qt【第五篇】——— QMainWindow 核心组件与对话框开发详解

[QMainWindow 核心属性之 QMenuBar（菜单栏）](#QMainWindow 核心属性之 QMenuBar（菜单栏）)

mainwindow.cpp（创建菜单栏、菜单、菜单项并关联）

mainwindow.cpp（给菜单、菜单项添加快捷键）

mainwindow.cpp（添加子菜单）

mainwindow.cpp（给菜单添加分割线与图标）

mainwindow.cpp（避免内存泄露）

主窗口最多只有一个菜单栏

QMenuBar

setMenuBar

QMenu

addMenu

QAction

addAction

triggered

[&F 快捷键设置](#&F 快捷键设置)

addSeparator

分割线添加位置

[QMenu 与 QAction 设置图标的区别](#QMenu 与 QAction 设置图标的区别)

菜单栏内存泄露问题

this->menuBar()
[QMainWindow 核心属性之 QToolBar（工具栏）](#QMainWindow 核心属性之 QToolBar（工具栏）)

mainwindow.cpp（创建工具栏与菜单项并以图标显示）

mainwindow.cpp（创建多个工具栏并设置停靠位置）

工具栏创建规则

[工具栏与菜单栏共用 QAction 类](#工具栏与菜单栏共用 QAction 类)

[addToolBar 函数](#addToolBar 函数)

[setMenuBar 与 addToolBar 语义区别](#setMenuBar 与 addToolBar 语义区别)

工具项设置图标后文字显示规则

工具栏默认交互特性

[addToolBar 设置初始停靠位置](#addToolBar 设置初始停靠位置)

[setAllowedAreas 函数](#setAllowedAreas 函数)

[setFloatable 函数](#setFloatable 函数)

[setMovable 函数](#setMovable 函数)
[QMainWindow 核心属性之 QStatusBar（状态栏）](#QMainWindow 核心属性之 QStatusBar（状态栏）)

mainwindow.cpp（创建状态栏并添加控件）

[QStatusBar 与菜单栏属性一致性](#QStatusBar 与菜单栏属性一致性)

addWidget

addPermanentWidget

showMessage
[QMainWindow 核心属性之 QDockWidget（浮动窗口）](#QMainWindow 核心属性之 QDockWidget（浮动窗口）)

mainwindow.cpp（创建浮动窗口并关联控件）

[QDockWidget 创建规则](#QDockWidget 创建规则)

addDockWidget

setWindowTitle

[QWidget 容器控件](#QWidget 容器控件)

多层嵌套关联逻辑

setAllowedAreas
[QMainWindow 核心属性之 QDialog（对话框）](#QMainWindow 核心属性之 QDialog（对话框）)

mainwindow.cpp（对话框的创建与释放）

mainwindow.cpp（自定义对话框）

mainwindow.cpp（模态对话框）

mainwindow.cpp（消息对话框QMessageBox）

mainwindow.cpp（颜色对话框QColorDialog）

mainwindow.cpp（文件对话框QFileDialog）

mainwindow.cpp（字体对话框QFontDialog）

mainwindow.cpp（输入对话框QInputDialog）

[Qt::WA_DeleteOnClose 属性](#Qt::WA_DeleteOnClose 属性)

自定义对话框

模态对话框

QMessageBox

QColorDialog

QFileDialog

QFontDialog

QInputDialog

QStringList

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");