揭秘 C++ 框架中设计模式的灵活组合策略

C++ 是一种强大且灵活的编程语言，广泛应用于系统软件、游戏开发以及高性能计算领域。在开发复杂系统时，我们常常要面对代码可维护性、扩展性等一系列挑战。这时，设计模式作为常用的解决方案显得尤为重要。本篇文章将探讨如何在 C++ 框架中灵活地组合使用设计模式，从而打造出高效且可维护的架构。

策略模式与工厂模式的结合

策略模式通过定义一系列可以相互替换的算法，从而使得客户可以通过相应的策略对象去调用这些算法。工厂模式用于创建对象，封装了具体类的实例化过程。当策略模式需要灵活地创建策略对象时，可以结合工厂模式来实现。

实现方式

我们可以创建一个策略接口类（Strategy）和两个具体策略类（ConcreteStrategyA 和 ConcreteStrategyB）。同时，使用工厂模式来创建这些具体的策略对象。

// 策略接口

class Strategy {
public:
    virtual void execute() const = 0;
};
// 具体策略A
class ConcreteStrategyA : public Strategy {
public:
    void execute() const override {
        std::cout << "Executing strategy A" << std::endl;
    }
};
// 具体策略B
class ConcreteStrategyB : public Strategy {
public:
    void execute() const override {
        std::cout << "Executing strategy B" << std::endl;
    }
};
// 策略工厂
class StrategyFactory {
public:
    static std::shared_ptr createStrategy(const std::string& type) {
        if (type == "A") {
            return std::make_shared();
        } else if (type == "B") {
            return std::make_shared();
        }
        return nullptr;
    }
};
// 使用示例
int main() {
    auto strategy = StrategyFactory::createStrategy("A");
    if (strategy) {
        strategy->execute();
    }
    return 0;
}

上述代码演示了通过工厂模式创建策略对象，配合策略模式的灵活调用机制，可以根据业务需求动态选择具体的策略。

单例模式与观察者模式的结合

单例模式保证一个类只有一个实例，并提供一个访问它的全局访问点。观察者模式定义了一种一对多的关系，让多个观察者对象同时监听某一个主题对象。当该主题对象发生变化时，所有的观察者都会收到通知。在 C++ 框架中，可以结合单例模式与观察者模式，实现全局事件通知机制。

实现方式

我们先定义一个单例类 ObserverManager，管理所有的观察者。同时，定义一个事件类以及观察者接口。

// 事件类

class Event {
public:
    virtual std::string getName() const = 0;
};
// 观察者接口
class Observer {
public:
    virtual void onNotify(const Event& event) = 0;
};
// 观察者管理器（单例）
class ObserverManager {
public:
    static ObserverManager& getInstance() {
        static ObserverManager instance;
        return instance;
    }
    void addObserver(Observer* observer) {
        observers.push_back(observer);
    }
    void notifyObservers(const Event& event) {
        for (auto observer : observers) {
            observer->onNotify(event);
        }
    }
private:
    ObserverManager() {}
    std::vector observers;
};
// 自定义事件
class CustomEvent : public Event {
public:
    std::string getName() const override {
        return "CustomEvent";
    }
};
// 具体观察者
class ConcreteObserver : public Observer {
public:
    void onNotify(const Event& event) override {
        std::cout << "Notified of " << event.getName() << std::endl;
    }
};
// 使用示例
int main() {
    ConcreteObserver observer;
    ObserverManager::getInstance().addObserver(&observer);
    CustomEvent event;
    ObserverManager::getInstance().notifyObservers(event);
    return 0;
}

通过将观察者管理器实现为单例，确保全局只有一个实例管理所有的观察者，使得事件通知机制变得更加统一和高效。

装饰模式与组合模式的结合

装饰模式通过将对象嵌入到装饰器类中，从而动态地扩展对象的功能。组合模式将对象组织成树形结构，用于表示部分-整体的层次结构。这两种模式的结合可以用来处理复杂的层次化功能扩展。

实现方式

我们先定义一个基础组件接口和具体的组件实现类，然后创建基础装饰器类和具体装饰器类，最后实现组合模式的结构。

// 基础组件接口

class Component {
public:
    virtual void operation() const = 0;
};
// 具体组件
class ConcreteComponent : public Component {
public:
    void operation() const override {
        std::cout << "ConcreteComponent operation" << std::endl;
    }
};
// 装饰器基类
class Decorator : public Component {
protected:
    std::shared_ptr component;
public:
    Decorator(std::shared_ptr comp) : component(comp) {}
    void operation() const override {
        if (component) {
            component->operation();
        }
    }
};
// 具体装饰器A
class ConcreteDecoratorA : public Decorator {
public:
    ConcreteDecoratorA(std::shared_ptr comp) : Decorator(comp) {}
    void operation() const override {
        Decorator::operation();
        std::cout << "Adding behavior A" << std::endl;
    }
};
// 具体装饰器B
class ConcreteDecoratorB : public Decorator {
public:
    ConcreteDecoratorB(std::shared_ptr comp) : Decorator(comp) {}
    void operation() const override {
        Decorator::operation();
        std::cout << "Adding behavior B" << std::endl;
    }
};
// 组合模式结构
class Composite : public Component {
private:
    std::vector> children;
public:
    void add(std::shared_ptr comp) {
        children.push_back(comp);
    }
    void operation() const override {
        for (const auto& child : children) {
            child->operation();
        }
    }
};
// 使用示例
int main() {
    auto component = std::make_shared();
    auto decoratedComponentA = std::make_shared(component);
    auto decoratedComponentB = std::make_shared(decoratedComponentA);
    Composite composite;
    composite.add(decoratedComponentB);
    composite.operation();
    return 0;
}

通过组合模式的树形结构和装饰模式的灵活扩展机制，我们可以轻松应对复杂层次结构中的功能扩展需求。

总结来说，在 C++ 框架中灵活组合设计模式，可以有效地增强代码的可维护性和扩展性。策略模式与工厂模式的结合能够动态选择策略，单例模式与观察者模式的结合实现全局事件管理，而装饰模式与组合模式的结合则处理了复杂的分层功能扩展。这些组合策略为我们提供了多种可能，为复杂系统的设计注入了更多的灵活性。