现代C++设计模式：单例、观察者与工厂模式优化实践-嵌云网-嵌入式AI开发资源站

现代C++设计模式：单例、观察者与工厂模式优化实践

夜雨穿林

1. 现代C++与设计模式的完美结合

作为一名在C++领域深耕多年的开发者，我见证了C++11标准带来的革命性变化。现代C++不仅仅是语法糖的堆砌，它从根本上改变了我们编写代码的方式和思维模式。设计模式作为软件工程中的经典解决方案，在现代C++中获得了全新的表达方式。

传统C++实现设计模式时常常面临几个痛点：冗长的样板代码、复杂的内存管理、不够直观的多态实现，以及线程安全问题。而现代C++通过一系列新特性，让我们能够用更简洁、更安全的方式实现这些经典模式。

2. 单例模式的现代化实现

2.1 传统单例模式的痛点

在C++98时代，实现一个线程安全的单例需要大量样板代码。典型的双重检查锁定模式(DCLP)虽然有效，但实现起来相当复杂：

cpp复制class Singleton {
public:
    static Singleton* getInstance() {
        if (!instance) {
            std::lock_guard<std::mutex> lock(mutex);
            if (!instance) {
                instance = new Singleton();
            }
        }
        return instance;
    }
private:
    static Singleton* instance;
    static std::mutex mutex;
    Singleton() {}
};

这种实现有几个明显问题：需要手动管理内存、锁的开销较大、代码可读性差。

2.2 C++11的优雅解决方案

C++11标准规定，局部静态变量的初始化是线程安全的。这让我们可以用极简的方式实现单例：

cpp复制class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
private:
    Singleton() {}
};

这个实现有几个关键改进：

自动生命周期管理，无需手动释放
线程安全的懒加载
使用引用而非指针，更符合C++习惯
显式删除拷贝构造函数和赋值运算符，防止意外复制

提示：对于需要延迟初始化且依赖参数的单例，可以结合std::call_once和std::optional实现更灵活的控制。

3. 观察者模式的灵活扩展

3.1 传统观察者模式的限制

传统观察者模式通常需要定义抽象的Observer接口，然后让具体观察者继承实现：

cpp复制class Observer {
public:
    virtual void update(int value) = 0;
};

class Subject {
    std::vector<Observer*> observers;
public:
    void attach(Observer* obs) { /*...*/ }
    void notify(int value) {
        for (auto obs : observers) {
            obs->update(value);
        }
    }
};

这种实现的问题在于：

强制的继承关系限制了灵活性
裸指针管理容易导致内存问题
虚函数调用有一定性能开销

3.2 现代C++的函数式实现

现代C++可以用std::function和Lambda表达式彻底改变观察者模式：

cpp复制class Subject {
    std::vector<std::function<void(int)>> observers;
public:
    void attach(std::function<void(int)> obs) {
        observers.push_back(obs);
    }
    void notify(int value) {
        for (auto& obs : observers) {
            obs(value);
        }
    }
};

// 使用示例
Subject s;
s.attach([](int v) { std::cout << "Lambda: " << v << "\n"; });

struct Observer {
    void operator()(int v) { std::cout << "Functor: " << v << "\n"; }
};
Observer obs;
s.attach(obs);

auto func = [](int v) { /*...*/ };
s.attach(func);

这种实现的优势：

任何可调用对象都可以作为观察者，无需继承
支持Lambda表达式，代码更简洁
可以结合std::bind绑定成员函数
使用std::function替代裸指针更安全

注意：对于需要管理生命周期的场景，可以结合std::weak_ptr避免悬空回调。

4. 工厂模式的类型安全改进

4.1 传统工厂模式的问题

传统工厂模式通常返回基类指针，需要运行时类型检查：

cpp复制class Product {
public:
    virtual ~Product() {}
};

class Factory {
public:
    virtual Product* create() = 0;
};

// 使用时需要dynamic_cast检查类型
Product* p = factory.create();
if (auto derived = dynamic_cast<DerivedProduct*>(p)) {
    // 使用derived
}

这种实现的问题：

需要手动管理内存
运行时类型检查有开销
类型不安全，容易出错

4.2 现代C++的类型安全工厂

结合unique_ptr和完美转发，可以实现类型安全的工厂：

cpp复制template <typename T>
class Product {
public:
    virtual ~Product() {}
    static std::unique_ptr<T> create() {
        return std::make_unique<T>();
    }
    
    template <typename... Args>
    static std::unique_ptr<T> createWithArgs(Args&&... args) {
        return std::make_unique<T>(std::forward<Args>(args)...);
    }
};

// 使用示例
auto widget = Widget::create();
auto button = Button::createWithArgs("OK", 100, 50);

C++17的std::variant进一步增强了工厂模式的表达能力：

cpp复制using ProductVariant = std::variant<Widget, Button, Menu>;

class ProductFactory {
public:
    ProductVariant createProduct(ProductType type) {
        switch(type) {
            case WidgetType: return Widget{};
            case ButtonType: return Button{"Click", 100, 30};
            // ...
        }
    }
};

// 使用std::visit处理不同产品
std::visit([](auto&& product) {
    product.display();
}, productVariant);

这种实现的特点：

编译期类型安全
自动内存管理
支持任意参数构造
无需运行时类型检查

5. 策略模式的Lambda优化

5.1 传统策略模式的实现

传统策略模式需要为每个策略定义单独的类：

cpp复制class SortStrategy {
public:
    virtual void sort(std::vector<int>&) = 0;
};

class QuickSort : public SortStrategy { /*...*/ };
class MergeSort : public SortStrategy { /*...*/ };

class Sorter {
    std::unique_ptr<SortStrategy> strategy;
public:
    void setStrategy(std::unique_ptr<SortStrategy> s) {
        strategy = std::move(s);
    }
    void sort(std::vector<int>& data) {
        strategy->sort(data);
    }
};