C++ 结构型设计模式

C++ 设计模式自己理解整理笔记

结构型 - 适配器模式 

适配器模式（Adapter Pattern）是一种结构型设计模式，它的主要作用是将一个类的接口转换成客户希望的另一个接口，
使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。适配器模式主要有两种实现方式：类适配器模式和对象适配器模式。

类适配器

类适配器通过多重继承实现，这种方式利用了继承

优点

1. 直接调用：由于适配器类继承了被适配类，所以可以直接调用被适配类的方法，性能可能会稍微好一些。
2. 更简单：适配器和被适配类在同一个对象中，不需要间接调用。

缺点

1. 多重继承的局限性：C++中的多重继承可能导致菱形继承问题，而且某些情况下可能会引入复杂性和维护难度。
2. 不灵活：类适配器不能适配多个被适配类，适配器和被适配类的绑定在编译时确定，不如对象适配器灵活。

#include <iostream>
#include <string>
 
 
// 目标接口
class Target
{
public:
    virtual ~Target() = default;
    virtual void request() const = 0;
};
 
// 需要适配的类
class Adaptee
{
public:
    void specificRequest() const
    {
        std::cout << "Adaptee: Specific request.\n";
    }
};
 
// 类适配器
class Adapter : public Target, private Adaptee
{
public:
    void request() const override
    {
        specificRequest();
    }
};
 
int main()
{
    target *target = new adapter();
    target->request();
    delete target;
 
    return 0;
}

对象适配器

对象适配器通过在适配器类中包含一个指向被适配对象的指针来实现。这种方式利用了对象组合

优点

1. 组合优于继承：对象适配器遵循了“组合优于继承”的设计原则。
2. 灵活性：可以适配多个被适配类的对象，可以在运行时选择要适配的对象。
3. 解耦：适配器和被适配对象之间的耦合度较低。

缺点

1. 额外的间接层：因为需要通过指针间接调用被适配对象的方法，性能可能会略低于类适配器。

#include <iostream>
#include <string>
 
// 目标接口
class Target
{
public:
    virtual ~Target() = default;
    virtual void request() const = 0;
};
 
// 需要适配的类
class Adaptee
{
public:
    void specificRequest() const
    {
        std::cout << "Adaptee: Specific request.\n";
    }
};
 
// 对象适配器
class Adapter : public Target
{
private:
    Adaptee *adaptee;
 
public:
    Adapter(Adaptee *a)
        : adaptee(a)
    {
    }
    void request() const override
    {
        adaptee->specificRequest();
    }
};
 
int main()
{
    Adaptee *adptee = new Adaptee();
    Target *target = new Adapter(adptee);
    target->request();
 
    delete target;
    delete adptee;
}
 

结构型 - 装饰器模式 

装饰器模式（Decorator Pattern）是一种结构型设计模式，允许向一个现有对象添加新的功能，同时又不改变其结构。装饰器模式通过创建一个装饰类来包装原始类，可以在不改变原始类代码的情况下扩展其功能。以下是装饰器模式的主要优缺点：

优点

1. 遵循开闭原则：

   • 装饰器模式遵循开闭原则，即对扩展开放，对修改关闭。你可以通过添加新的装饰类来扩展对象的功能，而无需修改现有的代码。

2. 灵活性：

   • 可以在运行时动态地添加或撤销对象的功能。你可以根据需要随时组合不同的装饰器来改变对象的行为。

3. 细粒度的功能扩展：

   • 每个装饰器可以单独添加一个特定的功能，可以非常精细地控制对象的行为变化。

4. 减少子类的数量：

   • 通过使用装饰器模式，可以避免创建大量的子类来实现不同的功能组合，从而减少类的数量和复杂性。

缺点

1. 增加复杂性：

   • 装饰器模式会增加系统类的数量，并且由于使用了对象的递归组合，导致调试和排查问题时的复杂度增加。

2. 创建大量的小对象：

   • 每个功能的扩展都会创建一个新的装饰器对象，这可能导致系统中存在大量的小对象，从而增加内存开销。

3. 依赖装饰器的顺序：

   • 装饰器的功能可能依赖于其应用的顺序，不同的组合顺序可能导致不同的行为，这需要开发者非常小心地处理。

4. 违背单一职责原则：

   • 如果装饰器类的职责不明确，可能会导致单一职责原则被破坏。每个装饰器类应该只负责一个功能扩展，否则会增加类的复杂性和职责混乱。

     #include <iostream>
     #include <string>
      
     //动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式相比生成子类更为灵活。
      
     //抽象类
     class Jbgz
     {
     public:
         virtual ~Jbgz() = default;
      
         virtual std::string GetName() = 0;
      
         virtual double GetMemary() = 0;
     };
      
     //实现类
     class SimpleJbgz : public Jbgz
     {
     public:
         virtual ~SimpleJbgz()
         {
             std::cout << "SimpleJbgz析构" << std::endl;
         }
      
         virtual std::string GetName() override
         {
             return "基本版 ";
         }
      
         virtual double GetMemary() override
         {
             return 5.5;
         }
     };
      
     class DecoratorJbgz : public Jbgz
     {
     public:
         ~DecoratorJbgz()
         {
             delete _jb;
             std::cout << "装饰类析构" << std::endl;
         }
      
         DecoratorJbgz(Jbgz *jb)
             : _jb(jb)
         {
         }
      
     protected:
         Jbgz *_jb = nullptr;
     };
      
     class EegJbgz : public DecoratorJbgz
     {
     public:
         ~EegJbgz()
         {
             std::cout << "Eeg析构" << std::endl;
         }
      
         EegJbgz(Jbgz *jb)
             : DecoratorJbgz(jb)
         {
         }
      
         std::string GetName() override
         {
             return _jb->GetName() + "Eeg    ";
         }
      
         double GetMemary() override
         {
             return _jb->GetMemary() + 2.0;
         }
     };
      
     class LtJbgz : public DecoratorJbgz
     {
     public:
         ~LtJbgz()
         {
             std::cout << "LT析构" << std::endl;
         }
      
         LtJbgz(Jbgz *jb)
             : DecoratorJbgz(jb)
         {
         }
      
         std::string GetName() override
         {
             return _jb->GetName() + "Lt ";
         }
      
         double GetMemary() override
         {
             return _jb->GetMemary() + 1.0;
         }
     };
      
     int main()
     {
         Jbgz *simJb = new SimpleJbgz();
         std::cout << simJb->GetName() << std::endl;
         std::cout << simJb->GetMemary() << std::endl;
      
         simJb = new EegJbgz(simJb);
         std::cout << simJb->GetName() << std::endl;
         std::cout << simJb->GetMemary() << std::endl;
      
         simJb = new LtJbgz(simJb);
         std::cout << simJb->GetName() << std::endl;
         std::cout << simJb->GetMemary() << std::endl;
      
         delete simJb;
      
         return 0;
     }