【C++】适配器模式

适配器模式（Adapter Pattern）是一种【结构型】设计模式，用于解决接口不兼容的问题。当两个原本不兼容的类需要协同工作时，适配器模式通过创建一个中间层（适配器）来转换接口，使它们能够无缝协作。这种模式在遗留系统集成、第三方库对接等场景中尤为常见。

一、模式核心概念与结构

适配器模式包含三个核心角色：

1. 目标接口（Target）：客户端期望的接口。
2. 适配者（Adaptee）：需要被适配的现有接口。
3. 适配器（Adapter）：连接目标接口和适配者的中间层，负责接口转换。

适配器模式有两种实现方式：类适配器（通过继承实现）和对象适配器（通过组合实现）。在 C++ 中，对象适配器更常用，因为它避免了多重继承的复杂性。

二、对象适配器实现示例

以下是一个将圆接口适配为矩形接口的经典示例：

#include <iostream>
#include <cmath>

// 目标接口：客户端期望的矩形接口
class Rectangle 
{
public:
    virtual ~Rectangle() {}
    virtual void draw(int x, int y, int width, int height) = 0;
};

// 适配者：现有的圆接口
class Circle {
public:
    void drawCircle(int x, int y, int radius) 
    {
        std::cout << "Drawing circle at (" << x << ", " << y 
                  << ") with radius " << radius << std::endl;
    }
};

// 对象适配器：将圆适配为矩形接口
class CircleAdapter : public Rectangle 
{
private:
    Circle circle; // 组合适配者对象

public:
    // 实现目标接口的draw方法，转换为圆的绘制逻辑
    void draw(int x, int y, int width, int height) override 
    {
        // 假设矩形的宽高相等时视为圆形（简化逻辑）
        int radius = width / 2;
        if (height == width) 
        {
            circle.drawCircle(x + radius, y + radius, radius);
        } else 
        {
            std::cout << "Invalid rectangle for circle adaptation" << std::endl;
        }
    }
};

// 客户端代码
int main() 
{
    // 使用适配器替代原生矩形接口
    Rectangle* adapter = new CircleAdapter();
    
    // 客户端调用矩形接口，但实际绘制圆形
    adapter->draw(100, 100, 50, 50);  // 绘制半径25的圆
    adapter->draw(200, 200, 80, 30);  // 输出错误信息
    
    delete adapter;
    return 0;
}

三、类适配器实现（C++ 特性限制说明）

由于 C++ 支持多重继承，类适配器可以通过继承同时实现目标接口和适配者：

// 目标接口（同上）
class Rectangle { /* ... */ };

// 适配者（同上）
class Circle { /* ... */ };

// 类适配器：通过多重继承实现
class CircleAdapter : public Rectangle, public Circle 
{
public:
    void draw(int x, int y, int width, int height) override 
    {
        // 类适配器直接调用适配者的方法
        int radius = width / 2;
        Circle::drawCircle(x + radius, y + radius, radius);
    }
};

注意：类适配器在 C++ 中较少使用，因为：

• 多重继承可能引发 “钻石继承” 等复杂性问题。
• 无法适配适配者的子类（对象适配器可通过多态解决）。

四、适配器模式的应用场景

1. 遗留系统集成：将旧接口适配为新系统接口，例如：
   • 适配 C 风格的文件操作接口到 C++ 的std::fstream。
   • 适配老式数据库驱动到现代 ORM 框架。
2. 第三方库对接：当第三方库接口与系统接口不兼容时，例如：
   • 将不同 JSON 解析库（如 nlohmann/json 与 rapidjson）的接口统一。
   • 适配不同日志库（如 log4cpp 与 spdlog）的接口。
3. 接口转换场景：
   • 将迭代器接口适配为容器接口。
   • 在图形库中适配不同坐标系（如 OpenGL 与 DirectX）。

五、智能指针与适配器模式

在现代 C++ 中，结合智能指针实现适配器更安全：

#include <memory>

class Target 
{
public:
    virtual ~Target() {}
    virtual void operation() = 0;
};

class Adaptee 
{
public:
    void specificOperation() 
    {
        std::cout << "Adaptee operation" << std::endl;
    }
};

class Adapter : public Target 
{
private:
    std::shared_ptr<Adaptee> adaptee;

public:
    Adapter(std::shared_ptr<Adaptee> a) : adaptee(a) {}
    
    void operation() override 
    {
        adaptee->specificOperation();
    }
};

六、适配器模式与其他设计模式的关系

1. 装饰器模式：
   • 适配器模式改变接口定义，装饰器模式扩展接口功能。
   • 示例：适配器将圆接口转为矩形接口，装饰器为矩形添加阴影效果。
2. 外观模式：
   • 适配器模式专注于接口转换，外观模式简化复杂子系统的接口。
   • 示例：适配器适配单个类的接口，外观为整个数据库系统提供统一接口。
3. 桥接模式：
   • 适配器模式处理接口不兼容，桥接模式分离抽象与实现。
   • 示例：适配器让不同数据库驱动兼容统一接口，桥接模式分离 SQL 生成与执行引擎。

七、优缺点分析

优点：

• 接口复用：无需修改现有代码，通过适配器实现接口兼容。
• 解耦系统：客户端与适配者解耦，降低系统耦合度。
• 扩展性强：可针对不同适配者创建多个适配器，符合开闭原则。

缺点：

• 额外开销：适配器层增加系统复杂度和调用开销。
• 设计权衡：过度使用适配器可能表明系统设计存在缺陷。

八、C++ 标准库中的适配器应用

C++ 标准库中广泛使用适配器模式：

1. 容器适配器：
   • std::stack和std::queue基于std::deque实现。
   • 示例：std::stack将deque的接口适配为栈的 LIFO 接口。
2. 迭代器适配器：
   • std::reverse_iterator反转迭代器的遍历方向。
   • std::back_insert_iterator将容器接口适配为插入迭代器。
3. 函数适配器：
   • std::mem_fn将成员函数适配为函数对象。
   • std::bind绑定函数参数，适配不同参数列表的函数。

九、实战案例：网络库接口适配

以下是一个网络库接口适配的实战示例，将旧版网络接口适配为现代接口：

// 目标接口：现代网络接口
class NetworkInterface 
{
public:
    virtual ~NetworkInterface() {}
    virtual bool connect(const std::string& host, int port) = 0;
    virtual int send(const char* data, int size) = 0;
    virtual int receive(char* buffer, int size) = 0;
    virtual void disconnect() = 0;
};

// 适配者：旧版网络接口
class LegacyNetwork 
{
public:
    // 旧接口命名和参数风格不同
    int old_connect(const char* host, int port) 
    {
        std::cout << "Connecting to " << host << ":" << port << std::endl;
        return 0; // 返回句柄
    }
    
    int old_send(int handle, const void* data, size_t len) 
    {
        std::cout << "Sending " << len << " bytes" << std::endl;
        return len;
    }
    
    int old_receive(int handle, void* buffer, size_t len) 
    {
        std::cout << "Receiving up to " << len << " bytes" << std::endl;
        return len;
    }
    
    void old_disconnect(int handle) 
    {
        std::cout << "Disconnecting" << std::endl;
    }
};

// 对象适配器：适配旧版网络接口
class LegacyAdapter : public NetworkInterface 
{
private:
    LegacyNetwork legacy;
    int handle;
    bool connected;

public:
    LegacyAdapter() : handle(-1), connected(false) {}
    
    ~LegacyAdapter() 
    {
        if (connected) disconnect();
    }
    
    bool connect(const std::string& host, int port) override 
    {
        handle = legacy.old_connect(host.c_str(), port);
        connected = (handle != -1);
        return connected;
    }
    
    int send(const char* data, int size) override 
    {
        if (!connected) return -1;
        return legacy.old_send(handle, data, size);
    }
    
    int receive(char* buffer, int size) override 
    {
        if (!connected) return -1;
        return legacy.old_receive(handle, buffer, size);
    }
    
    void disconnect() override 
    {
        if (connected) 
        {
            legacy.old_disconnect(handle);
            connected = false;
        }
    }
};

// 客户端代码
int main() 
{
    std::unique_ptr<NetworkInterface> adapter(new LegacyAdapter());
    if (adapter->connect("example.com", 80)) 
    {
        char buffer[1024];
        adapter->send("GET / HTTP/1.1\r\n\r\n", 23);
        int bytes = adapter->receive(buffer, 1024);
        std::cout << "Received " << bytes << " bytes" << std::endl;
    }
    return 0;
}

十、C++ 实现注意事项

1. 虚析构函数：确保抽象类（如Target）有虚析构函数，避免内存泄漏。
2. 引用 vs 指针：适配器中存储适配者对象时，可使用引用或智能指针。
3. 异常安全：适配器应处理适配者可能抛出的异常，保持接口一致性。
4. 性能优化：避免在适配器中进行不必要的数据拷贝，尤其是大数据场景。

适配器模式是 C++ 中解决接口不兼容问题的核心工具，通过合理设计适配器层，可以在不修改现有代码的前提下实现系统集成，这在大型项目和框架设计中具有重要价值。

---

如果这篇文章对你有所帮助，渴望获得你的一个点赞！