C++设计模式

引言

设计模式是软件开发过程中解决常见问题的一种方法论。它们提供了一种通用的解决方案，帮助开发者应对软件设计中的复杂性，提高代码的可维护性和可扩展性。

本篇文章将介绍几种重要的C++设计模式，并通过具体案例和场景进行说明，以便读者能够理解并应用这些设计模式。

设计模式分类

设计模式通常分为三大类：

1. 创建型模式：关注对象的创建方式。
2. 结构型模式：关注对象的组合。
3. 行为型模式：关注对象之间的交互。

下面将详细介绍这些模式。

创建型模式

1. 单例模式 (Singleton)

定义

单例模式确保一个类只有一个实例，并提供一个全局访问点。

实现

cppCopy Code
#include <iostream>

class Singleton {
private:
    static Singleton* instance;
    
    // 私有构造函数
    Singleton() {} 

public:
    // 禁止复制构造函数
    Singleton(Singleton &other) = delete; 
    void operator=(const Singleton &) = delete; 

    static Singleton* getInstance() {
        if (!instance)
            instance = new Singleton();
        return instance;
    }

    void showMessage() {
        std::cout << "Hello, Singleton Pattern!" << std::endl;
    }
};

// 初始化静态成员
Singleton* Singleton::instance = nullptr;

int main() {
    Singleton::getInstance()->showMessage();
    return 0;
}

场景

单例模式常用于日志记录、配置管理等需要全局访问的场景。

2. 工厂模式 (Factory Method)

定义

工厂模式定义一个创建对象的接口，但让子类决定实例化哪一个类。

实现

cppCopy Code
#include <iostream>
#include <memory>

// 产品接口
class Product {
public:
    virtual void use() = 0;
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using Product A" << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "Using Product B" << std::endl;
    }
};

// 工厂接口
class Creator {
public:
    virtual std::unique_ptr<Product> factoryMethod() = 0; 
};

// 具体工厂A
class ConcreteCreatorA : public Creator {
public:
    std::unique_ptr<Product> factoryMethod() override {
        return std::make_unique<ConcreteProductA>();
    }
};

// 具体工厂B
class ConcreteCreatorB : public Creator {
public:
    std::unique_ptr<Product> factoryMethod() override {
        return std::make_unique<ConcreteProductB>();
    }
};

int main() {
    ConcreteCreatorA creatorA;
    std::unique_ptr<Product> productA = creatorA.factoryMethod();
    productA->use();

    ConcreteCreatorB creatorB;
    std::unique_ptr<Product> productB = creatorB.factoryMethod();
    productB->use();

    return 0;
}

场景

工厂模式适合于需要创建复杂对象或多个相似对象的场景，如数据库连接、图形界面组件等。

结构型模式

1. 适配器模式 (Adapter)

定义

适配器模式允许不兼容的接口协同工作，通过包装一个对象来使其接口符合另一个接口。

实现

cppCopy Code
#include <iostream>

// 目标接口
class Target {
public:
    virtual void request() {
        std::cout << "Target request" << std::endl;
    }
};

// 源类
class Adaptee {
public:
    void specificRequest() {
        std::cout << "Specific request" << std::endl;
    }
};

// 适配器类
class Adapter : public Target {
private:
    Adaptee* adaptee;
public:
    Adapter(Adaptee* a) : adaptee(a) {}

    void request() override {
        adaptee->specificRequest();
    }
};

int main() {
    Adaptee* adaptee = new Adaptee();
    Target* adapter = new Adapter(adaptee);
    adapter->request();

    delete adaptee;
    delete adapter;
    return 0;
}

场景

适配器模式常用于需要整合多个不兼容的接口时，例如在第三方库的集成中。

2. 装饰者模式 (Decorator)

定义

装饰者模式允许向现有对象添加新功能，而无需改变其结构。

实现

cppCopy Code
#include <iostream>

// 组件接口
class Component {
public:
    virtual void operation() = 0;
};

// 具体组件
class ConcreteComponent : public Component {
public:
    void operation() override {
        std::cout << "ConcreteComponent operation" << std::endl;
    }
};

// 装饰者基类
class Decorator : public Component {
protected:
    Component* component;
public:
    Decorator(Component* c) : component(c) {}

    void operation() override {
        component->operation();
    }
};

// 具体装饰者A
class ConcreteDecoratorA : public Decorator {
public:
    ConcreteDecoratorA(Component* c) : Decorator(c) {}

    void operation() override {
        Decorator::operation();
        std::cout << "ConcreteDecoratorA additional operation" << std::endl;
    }
};

// 具体装饰者B
class ConcreteDecoratorB : public Decorator {
public:
    ConcreteDecoratorB(Component* c) : Decorator(c) {}

    void operation() override {
        Decorator::operation();
        std::cout << "ConcreteDecoratorB additional operation" << std::endl;
    }
};

int main() {
    ConcreteComponent* component = new ConcreteComponent();
    ConcreteDecoratorA* decoratorA = new ConcreteDecoratorA(component);
    ConcreteDecoratorB* decoratorB = new ConcreteDecoratorB(decoratorA);

    decoratorB->operation();

    delete decoratorB;
    delete decoratorA;
    delete component;
    return 0;
}

场景

装饰者模式适用于动态地为对象添加功能，如图形界面元素、输入流和输出流的增强等。

行为型模式

1. 观察者模式 (Observer)

定义

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某个主题对象的状态变化。

实现

cppCopy Code
#include <iostream>
#include <vector>

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

// 主题接口
class Subject {
public:
    virtual void attach(Observer* observer) = 0;
    virtual void detach(Observer* observer) = 0;
    virtual void notify() = 0;
};

// 具体主题
class ConcreteSubject : public Subject {
private:
    std::vector<Observer*> observers;
    int state;

public:
    void attach(Observer* observer) override {
        observers.push_back(observer);
    }

    void detach(Observer* observer) override {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }

    void notify() override {
        for (auto observer : observers) {
            observer->update(state);
        }
    }

    void setState(int value) {
        state = value;
        notify();
    }
};

// 具体观察者
class ConcreteObserver : public Observer {
private:
    std::string name;

public:
    ConcreteObserver(std::string name) : name(name) {}

    void update(int value) override {
        std::cout << "Observer " << name << " received value: " << value << std::endl;
    }
};

int main() {
    ConcreteSubject subject;
    ConcreteObserver observer1("A");
    ConcreteObserver observer2("B");

    subject.attach(&observer1);
    subject.attach(&observer2);

    subject.setState(10);
    subject.setState(20);

    return 0;
}

场景

观察者模式常用于事件驱动系统、GUI框架的组件间通讯等。

2. 策略模式 (Strategy)

定义

策略模式定义了一系列算法，将每一个算法封装起来，并使它们可以互换。

实现

cppCopy Code
#include <iostream>

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

// 具体策略A
class ConcreteStrategyA : public Strategy {
public:
    void execute() override {
        std::cout << "Executing Strategy A" << std::endl;
    }
};

// 具体策略B
class ConcreteStrategyB : public Strategy {
public:
    void execute() override {
        std::cout << "Executing Strategy B" << std::endl;
    }
};

// 上下文类
class Context {
private:
    Strategy* strategy;
public:
    Context(Strategy* s) : strategy(s) {}

    void setStrategy(Strategy* s) {
        strategy = s;
    }

    void executeStrategy() {
        strategy->execute();
    }
};

int main() {
    ConcreteStrategyA strategyA;
    ConcreteStrategyB strategyB;

    Context context(&strategyA);
    context.executeStrategy();

    context.setStrategy(&strategyB);
    context.executeStrategy();

    return 0;
}

场景

策略模式适用于需要在运行时选择算法的场景，例如排序算法、支付方式选择等。

总结

本文介绍了几种常见的C++设计模式，包括单例模式、工厂模式、适配器模式、装饰者模式、观察者模式和策略模式。每种模式都有其独特的应用场景，能够帮助开发者提高代码质量和项目的可维护性。

通过理解和应用设计模式，开发者可以更有效地解决实际问题，提升软件开发的效率和质量。在实践中，结合具体业务需求灵活使用设计模式，能够显著增强系统的可扩展性和可复用性。