第43章 GUI开发

43.1 GUI开发概述

43.1.1 GUI的概念

GUI（图形用户界面）是一种允许用户通过图形元素（如窗口、按钮、菜单等）与程序交互的界面类型。与命令行界面（CLI）相比，GUI更加直观、易用，是现代应用程序的主流界面形式。

43.1.2 GUI开发的特点

事件驱动：GUI程序通过响应用户操作（如点击、拖动等）来执行相应的代码
组件化：通过组合各种控件来构建界面
布局管理：自动处理控件的位置和大小调整
资源管理：管理图标、图片、字体等资源
多线程：通常需要处理UI线程和工作线程的同步
跨平台：不同平台的GUI实现有所不同，需要考虑兼容性

43.1.3 C++ GUI库的选择

选择合适的GUI库是GUI开发的重要决策，需要考虑以下因素：

跨平台性：是否支持多个操作系统
易用性：学习曲线和开发效率
功能丰富度：提供的控件和功能
性能：运行速度和资源占用
社区支持：文档、教程和社区活跃度
许可模式：开源、商业或两者兼有

43.2 常用C++ GUI库

43.2.1 Qt

Qt是目前最流行的跨平台C++ GUI框架之一，由Qt Company开发和维护。

43.2.1.1 Qt的特点

跨平台：支持Windows、macOS、Linux、Android、iOS等多个平台
功能丰富：提供大量控件和工具类
信号槽机制：独特的事件处理机制
MVC架构：支持模型-视图-控制器设计模式
OpenGL集成：支持3D图形
网络和数据库：内置网络和数据库支持
国际化支持：内置国际化和本地化功能
开源和商业许可：提供开源版本（LGPL）和商业版本

43.2.1.2 Qt的模块

Qt Core：核心功能，包括容器、事件循环、元对象系统等
Qt GUI：图形界面相关功能，包括控件、绘图、字体等
Qt Widgets：传统的桌面应用程序控件
Qt Quick：基于QML的现代界面框架
Qt Network：网络编程功能
Qt SQL：数据库支持
Qt Multimedia：多媒体功能
Qt OpenGL：OpenGL集成
Qt Concurrent：并发编程支持

43.2.2 MFC

MFC（Microsoft Foundation Classes）是Microsoft提供的一套用于开发Windows应用程序的C++类库。

43.2.2.1 MFC的特点

Windows专用：专为Windows平台设计
与Windows API紧密集成：直接封装Windows API
文档视图架构：提供文档-视图设计模式
资源编辑器：Visual Studio提供强大的资源编辑工具
成熟稳定：经过多年发展，非常成熟
学习曲线较陡：需要了解Windows API

43.2.3 wxWidgets

wxWidgets是一个开源的跨平台C++ GUI库，旨在提供与平台原生控件一致的外观和感觉。

43.2.3.1 wxWidgets的特点

跨平台：支持Windows、macOS、Linux等多个平台
原生外观：使用平台原生控件，外观与平台一致
开源：使用wxWindows Library Licence，允许商业使用
丰富的控件：提供大量常用控件
与STL兼容：设计理念与STL相似

43.2.4 其他GUI库

FLTK：轻量级跨平台GUI库，适合嵌入式系统
CEGUI：专注于游戏开发的GUI库
IUP：跨平台GUI工具包，使用C语言，有C++绑定
Juce：专注于音频应用的跨平台框架

43.3 Qt框架详解

43.3.1 Qt的安装与配置

43.3.1.1 下载与安装

访问Qt官网（https://www.qt.io/）
下载Qt Creator和所需的Qt版本
运行安装程序，选择所需的组件
完成安装后，启动Qt Creator

43.3.1.2 Qt Creator的使用

项目创建：通过向导创建新项目
代码编辑：支持语法高亮、代码补全等功能
设计师：可视化设计界面
调试器：内置调试功能
构建系统：支持qmake和CMake

43.3.2 Qt的信号槽机制

信号槽是Qt的核心特性，用于对象间的通信。

43.3.2.1 基本语法

// 定义信号和槽的类需要继承自QObject
class MyClass : public QObject
{
    Q_OBJECT // 必须添加这个宏

public:
    MyClass(QObject *parent = nullptr);

signals: // 信号声明
    void valueChanged(int newValue);

public slots: // 槽声明
    void setValue(int value);

private:
    int m_value;
};

// 实现
MyClass::MyClass(QObject *parent) : QObject(parent), m_value(0)
{
}

void MyClass::setValue(int value)
{
    if (m_value != value) {
        m_value = value;
        emit valueChanged(m_value); // 发送信号
    }
}

// 连接信号和槽
MyClass *obj1 = new MyClass;
MyClass *obj2 = new MyClass;

QObject::connect(obj1, &MyClass::valueChanged, obj2, &MyClass::setValue);

// 当obj1的valueChanged信号被触发时，obj2的setValue槽会被调用
obj1->setValue(42); // obj2的m_value也会变为42

43.3.2.2 信号槽的优点

类型安全：编译时检查信号和槽的参数类型
松耦合：发送者和接收者不需要知道彼此的存在
灵活性：支持一对一、一对多、多对一等连接方式
线程安全：支持跨线程的信号槽连接

43.3.2.3 信号槽的连接方式

// 自动连接（默认）：根据发送者和接收者是否在同一线程选择连接方式
QObject::connect(sender, SIGNAL(signal()), receiver, SLOT(slot()));

// 直接连接：信号发送时立即调用槽，无论接收者在哪个线程
QObject::connect(sender, SIGNAL(signal()), receiver, SLOT(slot()), Qt::DirectConnection);

// 队列连接：将信号放入接收者线程的事件队列，稍后处理
QObject::connect(sender, SIGNAL(signal()), receiver, SLOT(slot()), Qt::QueuedConnection);

// 阻塞队列连接：队列连接的变体，会阻塞发送者直到槽执行完毕
QObject::connect(sender, SIGNAL(signal()), receiver, SLOT(slot()), Qt::BlockingQueuedConnection);

// 唯一连接：确保信号和槽之间只存在一个连接
QObject::connect(sender, SIGNAL(signal()), receiver, SLOT(slot()), Qt::UniqueConnection);

43.3.3 Qt的布局管理

布局管理器用于自动管理控件的位置和大小，使界面能够适应窗口大小的变化。

43.3.3.1 常用布局管理器

QVBoxLayout：垂直布局，控件垂直排列
QHBoxLayout：水平布局，控件水平排列
QGridLayout：网格布局，控件按网格排列
QFormLayout：表单布局，标签和输入控件成对排列
QStackedLayout：堆栈布局，一次只显示一个控件

43.3.3.2 布局管理器的使用

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

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    
    QWidget window;
    window.setWindowTitle("布局管理器示例");
    
    // 创建垂直布局
    QVBoxLayout *mainLayout = new QVBoxLayout(&window);
    
    // 添加标题
    QLabel *titleLabel = new QLabel("用户登录");
    mainLayout->addWidget(titleLabel);
    
    // 创建表单布局
    QFormLayout *formLayout = new QFormLayout;
    QLineEdit *usernameEdit = new QLineEdit;
    QLineEdit *passwordEdit = new QLineEdit;
    passwordEdit->setEchoMode(QLineEdit::Password);
    
    formLayout->addRow("用户名:", usernameEdit);
    formLayout->addRow("密码:", passwordEdit);
    mainLayout->addLayout(formLayout);
    
    // 创建水平布局放置按钮
    QHBoxLayout *buttonLayout = new QHBoxLayout;
    QPushButton *loginButton = new QPushButton("登录");
    QPushButton *cancelButton = new QPushButton("取消");
    
    buttonLayout->addStretch(); // 弹簧，将按钮推到右侧
    buttonLayout->addWidget(loginButton);
    buttonLayout->addWidget(cancelButton);
    mainLayout->addLayout(buttonLayout);
    
    window.show();
    return app.exec();
}

43.3.4 Qt的控件

Qt提供了丰富的内置控件，用于构建各种界面。

43.3.4.1 常用控件

按钮控件：QPushButton、QToolButton、QRadioButton、QCheckBox
输入控件：QLineEdit、QTextEdit、QPlainTextEdit、QComboBox、QSpinBox
显示控件：QLabel、QTextBrowser、QProgressBar、QStatusBar
容器控件：QGroupBox、QTabWidget、QStackedWidget、QDockWidget
列表控件：QListWidget、QTreeWidget、QTableWidget
对话框：QDialog、QMessageBox、QFileDialog、QInputDialog

43.3.4.2 自定义控件

当内置控件不能满足需求时，可以创建自定义控件。

#include <QWidget>
#include <QPainter>
#include <QMouseEvent>

class CustomButton : public QWidget
{
    Q_OBJECT

public:
    CustomButton(QWidget *parent = nullptr);
    
    void setText(const QString &text);
    QString text() const;

signals:
    void clicked();

protected:
    void paintEvent(QPaintEvent *event) override;
    void mousePressEvent(QMouseEvent *event) override;
    void mouseReleaseEvent(QMouseEvent *event) override;

private:
    QString m_text;
    bool m_pressed;
};

CustomButton::CustomButton(QWidget *parent)
    : QWidget(parent), m_pressed(false)
{
    setMinimumSize(100, 40);
}

void CustomButton::setText(const QString &text)
{
    m_text = text;
    update();
}

QString CustomButton::text() const
{
    return m_text;
}

void CustomButton::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    
    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing);
    
    // 绘制按钮背景
    QColor backgroundColor = m_pressed ? Qt::darkGray : Qt::lightGray;
    painter.setBrush(backgroundColor);
    painter.setPen(Qt::gray);
    painter.drawRoundedRect(rect(), 5, 5);
    
    // 绘制文本
    painter.setPen(Qt::black);
    painter.drawText(rect(), Qt::AlignCenter, m_text);
}

void CustomButton::mousePressEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton) {
        m_pressed = true;
        update();
    }
    QWidget::mousePressEvent(event);
}

void CustomButton::mouseReleaseEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton && m_pressed) {
        m_pressed = false;
        update();
        emit clicked();
    }
    QWidget::mouseReleaseEvent(event);
}

43.3.5 Qt的事件处理

Qt的事件处理机制允许控件响应各种事件，如鼠标事件、键盘事件、绘图事件等。

43.3.5.1 事件处理的方式

重写事件处理函数：适用于特定控件的事件处理
事件过滤器：适用于监控多个控件的事件
事件分发器：适用于自定义事件系统

43.3.5.2 重写事件处理函数

#include <QWidget>
#include <QMouseEvent>
#include <QPainter>

class DrawWidget : public QWidget
{
    Q_OBJECT

public:
    DrawWidget(QWidget *parent = nullptr);

protected:
    void mousePressEvent(QMouseEvent *event) override;
    void mouseMoveEvent(QMouseEvent *event) override;
    void paintEvent(QPaintEvent *event) override;

private:
    QPoint lastPoint;
    QPoint currentPoint;
    bool drawing;
};

DrawWidget::DrawWidget(QWidget *parent)
    : QWidget(parent), drawing(false)
{
    setFixedSize(400, 300);
    setAutoFillBackground(true);
    setBackgroundRole(QPalette::Base);
}

void DrawWidget::mousePressEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton) {
        lastPoint = event->pos();
        drawing = true;
    }
}

void DrawWidget::mouseMoveEvent(QMouseEvent *event)
{
    if (event->buttons() & Qt::LeftButton && drawing) {
        currentPoint = event->pos();
        update();
        lastPoint = currentPoint;
    }
}

void DrawWidget::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    
    QPainter painter(this);
    painter.drawLine(lastPoint, currentPoint);
}

43.3.5.3 事件过滤器

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

class EventFilterWidget : public QWidget
{
    Q_OBJECT

public:
    EventFilterWidget(QWidget *parent = nullptr);

protected:
    bool eventFilter(QObject *obj, QEvent *event) override;

private:
    QPushButton *button1;
    QPushButton *button2;
};

EventFilterWidget::EventFilterWidget(QWidget *parent)
    : QWidget(parent)
{
    setWindowTitle("事件过滤器示例");
    
    QVBoxLayout *layout = new QVBoxLayout(this);
    
    button1 = new QPushButton("按钮1");
    button2 = new QPushButton("按钮2");
    
    layout->addWidget(button1);
    layout->addWidget(button2);
    
    // 安装事件过滤器
    button1->installEventFilter(this);
    button2->installEventFilter(this);
}

bool EventFilterWidget::eventFilter(QObject *obj, QEvent *event)
{
    if (obj == button1 || obj == button2) {
        if (event->type() == QEvent::MouseButtonPress) {
            QPushButton *button = qobject_cast<QPushButton*>(obj);
            qDebug() << button->text() << "被点击";
        }
    }
    
    // 继续事件处理
    return QWidget::eventFilter(obj, event);
}

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

43.3.6 Qt的资源管理

Qt提供了资源系统，用于管理应用程序所需的图片、图标、字体等资源。

43.3.6.1 资源文件的创建

在Qt Creator中，右键点击项目，选择”添加新文件”
选择”Qt” -> “Qt Resource File”
输入资源文件名称，如”resources.qrc”
编辑资源文件，添加前缀和文件

43.3.6.2 资源的使用

// 使用资源中的图片
QPixmap pixmap(":/images/logo.png");
QLabel *label = new QLabel;
label->setPixmap(pixmap);

// 使用资源中的图标
QIcon icon(":/icons/exit.png");
QPushButton *button = new QPushButton;
button->setIcon(icon);

43.3.7 Qt的国际化

Qt提供了强大的国际化（i18n）和本地化（l10n）支持，使应用程序能够轻松支持多种语言。

43.3.7.1 国际化的基本步骤

标记可翻译字符串：使用tr()函数标记需要翻译的字符串
生成翻译源文件：使用lupdate工具生成.ts文件
翻译字符串：使用Qt Linguist工具翻译.ts文件
生成翻译文件：使用lrelease工具生成.qm文件
加载翻译文件：在应用程序中加载.qm文件

43.3.7.2 代码示例

#include <QApplication>
#include <QTranslator>
#include <QWidget>
#include <QPushButton>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    
    // 创建翻译器
    QTranslator translator;
    
    // 加载翻译文件
    if (translator.load("myapp_zh_CN.qm")) {
        app.installTranslator(&translator);
    }
    
    QWidget window;
    window.setWindowTitle(QApplication::translate("MainWindow", "Hello World"));
    
    QPushButton *button = new QPushButton(
        QApplication::translate("MainWindow", "Click Me"), &window);
    button->move(50, 50);
    
    window.setFixedSize(200, 150);
    window.show();
    
    return app.exec();
}

43.4 MFC框架

MFC（Microsoft Foundation Classes）是Microsoft提供的一套用于开发Windows应用程序的C++类库。

43.4.1 MFC的特点

Windows专用：专为Windows平台设计
与Windows API紧密集成：直接封装Windows API
文档视图架构：提供文档-视图设计模式
资源编辑器：Visual Studio提供强大的资源编辑工具
成熟稳定：经过多年发展，非常成熟
学习曲线较陡：需要了解Windows API

43.4.2 MFC的基本结构

MFC应用程序通常包含以下组件：

应用程序类：派生自CWinApp，负责应用程序的初始化、运行和终止
主框架类：派生自CFrameWnd或CMDIFrameWnd，负责主窗口的管理
视图类：派生自CView，负责用户界面的显示和交互
文档类：派生自CDocument，负责数据的管理

43.4.3 MFC的消息映射

MFC使用消息映射机制来处理Windows消息。

43.4.3.1 消息映射的基本语法

BEGIN_MESSAGE_MAP(CMyView, CView)
    ON_WM_LBUTTONDOWN() // 处理鼠标左键点击消息
    ON_COMMAND(ID_FILE_NEW, &CMyView::OnFileNew) // 处理菜单命令
END_MESSAGE_MAP()

// 消息处理函数
void CMyView::OnLButtonDown(UINT nFlags, CPoint point)
{
    // 处理鼠标左键点击
    CView::OnLButtonDown(nFlags, point);
}

void CMyView::OnFileNew()
{
    // 处理文件新建命令
}

43.4.4 MFC的控件

MFC提供了封装Windows通用控件的类：

按钮：CButton
编辑框：CEdit
列表框：CListBox
组合框：CComboBox
静态文本：CStatic
滚动条：CScrollBar
进度条：CProgressCtrl
树控件：CTreeCtrl
列表控件：CListCtrl

43.4.5 MFC应用程序示例

// MyApp.h
class CMyApp : public CWinApp
{
public:
    virtual BOOL InitInstance();
};

// MyApp.cpp
BOOL CMyApp::InitInstance()
{
    CMainFrame* pFrame = new CMainFrame;
    m_pMainWnd = pFrame;
    pFrame->LoadFrame(IDR_MAINFRAME);
    pFrame->ShowWindow(SW_SHOW);
    pFrame->UpdateWindow();
    return TRUE;
}

CMyApp theApp;

// MainFrame.h
class CMainFrame : public CFrameWnd
{
public:
    CMainFrame();
    DECLARE_MESSAGE_MAP()
};

// MainFrame.cpp
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
END_MESSAGE_MAP()

CMainFrame::CMainFrame()
{
    Create(NULL, _T("MFC Application"), WS_OVERLAPPEDWINDOW,
        CRect(0, 0, 800, 600));
}

43.5 wxWidgets框架

wxWidgets是一个开源的跨平台C++ GUI库，旨在提供与平台原生控件一致的外观和感觉。

43.5.1 wxWidgets的特点

跨平台：支持Windows、macOS、Linux等多个平台
原生外观：使用平台原生控件，外观与平台一致
开源：使用wxWindows Library Licence，允许商业使用
丰富的控件：提供大量常用控件
与STL兼容：设计理念与STL相似
事件处理：基于事件表的事件处理机制
文档和示例：提供详细的文档和示例

43.5.2 wxWidgets的基本结构

应用程序类：派生自wxApp，负责应用程序的初始化和运行
框架窗口：wxFrame，顶级窗口
面板：wxPanel，容器控件
控件：按钮、编辑框等
事件处理：使用事件表或动态事件处理

43.5.3 wxWidgets的事件处理

wxWidgets支持两种事件处理方式：事件表和动态事件处理。

43.5.3.1 事件表方式

class MyFrame : public wxFrame
{
public:
    MyFrame(const wxString& title);

private:
    void OnButtonClick(wxCommandEvent& event);
    
    wxDECLARE_EVENT_TABLE();
};

wxBEGIN_EVENT_TABLE(MyFrame, wxFrame)
    EVT_BUTTON(ID_BUTTON, MyFrame::OnButtonClick)
wxEND_EVENT_TABLE()

void MyFrame::OnButtonClick(wxCommandEvent& event)
{
    // 处理按钮点击事件
}

43.5.3.2 动态事件处理方式

class MyFrame : public wxFrame
{
public:
    MyFrame(const wxString& title);

private:
    void OnButtonClick(wxCommandEvent& event);
};

MyFrame::MyFrame(const wxString& title)
    : wxFrame(NULL, wxID_ANY, title)
{
    wxButton* button = new wxButton(this, ID_BUTTON, "Click Me");
    button->Bind(wxEVT_BUTTON, &MyFrame::OnButtonClick, this);
}

void MyFrame::OnButtonClick(wxCommandEvent& event)
{
    // 处理按钮点击事件
}

43.5.4 wxWidgets应用程序示例

#include <wx/wx.h>

class MyApp : public wxApp
{
public:
    virtual bool OnInit();
};

class MyFrame : public wxFrame
{
public:
    MyFrame(const wxString& title);

private:
    void OnHello(wxCommandEvent& event);
    void OnExit(wxCommandEvent& event);
    void OnAbout(wxCommandEvent& event);
    
    wxDECLARE_EVENT_TABLE();
};

enum
{
    ID_Hello = 1
};

wxBEGIN_EVENT_TABLE(MyFrame, wxFrame)
    EVT_MENU(ID_Hello, MyFrame::OnHello)
    EVT_MENU(wxID_EXIT, MyFrame::OnExit)
    EVT_MENU(wxID_ABOUT, MyFrame::OnAbout)
wxEND_EVENT_TABLE()

wxIMPLEMENT_APP(MyApp);

bool MyApp::OnInit()
{
    MyFrame *frame = new MyFrame("Hello World");
    frame->Show(true);
    return true;
}

MyFrame::MyFrame(const wxString& title)
    : wxFrame(NULL, wxID_ANY, title)
{
    wxMenu *menuFile = new wxMenu;
    menuFile->Append(ID_Hello, "&Hello...");
    menuFile->AppendSeparator();
    menuFile->Append(wxID_EXIT);
    
    wxMenu *menuHelp = new wxMenu;
    menuHelp->Append(wxID_ABOUT);
    
    wxMenuBar *menuBar = new wxMenuBar;
    menuBar->Append(menuFile, "&File");
    menuBar->Append(menuHelp, "&Help");
    
    SetMenuBar( menuBar );
    
    CreateStatusBar();
    SetStatusText("Welcome to wxWidgets!");
}

void MyFrame::OnHello(wxCommandEvent& event)
{
    wxLogMessage("Hello world from wxWidgets!");
}

void MyFrame::OnExit(wxCommandEvent& event)
{
    Close(true);
}

void MyFrame::OnAbout(wxCommandEvent& event)
{
    wxMessageBox("This is a wxWidgets' Hello world sample",
                 "About Hello World", wxOK | wxICON_INFORMATION);
}

43.6 事件驱动编程

43.6.1 事件驱动编程的概念

事件驱动编程是一种编程范式，程序的执行流程由事件（如用户操作、系统通知等）触发，而不是按照预先定义的顺序执行。

43.6.2 事件驱动编程的基本要素

事件：表示发生的事情，如鼠标点击、键盘按下等
事件源：产生事件的对象，如按钮、文本框等
事件处理器：处理事件的函数或方法
事件队列：存储待处理事件的数据结构
事件循环：不断检查事件队列并分发事件的循环

43.6.3 事件驱动编程的优点

响应性：程序能够及时响应用户操作
模块化：事件处理器可以独立编写和维护
灵活性：可以动态添加或移除事件处理器
用户友好：提供直观的用户交互方式

43.6.4 事件驱动编程的挑战

状态管理：需要管理程序的状态，避免状态不一致
并发：需要处理多线程环境下的事件
性能：大量事件可能导致性能问题
调试：事件流的复杂性可能使调试变得困难

43.7 布局管理

43.7.1 布局管理的重要性

布局管理是GUI开发中的重要部分，它决定了控件如何在窗口中排列和调整大小。良好的布局管理可以：

提高用户体验：界面整洁、有序
适应不同屏幕尺寸：界面能够自动调整
简化开发：减少手动计算控件位置和大小的工作
提高代码可维护性：布局逻辑清晰、易于修改

43.7.2 布局管理的类型

绝对布局：手动指定控件的位置和大小
相对布局：基于其他控件的位置和大小
布局管理器：使用专门的布局管理器自动管理

43.7.3 布局管理的最佳实践

使用布局管理器：尽量使用布局管理器而不是绝对布局
组合布局：根据需要组合使用不同的布局管理器
使用间隔和边距：合理设置控件之间的间隔和边距
考虑不同屏幕尺寸：测试界面在不同屏幕尺寸下的表现
使用容器控件：将相关控件放在容器控件中，便于管理

43.8 资源管理

43.8.1 GUI资源的类型

图标：应用程序图标、工具栏图标等
图片：背景图片、按钮图片等
字体：界面使用的字体
字符串：菜单文本、提示信息等
布局：窗口和对话框的布局
光标：自定义光标

43.8.2 资源管理的方法

嵌入资源：将资源嵌入到可执行文件中
外部资源：将资源存储为外部文件
资源缓存：缓存常用资源，提高性能
资源释放：及时释放不再使用的资源

43.8.3 资源管理的最佳实践

集中管理：使用专门的资源管理类或模块
延迟加载：只在需要时加载资源
错误处理：处理资源加载失败的情况
国际化：支持多语言资源
版本控制：对资源进行版本控制

43.9 样式和主题

43.9.1 样式和主题的概念

样式是控件的外观设置，如颜色、字体、边框等。主题是一组协调的样式，应用于整个应用程序。

43.9.2 Qt的样式

Qt支持多种样式设置方法：

QSS（Qt Style Sheets）：类似CSS的样式表
QStyle：通过代码设置样式
主题：使用预定义的主题

43.9.2.1 QSS的使用

// 在代码中设置样式表
QPushButton *button = new QPushButton("Click Me");
button->setStyleSheet(
    "QPushButton { "
    "    background-color: #4CAF50; "
    "    border: none; "
    "    color: white; "
    "    padding: 10px 20px; "
    "    text-align: center; "
    "    text-decoration: none; "
    "    display: inline-block; "
    "    font-size: 16px; "
    "    margin: 4px 2px; "
    "    border-radius: 8px; "
    "}"
    "QPushButton:hover { "
    "    background-color: #45a049; "
    "}"
    "QPushButton:pressed { "
    "    background-color: #3e8e41; "
    "}"
);

43.9.3 MFC的样式

MFC使用Windows的控件样式和自定义绘制：

控件样式：通过设置控件的样式标志
自定义绘制：通过处理WM_DRAWITEM等消息
皮肤：使用第三方皮肤库

43.9.4 样式设计的最佳实践

一致性：整个应用程序使用一致的样式
可读性：确保文本和背景的对比度足够
可访问性：考虑色盲等特殊用户的需求
性能：避免过于复杂的样式，影响性能
平台一致性：尽量与平台的默认样式保持一致

43.10 跨平台开发

43.10.1 跨平台开发的挑战

平台差异：不同平台的API、控件和行为有所不同
编译环境：不同平台的编译器和工具链不同
资源管理：不同平台的资源格式和管理方式不同
性能优化：不同平台的性能特点不同
测试：需要在多个平台上测试

43.10.2 跨平台开发的策略

使用跨平台框架：如Qt、wxWidgets等
条件编译：使用#ifdef等预处理指令处理平台差异
抽象层：创建抽象层，隐藏平台差异
平台特定代码：将平台特定的代码分离到单独的文件中
构建系统：使用跨平台的构建系统，如CMake

43.10.3 跨平台开发的最佳实践

早期测试：在开发早期就开始在多个平台上测试
代码审查：特别关注平台特定的代码
文档：记录平台差异和解决方案
持续集成：使用CI系统在多个平台上自动构建和测试
用户反馈：收集不同平台用户的反馈

43.11 项目实战：计算器应用

43.11.1 项目需求

功能需求：
- 基本算术运算（加、减、乘、除）
- 科学计算功能（平方根、三角函数等）
- 历史记录
- 内存功能（存储和召回数值）
- 错误处理（如除以零）
性能需求：
- 响应迅速，无明显延迟
- 占用资源少
界面需求：
- 简洁、直观
- 支持键盘输入
- 适应不同窗口大小

43.11.2 技术选型

GUI框架：Qt
编程语言：C++
构建系统：qmake
开发环境：Qt Creator

43.11.3 系统设计

43.11.3.1 架构设计

模型：计算引擎，处理数学运算
视图：用户界面，显示结果和接收输入
控制器：连接模型和视图，处理用户输入

43.11.3.2 类设计

Calculator：计算引擎，处理数学运算
MainWindow：主窗口，包含所有控件
Button：自定义按钮类
HistoryDialog：历史记录对话框

43.11.4 代码实现

43.11.4.1 计算引擎

// calculator.h
#ifndef CALCULATOR_H
#define CALCULATOR_H

#include <QString>
#include <QVector>

class Calculator
{
public:
    Calculator();
    
    double calculate(const QString& expression, bool& ok) const;
    void addToHistory(const QString& expression, double result);
    QVector<QPair<QString, double>> history() const;
    void clearHistory();
    
    void setMemory(double value);
    double memory() const;
    void clearMemory();

private:
    double evaluateExpression(const QString& expression, int& pos, bool& ok) const;
    double evaluateTerm(const QString& expression, int& pos, bool& ok) const;
    double evaluateFactor(const QString& expression, int& pos, bool& ok) const;
    
    QVector<QPair<QString, double>> m_history;
    double m_memory;
};

#endif // CALCULATOR_H

// calculator.cpp
#include "calculator.h"
#include <cmath>
#include <QRegularExpression>

Calculator::Calculator() : m_memory(0.0)
{
}

double Calculator::calculate(const QString& expression, bool& ok) const
{
    int pos = 0;
    double result = evaluateExpression(expression, pos, ok);
    return result;
}

void Calculator::addToHistory(const QString& expression, double result)
{
    m_history.append(qMakePair(expression, result));
    if (m_history.size() > 100) {
        m_history.removeFirst();
    }
}

QVector<QPair<QString, double>> Calculator::history() const
{
    return m_history;
}

void Calculator::clearHistory()
{
    m_history.clear();
}

void Calculator::setMemory(double value)
{
    m_memory = value;
}

double Calculator::memory() const
{
    return m_memory;
}

void Calculator::clearMemory()
{
    m_memory = 0.0;
}

double Calculator::evaluateExpression(const QString& expression, int& pos, bool& ok) const
{
    double result = evaluateTerm(expression, pos, ok);
    if (!ok) return 0.0;
    
    while (pos < expression.length()) {
        QChar op = expression[pos];
        if (op != '+' && op != '-') break;
        pos++;
        
        double term = evaluateTerm(expression, pos, ok);
        if (!ok) return 0.0;
        
        if (op == '+') {
            result += term;
        } else {
            result -= term;
        }
    }
    
    return result;
}

double Calculator::evaluateTerm(const QString& expression, int& pos, bool& ok) const
{
    double result = evaluateFactor(expression, pos, ok);
    if (!ok) return 0.0;
    
    while (pos < expression.length()) {
        QChar op = expression[pos];
        if (op != '*' && op != '/') break;
        pos++;
        
        double factor = evaluateFactor(expression, pos, ok);
        if (!ok) return 0.0;
        
        if (op == '*') {
            result *= factor;
        } else {
            if (factor == 0) {
                ok = false;
                return 0.0;
            }
            result /= factor;
        }
    }
    
    return result;
}

double Calculator::evaluateFactor(const QString& expression, int& pos, bool& ok) const
{
    while (pos < expression.length() && expression[pos].isSpace()) {
        pos++;
    }
    
    if (pos >= expression.length()) {
        ok = false;
        return 0.0;
    }
    
    QChar ch = expression[pos];
    if (ch == '(') {
        pos++;
        double result = evaluateExpression(expression, pos, ok);
        if (!ok) return 0.0;
        
        if (pos >= expression.length() || expression[pos] != ')') {
            ok = false;
            return 0.0;
        }
        pos++;
        return result;
    } else if (ch.isDigit() || ch == '.') {
        int start = pos;
        while (pos < expression.length() && (expression[pos].isDigit() || expression[pos] == '.')) {
            pos++;
        }
        bool conversionOk;
        double result = expression.mid(start, pos - start).toDouble(&conversionOk);
        if (!conversionOk) {
            ok = false;
            return 0.0;
        }
        return result;
    } else if (ch == '-') {
        pos++;
        double factor = evaluateFactor(expression, pos, ok);
        if (!ok) return 0.0;
        return -factor;
    }
    
    ok = false;
    return 0.0;
}

43.11.4.2 主窗口

// mainwindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QGridLayout>
#include <QLineEdit>
#include <QPushButton>
#include <QStackedWidget>
#include <QComboBox>
#include "calculator.h"

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private slots:
    void digitClicked();
    void operatorClicked();
    void equalsClicked();
    void clearClicked();
    void backspaceClicked();
    void memoryClicked();
    void historyClicked();
    void modeChanged(int index);

private:
    void createUI();
    void createStandardButtons();
    void createScientificButtons();
    void updateDisplay();
    void handleError(const QString& error);

    Calculator* m_calculator;
    QLineEdit* m_display;
    QStackedWidget* m_buttonStack;
    QWidget* m_standardButtons;
    QWidget* m_scientificButtons;
    QComboBox* m_modeSelector;
    
    QString m_currentExpression;
    bool m_newExpression;
    double m_result;
};

#endif // MAINWINDOW_H

// mainwindow.cpp
#include "mainwindow.h"
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QMenuBar>
#include <QMenu>
#include <QAction>
#include <QDialog>
#include <QVBoxLayout>
#include <QListWidget>
#include <QPushButton>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent),
      m_calculator(new Calculator()),
      m_newExpression(true),
      m_result(0.0)
{
    setWindowTitle("计算器");
    setMinimumSize(300, 400);
    createUI();
}

MainWindow::~MainWindow()
{
    delete m_calculator;
}

void MainWindow::createUI()
{
    QWidget* centralWidget = new QWidget(this);
    setCentralWidget(centralWidget);
    
    QVBoxLayout* mainLayout = new QVBoxLayout(centralWidget);
    
    // 显示区域
    m_display = new QLineEdit(this);
    m_display->setReadOnly(true);
    m_display->setAlignment(Qt::AlignRight);
    m_display->setFont(QFont("Arial", 20));
    m_display->setText("0");
    mainLayout->addWidget(m_display);
    
    // 模式选择
    m_modeSelector = new QComboBox(this);
    m_modeSelector->addItem("标准");
    m_modeSelector->addItem("科学");
    connect(m_modeSelector, QOverload<int>::of(&QComboBox::currentIndexChanged),
            this, &MainWindow::modeChanged);
    mainLayout->addWidget(m_modeSelector);
    
    // 按钮区域
    m_buttonStack = new QStackedWidget(this);
    mainLayout->addWidget(m_buttonStack);
    
    // 创建标准按钮
    m_standardButtons = new QWidget(this);
    createStandardButtons();
    m_buttonStack->addWidget(m_standardButtons);
    
    // 创建科学按钮
    m_scientificButtons = new QWidget(this);
    createScientificButtons();
    m_buttonStack->addWidget(m_scientificButtons);
    
    // 菜单
    QMenuBar* menuBar = new QMenuBar(this);
    setMenuBar(menuBar);
    
    QMenu* fileMenu = menuBar->addMenu("文件");
    QAction* exitAction = fileMenu->addAction("退出");
    connect(exitAction, &QAction::triggered, this, &QWidget::close);
    
    QMenu* viewMenu = menuBar->addMenu("视图");
    QAction* standardAction = viewMenu->addAction("标准模式");
    QAction* scientificAction = viewMenu->addAction("科学模式");
    connect(standardAction, &QAction::triggered, [this]() { m_modeSelector->setCurrentIndex(0); });
    connect(scientificAction, &QAction::triggered, [this]() { m_modeSelector->setCurrentIndex(1); });
    
    QMenu* helpMenu = menuBar->addMenu("帮助");
    QAction* aboutAction = helpMenu->addAction("关于");
    connect(aboutAction, &QAction::triggered, [this]() {
        QDialog dialog(this);
        dialog.setWindowTitle("关于计算器");
        QVBoxLayout* layout = new QVBoxLayout(&dialog);
        layout->addWidget(new QLabel("计算器 v1.0\n\n一个简单的Qt计算器应用"));
        QPushButton* okButton = new QPushButton("确定");
        connect(okButton, &QPushButton::clicked, &dialog, &QDialog::accept);
        layout->addWidget(okButton);
        dialog.exec();
    });
}

void MainWindow::createStandardButtons()
{
    QGridLayout* layout = new QGridLayout(m_standardButtons);
    
    // 按钮标签
    QString buttonLabels[5][4] = {
        {"MC", "MR", "MS", "M+"},
        {"C", "←", "%", "÷"},
        {"7", "8", "9", "×"},
        {"4", "5", "6", "−"},
        {"1", "2", "3", "+"},
    };
    
    // 创建按钮
    for (int row = 0; row < 5; row++) {
        for (int col = 0; col < 4; col++) {
            QPushButton* button = new QPushButton(buttonLabels[row][col]);
            button->setMinimumSize(60, 40);
            layout->addWidget(button, row, col);
            
            if (buttonLabels[row][col].length() == 1 && buttonLabels[row][col][0].isDigit()) {
                connect(button, &QPushButton::clicked, this, &MainWindow::digitClicked);
            } else if (buttonLabels[row][col] == "C") {
                connect(button, &QPushButton::clicked, this, &MainWindow::clearClicked);
            } else if (buttonLabels[row][col] == "←") {
                connect(button, &QPushButton::clicked, this, &MainWindow::backspaceClicked);
            } else if (buttonLabels[row][col] == "=" || buttonLabels[row][col] == "+") {
                // 等号和加号处理
            } else {
                connect(button, &QPushButton::clicked, this, &MainWindow::operatorClicked);
            }
        }
    }
    
    // 添加0和等号按钮
    QPushButton* zeroButton = new QPushButton("0");
    zeroButton->setMinimumSize(60, 40);
    layout->addWidget(zeroButton, 5, 0, 1, 2);
    connect(zeroButton, &QPushButton::clicked, this, &MainWindow::digitClicked);
    
    QPushButton* dotButton = new QPushButton(".");
    dotButton->setMinimumSize(60, 40);
    layout->addWidget(dotButton, 5, 2);
    connect(dotButton, &QPushButton::clicked, this, &MainWindow::digitClicked);
    
    QPushButton* equalsButton = new QPushButton("=");
    equalsButton->setMinimumSize(60, 40);
    layout->addWidget(equalsButton, 5, 3);
    connect(equalsButton, &QPushButton::clicked, this, &MainWindow::equalsClicked);
}

void MainWindow::createScientificButtons()
{
    QVBoxLayout* layout = new QVBoxLayout(m_scientificButtons);
    
    // 添加标准按钮
    layout->addWidget(m_standardButtons);
    
    // 添加科学计算按钮
    QHBoxLayout* sciLayout = new QHBoxLayout();
    QString sciButtons[] = {"sin", "cos", "tan", "sqrt", "log", "exp", "pi", "e"};
    
    for (const QString& label : sciButtons) {
        QPushButton* button = new QPushButton(label);
        button->setMinimumSize(60, 40);
        sciLayout->addWidget(button);
        connect(button, &QPushButton::clicked, this, &MainWindow::operatorClicked);
    }
    
    layout->addLayout(sciLayout);
}

void MainWindow::digitClicked()
{
    QPushButton* button = qobject_cast<QPushButton*>(sender());
    if (!button) return;
    
    QString digit = button->text();
    
    if (m_newExpression) {
        m_currentExpression = digit;
        m_newExpression = false;
    } else {
        m_currentExpression += digit;
    }
    
    updateDisplay();
}

void MainWindow::operatorClicked()
{
    QPushButton* button = qobject_cast<QPushButton*>(sender());
    if (!button) return;
    
    QString op = button->text();
    
    if (m_newExpression && m_currentExpression.isEmpty()) {
        m_currentExpression = QString::number(m_result);
    }
    
    m_currentExpression += op;
    m_newExpression = false;
    updateDisplay();
}

void MainWindow::equalsClicked()
{
    if (m_currentExpression.isEmpty()) return;
    
    bool ok = true;
    double result = m_calculator->calculate(m_currentExpression, ok);
    
    if (ok) {
        m_result = result;
        m_calculator->addToHistory(m_currentExpression, result);
        m_display->setText(QString::number(result));
        m_newExpression = true;
    } else {
        handleError("计算错误");
    }
}

void MainWindow::clearClicked()
{
    m_currentExpression.clear();
    m_newExpression = true;
    m_display->setText("0");
}

void MainWindow::backspaceClicked()
{
    if (m_currentExpression.isEmpty()) return;
    
    m_currentExpression.chop(1);
    if (m_currentExpression.isEmpty()) {
        m_display->setText("0");
        m_newExpression = true;
    } else {
        updateDisplay();
    }
}

void MainWindow::memoryClicked()
{
    QPushButton* button = qobject_cast<QPushButton*>(sender());
    if (!button) return;
    
    QString action = button->text();
    
    if (action == "MC") {
        m_calculator->clearMemory();
    } else if (action == "MR") {
        double value = m_calculator->memory();
        m_currentExpression = QString::number(value);
        m_newExpression = false;
        updateDisplay();
    } else if (action == "MS") {
        m_calculator->setMemory(m_result);
    } else if (action == "M+") {
        m_calculator->setMemory(m_calculator->memory() + m_result);
    }
}

void MainWindow::historyClicked()
{
    QDialog dialog(this);
    dialog.setWindowTitle("历史记录");
    
    QVBoxLayout* layout = new QVBoxLayout(&dialog);
    QListWidget* historyList = new QListWidget(&dialog);
    
    QVector<QPair<QString, double>> history = m_calculator->history();
    for (const auto& item : history) {
        QString entry = item.first + " = " + QString::number(item.second);
        historyList->addItem(entry);
    }
    
    layout->addWidget(historyList);
    
    QPushButton* clearButton = new QPushButton("清空历史", &dialog);
    connect(clearButton, &QPushButton::clicked, [this, historyList]() {
        m_calculator->clearHistory();
        historyList->clear();
    });
    
    QPushButton* closeButton = new QPushButton("关闭", &dialog);
    connect(closeButton, &QPushButton::clicked, &dialog, &QDialog::accept);
    
    QHBoxLayout* buttonLayout = new QHBoxLayout();
    buttonLayout->addWidget(clearButton);
    buttonLayout->addWidget(closeButton);
    layout->addLayout(buttonLayout);
    
    dialog.exec();
}

void MainWindow::modeChanged(int index)
{
    m_buttonStack->setCurrentIndex(index);
}

void MainWindow::updateDisplay()
{
    m_display->setText(m_currentExpression);
}

void MainWindow::handleError(const QString& error)
{
    m_display->setText(error);
    m_newExpression = true;
}

43.11.4.3 主函数

#include "mainwindow.h"
#include <QApplication>

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