设计模式
在软件工程中，设计模式是一种通用的可重用解决方案，用于解决特定类型的问题。C++作为一种广泛使用的编程语言，支持多种设计模式来帮助开发者构建灵活且易于维护的系统。以下是一些常见的设计模式及其在C++中的实现方式：
创建型模式
创建型模式关注的是对象的创建机制，而不是类的实例化逻辑。
-
单例模式（Singleton）
- 确保一个类只有一个实例，并提供一个全局访问点。
- 在多线程环境下需要考虑线程安全。
- C++中可以使用静态局部变量来实现线程安全的单例。
-
工厂方法模式（Factory Method）
- 定义一个创建产品对象的接口，让子类决定实例化哪一个类。
- 在C++中可以使用模板方法或纯虚函数来实现。
-
抽象工厂模式（Abstract Factory）
- 提供一个接口，用于创建一系列相关或依赖的对象族，而无需指定它们具体的类。
- C++中可以使用模板和继承来实现抽象工厂。
结构型模式
结构型模式处理如何组合类或对象以形成更大的结构。
-
装饰模式（Decorator）
- 动态地给一个对象添加一些额外的责任。
- 在C++中，可以通过继承和组合来实现。
-
适配器模式（Adapter）
- 将一个类的接口转换成客户希望填充的另一个接口。
- C++中可以使用继承或者组合的方式实现。
-
桥接模式（Bridge）
- 将抽象部分与它的实现部分分离，使它们都可以独立变化。
- C++中可以利用多态性和指针来实现桥接。
行为型模式
行为型模式涉及算法的分配或不同职责的分配。
-
策略模式（Strategy）
- 定义一系列算法，把它们一个个封装起来，并且使它们可相互替换。
- 在C++中，可以使用函数指针、函数对象或者是继承来实现。
-
命令模式（Command）
- 将请求封装为一个对象，从而使你可用不同的请求对客户端进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
- C++中可以通过定义命令接口和具体命令类来实现。
-
观察者模式（Observer）
- 当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
- 在C++中，可以使用STL中的容器如vector来存储观察者，也可以使用智能指针来管理观察者的生命周期。
-
状态模式（State）
- 允许一个对象在其内部状态改变时改变其行为。对象看起来似乎修改了其类。
- 在C++中，可以使用继承和多态性来实现状态模式。
-
备忘录模式（Memento）
- 在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
- C++中可以通过简单的数据结构来保存状态，同时使用指向这些数据结构的指针来进行恢复。
-
迭代器模式（Iterator）
- 提供一种方法来访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示。
- C++标准库已经提供了迭代器的概念，用户也可以自定义迭代器。
这些设计模式在实际应用中可以帮助提高代码的复用性和可维护性，使得程序结构更加清晰。不过，在选择使用哪种模式时，应根据具体的应用场景来决定，避免过度设计。
具体的示例：
创建型模式
单例模式（Singleton）
目的: 确保一个类只有一个实例，并提供一个全局访问点。
示例:
class Singleton {
private:static Singleton* instance;Singleton() {} // 私有构造函数public:static Singleton* getInstance() {if (!instance) {instance = new Singleton();}return instance;}
};// 初始化静态成员
Singleton* Singleton::instance = nullptr;// 使用
int main() {Singleton* s = Singleton::getInstance();return 0;
}
工厂方法模式（Factory Method）
目的: 定义一个创建产品对象的接口，让子类决定实例化哪一个类。
示例:
class AbstractProduct {};
class ConcreteProduct : public AbstractProduct {};class AbstractFactory {
public:virtual AbstractProduct* createProduct() = 0;
};class ConcreteFactory : public AbstractFactory {
public:AbstractProduct* createProduct() override {return new ConcreteProduct();}
};// 使用
int main() {AbstractFactory* factory = new ConcreteFactory();AbstractProduct* product = factory->createProduct();delete factory;delete product;return 0;
}
抽象工厂模式（Abstract Factory）
目的: 提供一个接口，用于创建一系列相关或依赖的对象族，而无需指定它们具体的类。
示例:
class AbstractFactory {};
class ConcreteFactory1 : public AbstractFactory {};
class ConcreteFactory2 : public AbstractFactory {};class ProductA {};
class ProductB {};// 假设ConcreteFactory1和ConcreteFactory2都有createProductA和createProductB的方法// 使用
int main() {AbstractFactory* factory = new ConcreteFactory1();ProductA* a = factory->createProductA();ProductB* b = factory->createProductB();delete factory;delete a;delete b;return 0;
}
结构型模式
装饰模式（Decorator）
目的: 动态地给一个对象添加一些额外的责任。
示例:
class Component {
public:virtual void operation() = 0;
};class ConcreteComponent : public Component {
public:void operation() override {std::cout << "ConcreteComponent\n";}
};class Decorator : public Component {
protected:Component* component;
public:Decorator(Component* c) : component(c) {}void operation() override {if (component != nullptr) {component->operation();}}
};class ConcreteDecoratorA : public Decorator {
public:ConcreteDecoratorA(Component* c) : Decorator(c) {}void operation() override {Decorator::operation();std::cout << "ConcreteDecoratorA added behavior.\n";}
};// 使用
int main() {Component* c = new ConcreteComponent();Component* d = new ConcreteDecoratorA(c);d->operation();delete d;delete c;return 0;
}
适配器模式（Adapter）
目的: 将一个类的接口转换成客户希望填充的另一个接口。
示例:
class Target {
public:virtual void request() = 0;
};class Adaptee {
public:void specificRequest() {std::cout << "Adaptee's specific request.\n";}
};class Adapter : public Target {
private:Adaptee* adaptee;
public:Adapter() : adaptee(new Adaptee()) {}void request() override {adaptee->specificRequest();}
};// 使用
int main() {Target* target = new Adapter();target->request();delete target;return 0;
}
行为型模式
策略模式（Strategy）
目的: 定义一系列算法，把它们一个个封装起来，并且使它们可相互替换。
示例:
class Strategy {
public:virtual void algorithmInterface() = 0;
};class ConcreteStrategyA : public Strategy {
public:void algorithmInterface() override {std::cout << "ConcreteStrategyA\n";}
};class Context {
private:Strategy* strategy;
public:Context(Strategy* s) : strategy(s) {}void contextInterface() {strategy->algorithmInterface();}
};// 使用
int main() {Strategy* strategy = new ConcreteStrategyA();Context context(strategy);context.contextInterface();delete strategy;return 0;
}
以上是简化版的例子，实际应用中可能需要更复杂的逻辑来确保模式的正确实现。