C++设计模式实战：23种经典实现与优化技巧

1. 设计模式在C++中的实现概述

作为一名有十年经验的C++开发者，我经常被问到如何在项目中合理运用设计模式。设计模式不是银弹，但恰当使用确实能让代码更健壮、更易维护。今天我就结合实战经验，聊聊23种经典设计模式在C++中的具体实现方式。

C++作为一门支持多范式编程的语言，其面向对象特性与设计模式有着天然的契合度。不同于Java等语言，C++需要开发者更关注内存管理、性能开销等底层细节，这使得设计模式的实现需要考虑更多因素。比如工厂模式中对象的生命周期管理，观察者模式中的指针安全问题等。

2. 创建型模式实现详解

2.1 单例模式的双重检查锁定

在C++11之前，实现线程安全的单例需要特别注意：

cpp复制class Singleton {
private:
    static Singleton* instance;
    static std::mutex mtx;
    
    Singleton() {} // 私有构造函数

public:
    static Singleton* getInstance() {
        if (instance == nullptr) { // 第一次检查
            std::lock_guard<std::mutex> lock(mtx);
            if (instance == nullptr) { // 第二次检查
                instance = new Singleton();
            }
        }
        return instance;
    }
};

注意：C++11后可以使用magic static特性实现更简洁的线程安全单例：

cpp复制Singleton& getInstance() {
    static Singleton instance;
    return instance;
}

2.2 工厂方法模式与抽象工厂

C++中实现工厂模式时，需要考虑返回对象的生命周期。这里展示一个使用unique_ptr的现代C++实现：

cpp复制class Product {
public:
    virtual ~Product() = default;
    virtual void operation() = 0;
};

class ConcreteProduct : public Product {
public:
    void operation() override { /*...*/ }
};

class Creator {
public:
    virtual std::unique_ptr<Product> create() = 0;
};

class ConcreteCreator : public Creator {
public:
    std::unique_ptr<Product> create() override {
        return std::make_unique<ConcreteProduct>();
    }
};

3. 结构型模式实践

3.1 适配器模式的实际应用

在开发跨平台库时，适配器模式特别有用。比如将Linux和Windows的文件系统接口统一：

cpp复制class LinuxFS {
public:
    void linux_open(const char* path) { /*...*/ }
};

class IFileSystem {
public:
    virtual void open(const std::string& path) = 0;
};

class LinuxFSAdapter : public IFileSystem {
    LinuxFS linuxFs;
public:
    void open(const std::string& path) override {
        linuxFs.linux_open(path.c_str());
    }
};

3.2 组合模式的树形结构实现

实现GUI系统时，组合模式能优雅处理控件嵌套：

cpp复制class Component {
public:
    virtual void render() = 0;
    virtual void add(Component*) {}
    virtual ~Component() = default;
};

class Leaf : public Component {
public:
    void render() override { /* 渲染叶子节点 */ }
};

class Composite : public Component {
    std::vector<std::unique_ptr<Component>> children;
public:
    void render() override {
        for (auto& child : children) {
            child->render();
        }
    }
    void add(Component* comp) override {
        children.emplace_back(comp);
    }
};

4. 行为型模式深度解析

4.1 观察者模式的内存安全实现

C++中实现观察者模式要特别注意避免悬垂指针。下面是使用weak_ptr的解决方案：

cpp复制class Observer : public std::enable_shared_from_this<Observer> {
public:
    virtual void update() = 0;
};

class Subject {
    std::vector<std::weak_ptr<Observer>> observers;
    std::mutex mtx;
public:
    void attach(std::weak_ptr<Observer> obs) {
        std::lock_guard<std::mutex> lock(mtx);
        observers.push_back(obs);
    }
    
    void notify() {
        std::lock_guard<std::mutex> lock(mtx);
        for (auto it = observers.begin(); it != observers.end(); ) {
            if (auto obs = it->lock()) {
                obs->update();
                ++it;
            } else {
                it = observers.erase(it);
            }
        }
    }
};

4.2 策略模式的模板实现

现代C++可以利用模板实现编译期策略选择：

cpp复制template<typename SortingStrategy>
class Sorter {
    SortingStrategy strategy;
public:
    void sort(std::vector<int>& data) {
        strategy.sort(data);
    }
};

struct QuickSort {
    void sort(std::vector<int>& data) { /*...*/ }
};

struct MergeSort {
    void sort(std::vector<int>& data) { /*...*/ }
};

// 使用示例
Sorter<QuickSort> quickSorter;
quickSorter.sort(data);

5. 设计模式应用中的常见问题

5.1 过度设计与性能损耗

在实际项目中，我曾见过过度使用设计模式导致的性能问题。比如：

• 简单场景使用抽象工厂导致类爆炸
• 频繁的小对象创建销毁（如策略模式）导致内存碎片

建议通过性能分析工具（如perf、VTune）定期检查热点，对于性能关键路径，可能需要简化设计模式的使用。

5.2 C++特有的实现陷阱

1. 多继承的钻石问题：
   当使用桥接模式等涉及多继承的场景时，注意虚继承的使用：

   cpp复制class Implementor { /*...*/ };
   
   class ConcreteImpl : virtual public Implementor { /*...*/ };
   
   class Abstraction : virtual public Implementor { /*...*/ };
   

2. 移动语义与工厂模式：
   现代C++中，工厂可以返回unique_ptr或直接返回对象（利用NRVO）：

   cpp复制std::unique_ptr<Product> createProduct() {
       return std::make_unique<ConcreteProduct>();
   }
   
   // 或者
   Product createProduct() {
       return ConcreteProduct();
   }
   

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

C++11/14/17/20的新特性改变了某些设计模式的实现方式：

1. 访问者模式的变体实现：
   使用variant和visit替代经典实现：

   cpp复制using Shape = std::variant<Circle, Square>;
   
   class Visitor {
   public:
       void operator()(const Circle& c) { /*...*/ }
       void operator()(const Square& s) { /*...*/ }
   };
   
   std::vector<Shape> shapes;
   Visitor v;
   for (auto& shape : shapes) {
       std::visit(v, shape);
   }
   

2. 命令模式的lambda表达式：
   可以用function替代命令接口：

   cpp复制class Invoker {
       std::vector<std::function<void()>> commands;
   public:
       void addCommand(std::function<void()> cmd) {
           commands.push_back(cmd);
       }
       void executeAll() {
           for (auto& cmd : commands) cmd();
       }
   };
   

在实际项目中使用设计模式时，我最大的体会是：不要为了用模式而用模式。C++项目的性能约束和复杂度往往需要我们在优雅设计和实际效率之间找到平衡点。比如在嵌入式系统中，可能就需要简化某些模式的实现。