设计模式是软件开发中常见问题的可重用解决方案，它们是经过验证的最佳实践，可以帮助开发者创建更灵活、可维护和可扩展的代码。在C++中，设计模式尤为重要，因为C++支持多种编程范式（如面向对象编程、泛型编程等），并且具有丰富的语言特性，使得设计模式的应用更加灵活和强大。
本文将介绍一些在C++中常用的设计模式，并结合具体示例说明其应用场景和实现方式。
1. 设计模式的分类
设计模式通常分为三大类：
- 1.创建型模式（Creational Patterns） ：关注对象的创建过程。
- 2.结构型模式（Structural Patterns） ：关注对象和类的组合。
- 3.行为型模式（Behavioral Patterns） ：关注对象之间的通信和职责分配。
2. 常用的设计模式
2.1 创建型模式
2.1.1 单例模式（Singleton）
定义：确保一个类只有一个实例，并提供一个全局访问点。
应用场景：日志记录、配置管理、线程池等。
实现示例：
cpp
取消自动换行
复制
class Singleton {
public:
static Singleton& getInstance() {
static Singleton instance;
return instance;
}
// 删除拷贝构造和赋值操作
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
Singleton() {}
};
说明：通过将构造函数设为私有，并提供一个静态的getInstance方法，确保只有一个实例存在。C++11中的局部静态变量保证了线程安全。
2.1.2 工厂模式（Factory）
定义：定义一个创建对象的接口，让子类决定实例化哪一个类。
应用场景：对象创建逻辑复杂，需要根据不同条件创建不同对象。
实现示例：
cpp
取消自动换行
复制
class Product {
public:
virtual void use() = 0;
virtual ~Product() {}
};
class ConcreteProductA : public Product {
public:
void use() override { std::cout << "Using Product A" << std::endl; }
};
class ConcreteProductB : public Product {
public:
void use() override { std::cout << "Using Product B" << std::endl; }
};
class Factory {
public:
virtual Product* createProduct() = 0;
virtual ~Factory() {}
};
class ConcreteFactoryA : public Factory {
public:
Product* createProduct() override { return new ConcreteProductA(); }
};
class ConcreteFactoryB : public Factory {
public:
Product* createProduct() override { return new ConcreteProductB(); }
};
说明：通过工厂类封装对象的创建逻辑，使得客户端代码与具体产品类解耦。
2.2 结构型模式
2.2.1 适配器模式（Adapter）
定义：将一个类的接口转换成客户希望的另一个接口。
应用场景：系统需要使用现有的类，但接口不符合需求。
实现示例：
cpp
取消自动换行
复制
class Target {
public:
virtual void request() = 0;
virtual ~Target() {}
};
class Adaptee {
public:
void specificRequest() { std::cout << "Specific Request" << std::endl; }
};
class Adapter : public Target {
public:
Adapter(Adaptee* ade) : ade_(ade) {}
void request() override { ade_->specificRequest(); }
private:
Adaptee* ade_;
};
说明：通过适配器类，将Adaptee的接口转换为Target接口。
2.2.2 装饰器模式（Decorator）
定义：动态地给一个对象添加一些额外的职责。
应用场景：需要在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
实现示例：
cpp
取消自动换行
复制
class Component {
public:
virtual void operation() = 0;
virtual ~Component() {}
};
class ConcreteComponent : public Component {
public:
void operation() override { std::cout << "Concrete Component" << std::endl; }
};
class Decorator : public Component {
public:
Decorator(Component* cmp) : cmp_(cmp) {}
void operation() override {
cmp_->operation();
addedBehavior();
}
private:
void addedBehavior() { std::cout << "Added Behavior" << std::endl; }
Component* cmp_;
};
说明：通过装饰器类，可以在不修改原有类的情况下，动态地添加功能。
2.3 行为型模式
2.3.1 观察者模式（Observer）
定义：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。
应用场景：事件处理、消息通知等。
实现示例：
cpp
取消自动换行
复制
class Observer {
public:
virtual void update() = 0;
virtual ~Observer() {}
};
class Subject {
public:
void attach(Observer* obs) { observers_.push_back(obs); }
void notify() {
for(auto obs : observers_) {
obs->update();
}
}
private:
std::vector<Observer*> observers_;
};
class ConcreteObserver : public Observer {
public:
void update() override { std::cout << "Observer updated" << std::endl; }
};
说明：通过主题（Subject）和观察者（Observer）之间的交互，实现对象间的通知机制。
2.3.2 策略模式（Strategy）
定义：定义一系列算法，将每个算法封装起来，并使它们可以相互替换。
应用场景：需要在运行时选择不同的算法。
实现示例：
cpp
取消自动换行
复制
class Strategy {
public:
virtual void algorithm() = 0;
virtual ~Strategy() {}
};
class ConcreteStrategyA : public Strategy {
public:
void algorithm() override { std::cout << "Algorithm A" << std::endl; }
};
class ConcreteStrategyB : public Strategy {
public:
void algorithm() override { std::cout << "Algorithm B" << std::endl; }
};
class Context {
public:
Context(Strategy* strat) : strat_(strat) {}
void setStrategy(Strategy* strat) { strat_ = strat; }
void execute() { strat_->algorithm(); }
private:
Strategy* strat_;
};
说明：通过策略类，可以在运行时动态地切换不同的算法。
3. 设计模式的选择与使用
选择合适的设计模式需要根据具体的应用场景和问题需求。以下是一些选择设计模式的建议：
- 理解问题：明确问题的核心需求和约束条件。
- 分析现有模式：了解各种设计模式的优缺点和应用场景。
- 权衡利弊：根据实际情况，权衡不同模式的利弊，选择最合适的模式。
- 灵活应用：设计模式不是一成不变的，可以根据需要进行调整和组合。
