适配器模式（Adapter Pattern）

定义

适配器模式是一种结构型设计模式，它允许将一个类的接口转换成客户希望的另一个接口。这种模式通常用于解决接口不兼容的问题。适配器模式包括三个角色：目标接口（Target）、适配器（Adapter）和被适配者（Adaptee）。

示例

在 C++ 中，适配器模式可以通过类适配器和对象适配器两种方式来实现。下面分别介绍这两种方式，并提供相应的示例。

类适配器

在类适配器中，适配器类继承自目标接口类，并且包含一个被适配者类的实例。

#include <iostream>

// 目标接口
class Target {
public:
    virtual void request() = 0;
};

// 被适配者类
class Adaptee {
public:
    void specificRequest() {
        std::cout << "Adaptee: specificRequest\n";
    }
};

// 适配器类
class Adapter : public Target, private Adaptee {
public:
    void request() override {
        specificRequest();
    }
};

// 客户端代码
int main() {
    Target* target = new Adapter();
    target->request();

    delete target;
    return 0;
}

在这个例子中，Target 是目标接口，Adaptee 是被适配者，而 Adapter 则通过继承 Target 并包含 Adaptee 的实例来实现适配。

对象适配器

在对象适配器中，适配器类持有一个被适配者类的实例，并实现目标接口。

#include <iostream>

// 目标接口
class Target {
public:
    virtual void request() = 0;
};

// 被适配者类
class Adaptee {
public:
    void specificRequest() {
        std::cout << "Adaptee: specificRequest\n";
    }
};

// 适配器类
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;
}

在对象适配器中，Adapter 持有一个 Adaptee 的实例，并实现了 Target 接口，从而将 Adaptee 的接口转换成了 Target 的接口。

这就是适配器模式在 C++ 中的示例。适配器模式可以很好地解决接口不兼容的问题，使得原本不兼容的类能够协同工作。

生活中的应用

在生活中，适配器模式的一个常见应用是电源适配器。考虑以下情况：你带着笔记本电脑去国外旅行，但是国外的电源插座与你笔记本电脑的电源插头不兼容。这时你需要一个电源适配器，将国外的电源插座转换成你笔记本电脑所需的插头类型，以便正确地充电。

让我们用 C++ 来模拟这个情景，实现一个简单的电源适配器示例：

#include <iostream>
#include <string>

// 目标接口：笔记本电脑充电器接口
class LaptopCharger {
public:
    virtual void charge() = 0;
};

// 笔记本电脑
class Laptop {
public:
    void chargeWith(LaptopCharger* charger) {
        charger->charge();
    }
};

// 适配者：国外电源插座
class ForeignPowerSocket {
public:
    void providePower() {
        std::cout << "ForeignPowerSocket: Providing power.\n";
    }
};

// 适配器：电源适配器
class PowerAdapter : public LaptopCharger {
private:
    ForeignPowerSocket* socket;

public:
    PowerAdapter(ForeignPowerSocket* socket) : socket(socket) {}

    void charge() override {
        // 调用国外电源插座的方法来提供电源
        socket->providePower();
        std::cout << "PowerAdapter: Converting power to the laptop.\n";
    }
};

int main() {
    // 创建笔记本电脑
    Laptop laptop;

    // 创建国外电源插座
    ForeignPowerSocket socket;

    // 创建电源适配器
    PowerAdapter adapter(&socket);

    // 使用适配器给笔记本电脑充电
    laptop.chargeWith(&adapter);

    return 0;
}

在这个示例中，LaptopCharger 是目标接口，代表笔记本电脑的充电器接口。Laptop 类表示笔记本电脑，它有一个充电方法，接受一个实现了 LaptopCharger 接口的对象作为参数来充电。

ForeignPowerSocket 类表示国外的电源插座，它有一个提供电源的方法。PowerAdapter 类是适配器，它实现了 LaptopCharger 接口，并持有一个 ForeignPowerSocket 对象的引用。在 charge 方法中，它调用了 ForeignPowerSocket 的提供电源方法来提供电源，并输出一条消息表示正在将电源转换成笔记本电脑所需的形式。

在 main 函数中，我们创建了笔记本电脑对象、国外电源插座对象和电源适配器对象，并通过适配器给笔记本电脑充电。

这个示例展示了适配器模式在生活中的应用，即将一个电源接口转换成另一个电源接口，使得笔记本电脑能够在国外充

不是杠杠