C/C++设计模式与架构

引言

在软件开发过程中，设计模式是一种被广泛应用的解决问题的方法论，它通过描述和抽象常见的问题和解决方案来帮助开发人员更好地设计和组织代码。C/C++作为广泛应用于系统级开发和嵌入式开发的编程语言，设计模式在其应用中起着至关重要的作用。本文将探讨如何使用常见的设计模式来构建高效、灵活和可维护的系统架构。

创建型设计模式

单例模式

单例模式是一种用于限制类实例化次数的设计模式，它确保一个类只有一个实例，并提供一个全局访问点。在C/C++中，我们可以使用静态变量和静态函数来实现单例模式。例如：

class Singleton {
private:
    static Singleton* instance;
    
    Singleton() {}  // 禁止外部实例化
    
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;

工厂模式

工厂模式是一种用于创建对象的设计模式，它将对象的创建逻辑封装在一个工厂类中，客户端只需要通过工厂类来创建对象，而无需直接调用构造函数。C/C++中，我们可以使用静态工厂方法来实现工厂模式。例如：

class Product {
public:
    virtual void operation() = 0;
};

class ConcreteProductA : public Product {
public:
    void operation() override {
        // 具体操作逻辑
    }
};

class ConcreteProductB : public Product {
public:
    void operation() override {
        // 具体操作逻辑
    }
};

class Factory {
public:
    static Product* createProduct(const std::string& type) {
        if (type == "A") {
            return new ConcreteProductA();
        } else if (type == "B") {
            return new ConcreteProductB();
        }
        return nullptr;
    }
};

原型模式

原型模式是一种用于通过克隆已有对象来创建新对象的设计模式，它避免了重复的对象实例化过程。在C/C++中，我们可以通过实现clone()函数来实现原型模式。例如：

class Prototype {
public:
    virtual Prototype* clone() = 0;
};

class ConcretePrototype : public Prototype {
public:
    Prototype* clone() override {
        return new ConcretePrototype(*this);
    }
};

结构型设计模式

适配器模式

适配器模式是一种用于将一个类的接口转换为另一个类的接口的设计模式，以方便两个不兼容的接口进行协作。在C/C++中，我们可以使用类继承或对象包装的方式来实现适配器模式。例如：

// 适配者类
class Adaptee {
public:
    void specificRequest() {
        // 具体请求逻辑
    }
};

// 目标接口
class Target {
public:
    virtual void request() = 0;
};

// 类适配器
class Adapter : public Target, private Adaptee {
public:
    void request() override {
        specificRequest();
    }
};

// 对象适配器
class Adapter : public Target {
private:
    Adaptee* adaptee;
    
public:
    Adapter(Adaptee* adaptee) : adaptee(adaptee) {}
    
    void request() override {
        adaptee->specificRequest();
    }
};

桥接模式

桥接模式是一种用于将抽象和实现解耦的设计模式，它通过将抽象和实现分离，使它们可以独立变化。在C/C++中，我们可以使用接口和实现类的组合来实现桥接模式。例如：

// 实现类接口
class Implementor {
public:
    virtual void operationImpl() = 0;
};

// 具体实现类A
class ConcreteImplementorA : public Implementor {
public:
    void operationImpl() override {
        // 具体实现逻辑
    }
};

// 具体实现类B
class ConcreteImplementorB : public Implementor {
public:
    void operationImpl() override {
        // 具体实现逻辑
    }
};

// 抽象类接口
class Abstraction {
protected:
    Implementor* implementor;
    
public:
    Abstraction(Implementor* implementor) : implementor(implementor) {}
    
    virtual void operation() = 0;
};

// 抽象类子类A
class ConcreteAbstractionA : public Abstraction {
public:
    ConcreteAbstractionA(Implementor* implementor) : Abstraction(implementor) {}
    
    void operation() override {
        implementor->operationImpl();
    }
};

// 抽象类子类B
class ConcreteAbstractionB : public Abstraction {
public:
    ConcreteAbstractionB(Implementor* implementor) : Abstraction(implementor) {}
    
    void operation() override {
        implementor->operationImpl();
    }
};

组合模式

组合模式是一种通过将对象组合成树状结构来表示部分-整体层次结构的设计模式。在C/C++中，我们可以使用递归的方式来实现组合模式。例如：

class Component {
public:
    virtual void operation() = 0;
    virtual void add(Component* component) {}
    virtual void remove(Component* component) {}
    virtual Component* getChild(int index) {
        return nullptr;
    }
};

class Leaf : public Component {
public:
    void operation() override {
        // 叶子节点操作逻辑
    }
};

class Composite : public Component {
private:
    std::vector<Component*> children;
    
public:
    void operation() override {
        for (Component* child : children) {
            child->operation();
        }
    }
    
    void add(Component* component) override {
        children.push_back(component);
    }
    
    void remove(Component* component) override {
        // 从children中移除component
    }
    
    Component* getChild(int index) override {
        return children[index];
    }
};

行为型设计模式

策略模式

策略模式是一种用于定义不同算法族并使其可以相互替换的设计模式，它将算法封装在独立的策略类中，并通过使用统一的接口来使用这些策略类。在C/C++中，我们可以使用函数指针或函数对象来实现策略模式。例如：

// 策略接口
class Strategy {
public:
    virtual void doSomething() = 0;
};

// 具体策略A
class ConcreteStrategyA : public Strategy {
public:
    void doSomething() override {
        // 具体策略A实现逻辑
    }
};

// 具体策略B
class ConcreteStrategyB : public Strategy {
public:
    void doSomething() override {
        // 具体策略B实现逻辑
    }
};

// 客户端类
class Client {
private:
    Strategy* strategy;
    
public:
    void setStrategy(Strategy* newStrategy) {
        strategy = newStrategy;
    }
    
    void executeStrategy() {
        strategy->doSomething();
    }
};

观察者模式

观察者模式是一种用于定义对象间一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会被通知并自动更新的设计模式。在C/C++中，我们可以使用回调函数或观察者接口来实现观察者模式。例如：

// 观察者接口
class Observer {
public:
    virtual void update() = 0;
};

// 具体观察者A
class ConcreteObserverA : public Observer {
public:
    void update() override {
        // 具体观察者A更新逻辑
    }
};

// 具体观察者B
class ConcreteObserverB : public Observer {
public:
    void update() override {
        // 具体观察者B更新逻辑
    }
};

// 主题类
class Subject {
private:
    std::vector<Observer*> observers;
    
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }
    
    void detach(Observer* observer) {
        // 从observers中移除observer
    }
    
    void notify() {
        for (Observer* observer : observers) {
            observer->update();
        }
    }
};

责任链模式

责任链模式是一种用于将多个对象组成责任链，并依次处理请求的设计模式，当一个对象无法处理请求时，它将请求转发给下一个对象，直到请求被处理或者到达链的末尾。在C/C++中，我们可以使用链表或迭代器来实现责任链模式。例如：

// 处理者接口
class Handler {
protected:
    Handler* successor;
    
public:
    virtual void handleRequest() = 0;
    
    void setSuccessor(Handler* successor) {
        this->successor = successor;
    }
};

// 具体处理者A
class ConcreteHandlerA : public Handler {
public:
    void handleRequest() override {
        if (/* 可以处理请求 */) {
            // 处理请求逻辑
        } else if (successor != nullptr) {
            successor->handleRequest();
        }
    }
};

// 具体处理者B
class ConcreteHandlerB : public Handler {
public:
    void handleRequest() override {
        if (/* 可以处理请求 */) {
            // 处理请求逻辑
        } else if (successor != nullptr) {
            successor->handleRequest();
        }
    }
};

总结

设计模式在C/C++系统架构中的应用是非常广泛的，通过合理地应用不同的设计模式，我们可以构建出高效、灵活和可维护的系统架构。本文介绍了一些常见的创建型、结构型和行为型设计模式，并给出了相应的代码示例。希望读者能够通过学习和实践，更好地应用设计模式来提升自己的软件开发能力。

本文来自极简博客，作者：指尖流年，转载请注明原文链接：C/C++设计模式与架构