现代C++设计模式：从传统实现到优雅重构

1. 为什么现代C++需要重新审视设计模式

我第一次接触设计模式是在2008年，当时还在用C++98标准。那会儿实现一个简单的工厂模式都要写一大堆样板代码，更别提更复杂的设计模式了。直到C++11标准发布后，我突然意识到：原来设计模式可以写得这么优雅！

现代C++（通常指C++11及之后的版本）带来了许多革命性的特性：lambda表达式、智能指针、移动语义、可变参数模板等等。这些特性不仅改变了我们编写C++代码的方式，也深刻影响了设计模式的实现方式。举个例子，在C++98时代实现观察者模式需要定义接口类、管理观察者列表、手动处理生命周期，而现在用std::function和智能指针，代码量能减少70%。

关键认识：设计模式的核心是解决特定问题的"思路"，而不是具体的代码实现。现代C++的特性让我们能够用更简洁、更安全的方式实现这些经典模式。

2. 现代C++中的经典设计模式实现

2.1 工厂模式的新面貌

传统工厂模式最让人头疼的就是要写一堆if-else或者switch-case来创建不同子类对象。现代C++给了我们至少三种更优雅的实现方式：

cpp复制// 方式1：使用lambda注册创建函数
class ShapeFactory {
public:
    using Creator = std::function<std::unique_ptr<Shape>()>;
    
    template<typename T>
    void registerCreator(const std::string& key) {
        creators_[key] = [] { return std::make_unique<T>(); };
    }
    
    std::unique_ptr<Shape> create(const std::string& key) {
        if (auto it = creators_.find(key); it != creators_.end())
            return it->second();
        return nullptr;
    }

private:
    std::unordered_map<std::string, Creator> creators_;
};

// 使用示例
ShapeFactory factory;
factory.registerCreator<Circle>("circle");
factory.registerCreator<Rectangle>("rect");
auto circle = factory.create("circle");

这种方式利用了std::function和模板，完全避免了手动编写创建逻辑。更妙的是，注册新类型时完全不需要修改工厂类代码，符合开闭原则。

2.2 观察者模式的现代化改造

观察者模式在现代C++中可以变得异常简洁：

cpp复制class Subject {
public:
    using Observer = std::function<void(const Event&)>;
    
    void addObserver(Observer obs) {
        observers_.push_back(std::move(obs));
    }
    
    void notify(const Event& event) {
        for (auto& obs : observers_)
            obs(event);
    }

private:
    std::vector<Observer> observers_;
};

// 使用示例
Subject subject;
subject.addObserver([](const Event& e) {
    std::cout << "Observer 1: " << e.description << std::endl;
});

这里完全不需要定义Observer接口类，任何可调用对象（函数、lambda、std::bind结果等）都可以作为观察者。结合智能指针，我们也不用担心观察者的生命周期管理问题。

3. 现代C++特有的设计模式实现

3.1 策略模式与std::function

策略模式在现代C++中几乎可以"消失"——不是真的消失，而是变得如此自然以至于你意识不到在使用它：

cpp复制class Sorter {
public:
    using SortStrategy = std::function<void(std::vector<int>&)>;
    
    void setStrategy(SortStrategy strategy) {
        strategy_ = std::move(strategy);
    }
    
    void sort(std::vector<int>& data) {
        if (strategy_) strategy_(data);
    }

private:
    SortStrategy strategy_;
};

// 使用示例
Sorter sorter;
sorter.setStrategy([](auto& data) { 
    std::sort(data.begin(), data.end()); 
});

3.2 单例模式的线程安全实现

C++11的magic static特性让线程安全的单例模式变得极其简单：

cpp复制class Singleton {
public:
    static Singleton& instance() {
        static Singleton inst;
        return inst;
    }
    
    // 删除拷贝构造和赋值
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() = default;
};

这个实现是线程安全的，因为C++11规定局部静态变量的初始化是线程安全的。而且这种写法比双重检查锁定模式更简洁高效。

4. 现代C++设计模式的最佳实践

4.1 何时使用设计模式

虽然现代C++让设计模式的实现更简单了，但并不意味着应该滥用它们。根据我的经验，以下情况特别适合使用设计模式：

1. 当系统需要支持多种算法或行为时（策略模式）
2. 当对象创建逻辑变得复杂时（工厂模式）
3. 当需要解耦事件发布者和订阅者时（观察者模式）
4. 当需要控制对共享资源的访问时（单例模式）

4.2 性能考量

现代C++的设计模式实现通常比传统实现更高效：

1. std::function相比虚函数调用有更好的内联机会
2. lambda表达式通常会被编译器优化掉
3. 移动语义减少了不必要的拷贝

但也要注意：

• std::function调用比直接函数调用稍慢
• 过度使用智能指针可能影响性能
• 模板实例化可能导致代码膨胀

4.3 可维护性建议

1. 为设计模式的使用添加清晰的注释——因为它们可能变得不那么明显了
2. 使用类型别名（using）提高代码可读性
3. 优先使用标准库组件（如std::function）而不是自己造轮子
4. 编写单元测试验证设计模式的行为

5. 实际项目中的设计模式应用案例

5.1 游戏开发中的状态模式

在一个游戏项目中，我使用std::variant和std::visit实现了状态模式：

cpp复制struct IdleState { /*...*/ };
struct RunningState { /*...*/ };
struct JumpingState { /*...*/ };

using CharacterState = std::variant<IdleState, RunningState, JumpingState>;

class Character {
public:
    void update() {
        std::visit([](auto& state) {
            state.update();
        }, state_);
    }

    template<typename T>
    void changeState(T&& newState) {
        state_ = std::forward<T>(newState);
    }

private:
    CharacterState state_;
};

这种实现方式比传统的基于继承的状态模式更高效，因为std::variant使用了值语义，避免了动态内存分配。

5.2 GUI框架中的命令模式

在一个GUI框架中，我使用lambda表达式实现了命令模式：

cpp复制class Button {
public:
    void setCommand(std::function<void()> cmd) {
        command_ = std::move(cmd);
    }
    
    void click() {
        if (command_) command_();
    }

private:
    std::function<void()> command_;
};

// 使用示例
Button saveButton;
saveButton.setCommand([&document] {
    document.saveToFile("backup.txt");
});

这种实现比传统的命令接口类简洁得多，而且可以直接捕获上下文变量。

6. 设计模式在现代C++中的演进趋势

从C++17到C++23，语言特性仍在不断发展，这将继续影响设计模式的实现方式：

1. 模式匹配（C++23提案）：可能改变访问者模式的实现方式
2. 协程（C++20）：为迭代器模式等提供了新的实现思路
3. 概念（C++20）：让模板策略模式更安全可靠
4. 反射（未来提案）：可能彻底改变工厂模式的实现方式

我个人的体会是，现代C++让设计模式从"显式"变得"隐式"。我们不再需要严格遵循GoF书中描述的类结构，而是可以利用语言特性以更自然的方式实现相同的设计思想。这降低了设计模式的使用门槛，但也要求我们更深入地理解模式背后的本质。