C++ 设计模式实践：工厂模式与单例模式详解

使用方式（Qt 主窗口）：

auto sensor = SensorFactory::create("temperature");
ui->label->setText(QString("%1: %2 °C").arg(sensor->type().c_str()).arg(sensor->readValue()));

优缺点总结：

17.3.2 工厂方法模式（Factory Method）——最推荐的扩展方案

核心思想：每个产品对应一个专属工厂，新增产品时只加一对（产品类 + 工厂类），不改现有代码。

Qt 项目真实案例：不同平台 UI 组件工厂（Windows / Mac / Linux）

代码结构：

// uifactory.h
#pragma once
#include <memory>

class Button {
public:
    virtual ~Button() = default;
    virtual void render() const = 0;
};

class WindowsButton : public Button {
public:
    void render() const override { qDebug() << "Windows 风格按钮"; }
};

class MacButton : public Button {
public:
    void render() const override { qDebug() << "Mac 风格圆角按钮"; }
};

// 抽象工厂
class UIFactory {
public:
    virtual std::unique_ptr<Button> createButton() const = 0;
    virtual ~UIFactory() = default;
};

class WindowsUIFactory : public UIFactory {
public:
    std::unique_ptr<Button> createButton() const override {
        return std::make_unique<WindowsButton>();
    }
};

class MacUIFactory : public UIFactory {
public:
    std::unique_ptr<Button> createButton() const override {
        return std::make_unique<MacButton>();
    }
};

使用（配置驱动）：

std::unique_ptr<UIFactory> factory;
if (platform == "windows") {
    factory = std::make_unique<WindowsUIFactory>();
} else {
    factory = std::make_unique<MacUIFactory>();
}
auto btn = factory->createButton();
btn->render();

优点：完全符合开闭原则，新增平台只需新增工厂类，无需改动现有代码。

17.3.3 抽象工厂模式（Abstract Factory）——多产品族解决方案

适用场景：需要同时创建一组相关对象（如 UI 组件族：按钮 + 文本框 + 窗口）

Qt 项目真实案例：跨平台 UI 组件族

完整代码（简版）：

class AbstractUI {
public:
    virtual std::unique_ptr<Button> createButton() const = 0;
    virtual std::unique_ptr<TextBox> createTextBox() const = 0;
    virtual ~AbstractUI() = default;
};

class WindowsUI : public AbstractUI {
public:
    std::unique_ptr<Button> createButton() const override {
        return std::make_unique<WindowsButton>();
    }
    std::unique_ptr<TextBox> createTextBox() const override {
        return std::make_unique<WindowsTextBox>();
    }
};

17.4 单例模式：全局唯一实例

推荐写法（C++11 后最优）：局部静态变量（Meyers Singleton）

class Logger {
private:
    Logger() { qDebug() << "Logger 初始化"; }
    ~Logger() { qDebug() << "Logger 销毁"; }
public:
    static Logger& instance() {
        static Logger inst; // C++11 保证线程安全 + 延迟初始化
        return inst;
    }
    void info(const QString& msg) {
        qDebug() << "[INFO]" << msg;
    }
};

使用：

Logger::instance().info("系统启动");

为什么这是最优写法：

• 线程安全（C++11 标准保证）
• 延迟初始化（首次调用时创建）
• 无需手动 delete（静态变量自动析构）
• 代码最简洁

其他写法对比：

17.5 完整 Qt 项目示例：多模式结合的日志系统

项目名称：QtDesignPatternsDemo

核心结构：

• Logger（单例）
• LogStrategy（策略模式接口）
• ConsoleStrategy / FileStrategy（具体策略）
• LoggerFactory（简单工厂创建策略）

mainwindow.cpp（综合使用）：

Logger::instance().setStrategy(LoggerFactory::create("file"));
Logger::instance().log("INFO", "系统启动成功");

总结与推荐路线

Qt 插件系统核心原理

Qt 插件本质上是动态链接库（.dll / .so / .dylib），但必须满足以下条件：

1. 插件内部必须有一个继承自 QObject 的类
2. 该类必须使用 Q_PLUGIN_METADATA(IID "...") 宏声明一个唯一的接口标识符（IID）
3. 主程序通过 QPluginLoader::instance() 获取插件对象
4. 使用 qobject_cast<YourInterface*>(plugin) 转换为自定义接口类型

最关键的两个宏（必须成对出现）：

#define MyPluginInterface_iid "org.example.MyPluginInterface/1.0"
Q_DECLARE_INTERFACE(MyPluginInterface, MyPluginInterface_iid)

Q_PLUGIN_METADATA(IID MyPluginInterface_iid)

完整可运行的现代插件系统实现（推荐方式）

项目结构（最清晰的组织方式）

QtPluginDemo/
├── main/ 主程序
│   ├── main.cpp
│   ├── mainwindow.h/cpp/ui
│   └── CMakeLists.txt
├── plugins/ 插件目录（可独立编译）
│   ├── plugin_core/ 插件核心接口
│   │   ├── plugininterface.h
│   │   └── CMakeLists.txt
│   ├── plugin_echo/ 示例插件 1：回显插件
│   │   ├── echo_plugin.h/cpp
│   │   └── CMakeLists.txt
│   └── plugin_calculator/ 示例插件 2：计算器插件
│       ├── calc_plugin.h/cpp
│       └── CMakeLists.txt
└── CMakeLists.txt 根 CMake（可选）

1. 插件接口（plugininterface.h）

// plugin_core/plugininterface.h
#pragma once
#include <QtPlugin>
#include <QString>
#include <QWidget>

class PluginInterface {
public:
    virtual ~PluginInterface() = default;
    // 插件名称（显示在主程序界面）
    virtual QString name() const = 0;
    // 插件描述
    virtual QString description() const = 0;
    // 插件版本
    virtual QString version() const = 0;
    // 创建插件的 UI 部件（可以返回 nullptr 表示无界面）
    virtual QWidget* createWidget(QWidget *parent = nullptr) = 0;
    // 可选：插件初始化（加载资源、连接信号等）
    virtual void initialize() {}
};

#define PluginInterface_iid "org.example.PluginInterface/1.0"
Q_DECLARE_INTERFACE(PluginInterface, PluginInterface_iid)

2. 示例插件：回显插件（echo_plugin.h & .cpp）

echo_plugin.h

#pragma once
#include "plugininterface.h"

class EchoPlugin : public QObject, public PluginInterface {
    Q_OBJECT
    Q_PLUGIN_METADATA(IID PluginInterface_iid)
    Q_INTERFACES(PluginInterface)
public:
    QString name() const override { return "回显插件"; }
    QString description() const override { return "简单输入输出回显演示"; }
    QString version() const override { return "1.0.0"; }
    QWidget* createWidget(QWidget *parent = nullptr) override;
    void initialize() override;
};

echo_plugin.cpp

#include "echo_plugin.h"
#include <QVBoxLayout>
#include <QLineEdit>
#include <QTextEdit>
#include <QPushButton>
#include <QDebug>

QWidget* EchoPlugin::createWidget(QWidget *parent) {
    QWidget *w = new QWidget(parent);
    QVBoxLayout *layout = new QVBoxLayout(w);
    QLineEdit *input = new QLineEdit(w);
    input->setPlaceholderText("输入内容，按回车回显");
    QTextEdit *output = new QTextEdit(w);
    output->setReadOnly(true);
    QPushButton *clearBtn = new QPushButton("清空", w);
    layout->addWidget(input);
    layout->addWidget(output);
    layout->addWidget(clearBtn);
    connect(input, &QLineEdit::returnPressed, this, [=]() {
        QString text = input->text();
        if (!text.isEmpty()) {
            output->append(">> " + text);
            input->clear();
        }
    });
    connect(clearBtn, &QPushButton::clicked, output, &QTextEdit::clear);
    return w;
}

void EchoPlugin::initialize() {
    qDebug() << "回显插件初始化完成";
}

3. 主程序加载与调用（mainwindow.cpp 核心部分）

#include <QPluginLoader>
#include <QDir>
#include <QDebug>
#include "plugininterface.h"

void MainWindow::loadPlugins() {
    QDir pluginsDir(qApp->applicationDirPath());
#if defined(Q_OS_WIN)
    pluginsDir.cd("plugins");
#elif defined(Q_OS_MAC)
    pluginsDir.cdUp();
    pluginsDir.cd("Plugins");
#else
    pluginsDir.cd("plugins");
#endif
    const QStringList files = pluginsDir.entryList(QDir::Files);
    for (const QString &fileName : files) {
        if (!QLibrary::isLibrary(fileName)) continue;
        QPluginLoader loader(pluginsDir.absoluteFilePath(fileName));
        QObject *plugin = loader.instance();
        if (!plugin) continue;
        if (auto* myPlugin = qobject_cast<PluginInterface*>(plugin)) {
            qDebug() << "加载插件成功:" << myPlugin->name() << "版本:" << myPlugin->version();
            QWidget *w = myPlugin->createWidget();
            if (w) ui->tabWidget->addTab(w, myPlugin->name());
            myPlugin->initialize();
        } else {
            qDebug() << "插件" << fileName << "未实现 PluginInterface 接口";
        }
    }
}

CMake 配置（推荐方式）

根 CMakeLists.txt

cmake_minimum_required(VERSION 3.16)
project(QtPluginDemo LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)
find_package(Qt6 REQUIRED COMPONENTS Core Gui Widgets)

# 主程序
add_executable(QtPluginDemo main.cpp mainwindow.cpp)
target_link_libraries(QtPluginDemo PRIVATE Qt6::Core Qt6::Gui Qt6::Widgets)

# 插件接口（静态库，供插件和主程序链接）
add_library(plugin_interface INTERFACE)
target_include_directories(plugin_interface INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/plugin_core)

# 插件：echo_plugin
add_library(echo_plugin MODULE plugins/plugin_echo/echo_plugin.cpp)
target_link_libraries(echo_plugin PRIVATE Qt6::Core Qt6::Gui Qt6::Widgets plugin_interface)
set_target_properties(echo_plugin PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins")

常见问题排查清单（VS / Creator 都适用）

策略模式详解

1. 引言

策略模式（Strategy Pattern）是行为型设计模式的一种，它定义了一系列算法（策略），将每个算法封装起来，并使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户端，从而实现'算法与客户端的解耦'。

在实际开发中，当一个类需要根据不同条件选择不同行为时（如支付系统选择微信/支付宝/银行卡），直接用 if-else 会导致代码膨胀、难以扩展。策略模式通过多态接口解决这个问题，让行为像'插件'一样可插拔。

策略模式的核心价值：开闭原则（对扩展开放、对修改封闭），特别适合 Qt 项目中的动态行为切换（如渲染策略、事件处理策略）。

2. 策略模式的概念与核心思想

概念： 策略模式将可变的行为抽象为一个策略接口（Strategy），然后由上下文类（Context）持有策略对象的引用。客户端通过上下文类调用策略，从而实现行为动态切换。

工作原理：

• 上下文类不直接实现行为，而是委托给策略对象
• 策略对象通过多态（虚函数）提供具体实现
• 运行时可替换策略对象，实现行为变化

核心思想（为什么用策略模式）：

• 隔离变化：行为变化不影响上下文
• 复用算法：策略类可独立测试/复用
• 避免条件分支：取代 if-else / switch-case

3. 策略模式的结构与组成部分

策略模式有三个主要角色：

1. 抽象策略接口（Strategy）：定义所有策略的公共接口（纯虚函数）
2. 具体策略类（ConcreteStrategy）：实现接口，提供算法变体
3. 上下文类（Context）：持有策略引用，委托执行

UML 图简述（文字版）：

Context - strategy: Strategy*
+ executeStrategy()
Strategy (接口)
+ algorithmInterface() = 0
ConcreteStrategyA
+ algorithmInterface() { /* 实现 A */ }
ConcreteStrategyB
+ algorithmInterface() { /* 实现 B */ }

4. 策略模式的优点与缺点

优点：

• 灵活性高：运行时动态更换策略
• 代码复用：策略类可独立于上下文复用
• 符合开闭原则：新增策略无需改动上下文
• 测试友好：每个策略独立单元测试
• 避免分支膨胀：取代长 if-else 链

缺点：

• 类数量增加：每个策略一个类
• 客户端需知道所有策略：选择策略时需了解变体
• 开销稍高：虚函数调用 + 对象创建

5. 策略模式的适用场景

• 算法变体多：支付方式（微信/支付宝/银行卡）
• 行为动态切换：渲染策略（2D/3D/OpenGL/Vulkan）
• 条件分支复杂：排序算法（快速/归并/插入/冒泡）
• Qt 项目典型：事件处理策略（如鼠标事件分派）、动画效果策略（如淡入/滑动/旋转）

不适用场景：行为固定、变体少时（简单 if-else 就够）。

6. C++ 中的策略模式实现示例（现代写法）

示例场景：排序策略（快速排序 vs 冒泡排序），上下文是数据处理器。

strategy.h（抽象策略）

#pragma once
class SortStrategy {
public:
    virtual ~SortStrategy() = default;
    virtual void sort(std::vector<int>& data) = 0;
    virtual std::string name() const = 0;
};

quick_sort.h

#pragma once
#include "strategy.h"
#include <vector>

class QuickSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        std::sort(data.begin(), data.end());
    }
    std::string name() const override { return "快速排序"; }
};

context.h（上下文）

#pragma once
#include <memory>
#include "strategy.h"

class DataProcessor {
private:
    std::unique_ptr<SortStrategy> strategy_;
public:
    void setStrategy(std::unique_ptr<SortStrategy> s) {
        strategy_ = std::move(s);
    }
    void process(std::vector<int>& data) {
        if (strategy_) {
            strategy_->sort(data);
        }
    }
};

main.cpp

#include "context.h"
#include "quick_sort.h"
#include <iostream>

int main() {
    std::vector<int> data = {5, 3, 8, 1, 9};
    DataProcessor proc;
    proc.setStrategy(std::make_unique<QuickSort>());
    proc.process(data);
    std::cout << "排序后：";
    for (int n : data) std::cout << n << " ";
    std::cout << "\n";
    return 0;
}

7. Qt 项目中的策略模式高级实践

Qt 典型场景：动态切换绘制策略（2D vs 3D）

drawstrategy.h

#pragma once
#include <QObject>
#include <QPainter>

class DrawStrategy : public QObject {
    Q_OBJECT
public:
    virtual void draw(QPainter *painter, const QRect &rect) = 0;
};

2dstrategy.h

#pragma once
#include "drawstrategy.h"

class TwoDStrategy : public DrawStrategy {
    Q_OBJECT
public:
    void draw(QPainter *painter, const QRect &rect) override {
        painter->fillRect(rect, Qt::blue);
    }
};

mainwindow.cpp（上下文）

class Canvas : public QWidget {
    std::unique_ptr<DrawStrategy> strategy_;
public:
    void setStrategy(std::unique_ptr<DrawStrategy> s) {
        strategy_ = std::move(s);
        update();
    }
protected:
    void paintEvent(QPaintEvent *) override {
        QPainter painter(this);
        if (strategy_) {
            strategy_->draw(&painter, rect());
        }
    }
};

// 使用
Canvas *canvas = new Canvas(this);
canvas->setStrategy(std::make_unique<TwoDStrategy>());

8. 常见陷阱与最佳实践

最佳实践：

• 接口一律纯虚 + 虚析构
• 策略类轻量设计（无状态优先）
• Qt 项目中，策略类继承 QObject 支持信号

9. 完整示例项目：多态形状编辑器

项目名称：StrategyPatternQt

strategy.h（策略接口）

#pragma once
#include <QObject>
#include <QPainter>

class ShapeStrategy : public QObject {
    Q_OBJECT
public:
    virtual void draw(QPainter *painter, const QRect &rect) = 0;
};

mainwindow.cpp（使用）

// 切换策略
void MainWindow::on_switchStrategy_clicked() {
    canvas->setStrategy(std::make_unique<CircleStrategy>());
}

总结

策略模式的核心是'行为封装 + 运行时替换'，在 Qt 项目中常用于算法切换、事件处理、渲染等场景。