设计模式（二）（C++）

设计模式（二）

1.适配器模式

定义

将一个类的接口转换成客户希望的另一个接口。适配器模式让那些接口不兼容的类可以一起工作。

其包含适配器类（根据客户的需求，将适配者已有的接口转换成另一个接口）、适配者类（适配器包装的对象）。

以下以“表白暗语翻译器”为例：

#include <iostream>
#include <string>
#include <vector>

// 原有接口
class Target
{
   
public:
    virtual ~Target() = default;

    virtual std::string Answer() const
    {
   
        return "I love you\n";
    }
};

// 需要通过适配器处理的适配者
class Adaptee
{
   
public:
    std::vector<int> SpecialAnswer() const
    {
   
        return std::vector<int> {
   73,32,108,111,118,101,32,121,111,117};
    }
};

// 适配器，需要继承默认接口，可以处理适配者，便于使用
class Adapter:public Target
{
   
private:
    Adaptee *adaptee;

public:
    Adapter(Adaptee *adaptee) : adaptee(adaptee) {
   }
    // 实现对原有数据的解析
    std::string Answer() const override
    {
   
        std::vector<int> ciphertext = this->adaptee->SpecialAnswer();
        std::string cleartext;
        for(int i:ciphertext)
        {
   
            cleartext += char(i);
        }
        return cleartext;
    }
};

int main()
{
   
    Target *target = new Target;
    Adaptee *adaptee = new Adaptee;

    std::cout<<"Target mode:"<<std::endl;
    std::cout<<target->Answer();

    std::cout<<"Adaptee mode:"<<std::endl;
    Adapter *adapter = new Adapter(adaptee);
    std::cout<<adapter->Answer();
}

结果：

I Love you

I Love you

2.桥接模式

定义

将抽象部分与它的实现部分解耦，使得两者都能够独立变化。

具体来说，就是抽取其中一个维度并使之成为独立的类层次，这样就可以在初始类中引用这个新层次的对象， 从而使得一个类不必拥有所有的状态和行为。

桥接模式将两个独立变化的维度设计成两个独立的继承等级结构（而不会将两者耦合在一起形成多层继承结构），在抽象层将二者建立起一个抽象关联，该关联关系类似一座桥，将两个独立的等级结构连接起来。

其包含抽象类、实现类接口、扩充抽象类、具体实现类。

以下以“发行于Windows和Linux的不同游戏”为例：

#include <iostream>
#include <string>
// 打个不恰当的比方，实现类相当于各式各样的软件，抽象类相当于各式各样的平台
// 实现类（接口）
class Game
{
   
public:
    Game() {
   }
    virtual void Play() const = 0;
    virtual ~Game() {
   }
};

// 具体实现类
class GameA : public Game
{
   
public:
    GameA() {
   }
    void Play() const override
    {
   
        std::cout << "Play Game A" << std::endl;
    }
};

// 具体实现类
class GameB : public Game
{
   
public:
    GameB() {
   }
    void Play() const override
    {
   
        std::cout << "Play Game B" << std::endl;
    }
};

// 抽象类
class OS
{
   
public:
    OS(){
   }
	virtual void SetupGame(Game *game) = 0;
	virtual void Play() = 0;
    virtual ~OS(){
   }
protected:
	Game *game;
};

// 扩充抽象类
class Windows:public OS
{
   
public:
    Windows(){
   }
    void SetupGame(Game *game) override
    {
   
        this->game = game;
    }
    void Play() override
    {
   
        std::cout<<"On Windows:";
        this->game->Play();
    }
};

// 扩充抽象类
class Linux:public OS
{
   
public:
    Linux(