1. Adapter(适配器模式)

        适配器模式是一种结构型设计模式，它允许将一个类的接口转换成客户端所期望的另一个接口。这种模式通常用于解决接口不兼容的情况，使得原本由于接口不匹配而无法工作的类可以一起工作。

        在 C++ 中，适配器模式可以通过类适配器和对象适配器两种方式来实现。

1.1 类适配器

        使用多重继承实现适配器类，使其既继承目标接口，又继承被适配的类。

        以下是模式示例：

#include <iostream>// 目标接口
class Target {
public:virtual void request() = 0;
};// 被适配的类
class Adaptee {
public:void specificRequest() {std::cout << "Specific request from Adaptee" << std::endl;}
};// 类适配器，继承目标接口和被适配类
class Adapter : public Target, private Adaptee {
public:void request() override {specificRequest(); // 调用被适配类的方法}
};int main() {Target* target = new Adapter();target->request();delete target;return 0;
}

1.2 对象适配器

        使用对象组合实现适配器类，使其持有被适配的对象实例。

        以下是模式示例： 

#include <iostream>// 目标接口
class Target {
public:virtual void request() = 0;
};// 被适配的类
class Adaptee {
public:void specificRequest() {std::cout << "Specific request from Adaptee" << std::endl;}
};// 对象适配器，持有被适配类的对象实例
class Adapter : public Target {
private:Adaptee* adaptee;public:Adapter(Adaptee* adaptee) : adaptee(adaptee) {}void request() override {adaptee->specificRequest(); // 调用被适配类的方法}
};int main() {Adaptee* adaptee = new Adaptee();Target* target = new Adapter(adaptee);target->request();delete target;delete adaptee;return 0;
}

        无论是类适配器还是对象适配器，都可以实现将目标接口和被适配类进行适配，使得客户端可以统一调用目标接口的方法，而无需直接与被适配类打交道。

2. Decorator(装饰器模式)

        装饰器模式是一种结构型设计模式，它允许向现有对象添加新功能，同时又不改变其结构。这种模式通过创建包装类（装饰器）来实现，在包装类中包含一个指向被包装对象的引用，并且实现与被包装对象相同的接口。

2.1 使用继承实现装饰器模式

        以下是模式示例：

#include <iostream>// 抽象组件
class Component {
public:virtual void operation() = 0;
};// 具体组件
class ConcreteComponent : public Component {
public:void operation() override {std::cout << "Concrete Component operation" << std::endl;}
};// 抽象装饰器
class Decorator : public Component {
protected:Component* component;public:Decorator(Component* comp) : component(comp) {}void operation() override {if (component != nullptr) {component->operation();}}
};// 具体装饰器A
class ConcreteDecoratorA : public Decorator {
public:ConcreteDecoratorA(Component* comp) : Decorator(comp) {}void operation() override {Decorator::operation();addBehaviorA();}void addBehaviorA() {std::cout << "Added behavior A" << std::endl;}
};// 具体装饰器B
class ConcreteDecoratorB : public Decorator {
public:ConcreteDecoratorB(Component* comp) : Decorator(comp) {}void operation() override {Decorator::operation();addBehaviorB();}void addBehaviorB() {std::cout << "Added behavior B" << std::endl;}
};int main() {Component* component = new ConcreteComponent();Component* decoratedA = new ConcreteDecoratorA(component);Component* decoratedB = new ConcreteDecoratorB(decoratedA);decoratedB->operation();delete decoratedB;delete decoratedA;delete component;return 0;
}

2.2 使用组合实现装饰器模式

        当使用组合实现装饰器模式时，装饰器类将持有一个对被装饰对象的引用，并在其基础上添加额外的功能

#include <iostream>// 抽象组件
class Component {
public:virtual void operation() = 0;
};// 具体组件
class ConcreteComponent : public Component {
public:void operation() override {std::cout << "Concrete Component operation" << std::endl;}
};// 抽象装饰器
class Decorator : public Component {
protected:Component* component;public:Decorator(Component* comp) : component(comp) {}void operation() override {if (component != nullptr) {component->operation();}}
};// 具体装饰器A
class ConcreteDecoratorA : public Decorator {
public:ConcreteDecoratorA(Component* comp) : Decorator(comp) {}void operation() override {Decorator::operation();addBehaviorA();}void addBehaviorA() {std::cout << "Added behavior A" << std::endl;}
};// 具体装饰器B
class ConcreteDecoratorB : public Decorator {
public:ConcreteDecoratorB(Component* comp) : Decorator(comp) {}void operation() override {Decorator::operation();addBehaviorB();}void addBehaviorB() {std::cout << "Added behavior B" << std::endl;}
};int main() {Component* component = new ConcreteComponent();Decorator* decoratedA = new ConcreteDecoratorA(component);Decorator* decoratedB = new ConcreteDecoratorB(decoratedA);decoratedB->operation();delete decoratedB;delete decoratedA;delete component;return 0;
}

 3. Proxy(代理模式)

        代理模式是一种结构型设计模式，它允许通过一个代理对象控制对另一个对象的访问。代理模式可以用于各种场景，例如：远程代理、虚拟代理、保护代理等，以实现对目标对象的访问控制、延迟加载、缓存等功能。

        在 C++ 中，代理模式可以通过以下方式实现：

        ①. 虚拟代理（Virtual Proxy）：延迟加载对象，在需要时才真正创建对象。
        ②. 保护代理（Protection Proxy）：控制对象的访问权限，提供额外的安全性。
        ③. 远程代理（Remote Proxy）：在不同地址空间中代表对象，实现远程通信。

         以下是模式示例：  

#include <iostream>
#include <string>// 抽象主题
class Subject {
public:virtual void request() = 0;
};// 具体主题
class RealSubject : public Subject {
public:void request() override {std::cout << "Real Subject request" << std::endl;}
};// 代理类
class Proxy : public Subject {
private:RealSubject* realSubject;bool initialized;public:Proxy() : realSubject(nullptr), initialized(false) {}void request() override {if (!initialized) {lazyInit();}realSubject->request();}void lazyInit() {std::cout << "Proxy initializing..." << std::endl;realSubject = new RealSubject();initialized = true;}
};int main() {Proxy proxy;proxy.request();return 0;
}

        在上面的示例中，Subject 是抽象主题类，定义了对实际主题进行操作的接口。RealSubject 是具体主题类，实现了真正的业务逻辑。Proxy 是代理类，延迟初始化 RealSubject 对象，并在需要时调用其方法。

        当运行主函数时，代理对象首先进行了延迟初始化（虚拟代理的特性），然后通过代理对象调用实际主题的方法，实现了对实际主题的代理访问。

4. Composite(组合模式)

        组合模式是一种结构型设计模式，它允许将对象组合成树形结构以表示“部分-整体”的层次关系。组合模式使得客户端可以统一处理单个对象和对象组合，从而使得客户端代码更加简单且具有一致性。

        在 C++ 中，组合模式通常涉及以下几个角色：

        ①. Component（组件）：是组合中的对象声明接口，在适当的情况下，实现所有类共有接口的缺省行为。可以是抽象类或接口。

        ②. Leaf（叶子节点）：是组合中的叶节点对象，它没有子节点。

        ③. Composite（复合节点）：是组合中的复合对象，它有子节点。通常实现了在 Component 接口中定义的操作，这些操作可以通过递归调用子节点来实现。

        以下是模式示例： 

#include <iostream>
#include <string>
#include <vector>// 抽象组件类
class Component {
public:virtual void operation() const = 0;
};// 叶子节点类
class Leaf : public Component {
private:std::string name;public:Leaf(const std::string& name) : name(name) {}void operation() const override {std::cout << "Leaf " << name << " operation" << std::endl;}
};// 复合节点类
class Composite : public Component {
private:std::vector<Component*> children;public:void add(Component* component) {children.push_back(component);}void remove(Component* component) {// 省略移除逻辑}void operation() const override {for (Component* child : children) {child->operation();}}
};int main() {Leaf leafA("A");Leaf leafB("B");Composite composite;composite.add(&leafA);composite.add(&leafB);composite.operation();return 0;
}

        在上述示例中，我们定义了 Component 抽象组件类，Leaf 叶子节点类和 Composite 复合节点类。叶子节点表示组合中的最终节点，而复合节点表示可以包含子节点的节点。在 main 函数中，我们创建了两个叶子节点 leafA 和 leafB，然后将它们添加到了复合节点 composite 中，最后通过复合节点的 operation 方法调用了所有子节点的 operation 方法，实现了对整个组合结构的统一处理。

5. Facade(外观模式)

        外观模式是一种结构型设计模式，它提供了一个统一的接口，用于访问子系统中的一群接口。外观模式定义了一个高层接口，这个接口使得子系统更容易使用。

        在 C++ 中，外观模式通常包括以下几个角色：

        ①. Facade（外观）：对客户端提供简单的接口，隐藏了系统的复杂性，提供了对子系统的统一访问接口。

        ②. Subsystems（子系统）：包含了一组相关的类和接口，实现了系统的功能。

        以下是模式示例： 

#include <iostream>// 子系统A
class SubsystemA {
public:void operationA() const {std::cout << "SubsystemA operation" << std::endl;}
};// 子系统B
class SubsystemB {
public:void operationB() const {std::cout << "SubsystemB operation" << std::endl;}
};// 子系统C
class SubsystemC {
public:void operationC() const {std::cout << "SubsystemC operation" << std::endl;}
};// 外观类
class Facade {
private:SubsystemA subsystemA;SubsystemB subsystemB;SubsystemC subsystemC;public:void operation() const {subsystemA.operationA();subsystemB.operationB();subsystemC.operationC();}
};int main() {Facade facade;facade.operation();return 0;
}

6. Bridge(桥接模式)

        桥接模式是一种结构型设计模式，它将抽象部分与其实现部分分离，使它们可以独立变化，从而达到解耦的目的。桥接模式通过组合而不是继承的方式来实现这种分离。

        在 C++ 中，桥接模式通常涉及以下几个角色：

        ①. Abstraction（抽象类）：定义抽象部分的接口，并维护一个对实现部分对象的引用。

        ②. Implementor（实现类接口）：定义实现部分的接口，它与抽象部分接口保持一致。

        ③. ConcreteImplementor（具体实现类）：实现实现类接口，提供具体的实现。

        ④. RefinedAbstraction（扩充抽象类）：扩展抽象部分的接口，通常通过组合的方式来调用实现部分的方法。

        以下是模式示例： 

#include <iostream>// 实现类接口
class Implementor {
public:virtual void operationImpl() const = 0;
};// 具体实现类A
class ConcreteImplementorA : public Implementor {
public:void operationImpl() const override {std::cout << "Concrete Implementor A operation" << std::endl;}
};// 具体实现类B
class ConcreteImplementorB : public Implementor {
public:void operationImpl() const override {std::cout << "Concrete Implementor B operation" << std::endl;}
};// 抽象类
class Abstraction {
protected:Implementor* implementor;public:Abstraction(Implementor* impl) : implementor(impl) {}virtual void operation() const = 0;
};// 扩充抽象类
class RefinedAbstraction : public Abstraction {
public:RefinedAbstraction(Implementor* impl) : Abstraction(impl) {}void operation() const override {implementor->operationImpl();}
};int main() {Implementor* implA = new ConcreteImplementorA();Implementor* implB = new ConcreteImplementorB();Abstraction* abs1 = new RefinedAbstraction(implA);Abstraction* abs2 = new RefinedAbstraction(implB);abs1->operation();abs2->operation();delete abs2;delete abs1;delete implB;delete implA;return 0;
}

        在上述示例中，定义了 Implementor 实现类接口和两个具体实现类 ConcreteImplementorA 和 ConcreteImplementorB。然后定义了抽象类 Abstraction，它维护了一个对实现类的引用，并定义了抽象方法 operation。最后，定义了扩充抽象类 RefinedAbstraction，它通过组合的方式调用了实现类的方法。

        在 main 函数中，创建了具体实现类的对象，并将其传递给扩充抽象类，通过调用 operation 方法来间接调用具体实现类的方法，从而实现了抽象部分与实现部分的解耦。

7. Flyweight(享元模式)

        享元模式（Flyweight Pattern）是一种结构型设计模式，它旨在通过共享对象来减少内存使用和提高性能。该模式适用于存在大量相似对象，且这些对象可以共享部分状态的情况。

        在 C++ 中，享元模式通常涉及以下几个角色：

        ①. Flyweight（享元接口）：定义共享对象的接口，可以接受外部状态作为参数。

        ②. ConcreteFlyweight（具体享元类）：实现享元接口，并存储内部状态。具体享元类通常是可共享的。

        ③. UnsharedConcreteFlyweight（非共享具体享元类）：如果享元对象不可共享，则创建非共享具体享元类。

        ④. FlyweightFactory（享元工厂）：用于创建和管理享元对象，通常实现了享元对象的池化管理。

        以下是模式示例：

#include <iostream>
#include <unordered_map>// 享元接口
class Flyweight {
public:virtual void operation(int extrinsicState) const = 0;
};// 具体享元类
class ConcreteFlyweight : public Flyweight {
private:int intrinsicState;public:ConcreteFlyweight(int intrinsicState) : intrinsicState(intrinsicState) {}void operation(int extrinsicState) const override {std::cout << "Concrete Flyweight with intrinsic state " << intrinsicState;std::cout << " and extrinsic state " << extrinsicState << std::endl;}
};// 享元工厂
class FlyweightFactory {
private:std::unordered_map<int, Flyweight*> flyweights;public:Flyweight* getFlyweight(int key) {if (flyweights.find(key) != flyweights.end()) {return flyweights[key];} else {// 通过共享具有相同内部状态的享元对象，可以减少内存使用和提高性能;Flyweight* flyweight = new ConcreteFlyweight(key);flyweights[key] = flyweight;return flyweight;}}~FlyweightFactory() {for (auto& pair : flyweights) {delete pair.second;}flyweights.clear();}
};int main() {FlyweightFactory factory;Flyweight* flyweight1 = factory.getFlyweight(1);flyweight1->operation(100);Flyweight* flyweight2 = factory.getFlyweight(2);flyweight2->operation(200);Flyweight* flyweight3 = factory.getFlyweight(1);flyweight3->operation(300);delete flyweight3;delete flyweight2;delete flyweight1;return 0;
}