前言

代理和适配器模式（结构型设计模式）的 C++ 代码示例模板。

代码仓库

代理模式（Proxy）

结构

抽象服务类
具体服务类（被代理者）
代理类（代理者）
代理类继承（多态）抽象服务类，和具体服务类有相同的对外方法/接口
代理类 封装/隐藏 具体服务对象，调用代理对象的方法 func()，实际上是 func() 内部调用具体服务对象的方法

核心

封装
继承
多态
使用代理对象，实际上是使用具体服务对象

代码

#include <iostream>

using std::cout;
using std::endl;

// 抽象服务类
class AbstractService
{
public:
    virtual void func() const = 0;
};

// 具体服务类（被代理者）
class ConcreteService : public AbstractService
{
public:
    void func() const override
    {
        cout << "func()" << endl;

        return;
    }
};

// 代理类（代理者）
class Proxy : public AbstractService // 代理类 继承（多态） 抽象服务类，和具体服务类有相同的对外 方法/接口
{

public:
    Proxy() : concrete_service(){}; // 具体服务类的默认构造方法 初始化 具体服务对象

    void func() const override // 代理类 封装/隐藏 具体服务对象，调用代理对象的方法 func()，实际上是 func() 内部调用具体服务对象的方法
    {
        this->concrete_service.func(); // 2. 具体服务对象 调用 方法

        return;
    }

private:
    ConcreteService concrete_service;
};

// 客户端
int main()
{
    Proxy proxy; // 代理类的默认构造方法 初始化 代理对象

    proxy.func(); // 1. 代理对象 调用 方法

    return 0;
}
/*
输出：
func()
*/

适配器模式（Adapter）

类型

类适配器模式：使用多继承机制：适配器继承两个类。只能在支持多继承的编程语言中实现，如 C++
对象适配器模式：使用关联关系：适配器继承一个类，封装另一个类对象。大部分支持面向对象编程范式的编程语言可以实现

类适配器模式

结构

被适配类（客户端期望/可以使用/形式上使用的接口；适配者）
目标类（客户端不兼容/无法使用/实际上使用的接口；被适配者）
适配器类（中间者）
适配器类 多继承 被适配类和目标类
适配器类私有继承（封装）被适配类
适配器类中形式上使用的接口调用实际上使用的接口（适配过程）
客户端可以只知道目标类和适配器类，不知道被适配类

代码

#include <iostream>

using std::cout;
using std::endl;

// 被适配类（客户端 不兼容/无法使用/实际上使用 的接口；被适配者）
class Adaptee
{
public:
    void adaptee_func() const
    {
        cout << "adaptee_func()" << endl;

        return;
    }
};

// 目标类（客户端 期望/可以使用/形式上使用 的 接口；适配者）
class Target
{
public:
    virtual void target_func() const = 0;
};

// 适配器类（中间者）
// 适配器类 多继承 被适配类和目标类;
// 适配器类 私有继承（封装） 被适配类
class Adapter : public Target, private Adaptee
{
public:
    // 适配器类中 形式上使用的接口 调用 实际上使用的接口（适配过程）
    void target_func() const override // 形式上使用的接口
    {
        Adaptee::adaptee_func(); // 实际上使用的接口

        return;
    }
};

// 客户端
int main()
{
    // 客户端 可以只知道 目标类和适配器类，不知道被适配类
    Target *target = new Adapter();
    target->target_func(); // 形式上使用的接口
    delete target;

    return 0;
}
/*
输出：
adaptee_func()
*/

对象适配器模式

结构

被适配类（客户端期望/可以使用/形式上使用的接口；适配者）
目标类（客户端不兼容/无法使用/实际上使用的接口；被适配者）
适配器类（中间者）
适配器类继承目标类
适配器类封装被适配类对象
适配器类中形式上使用的接口调用实际上使用的接口（适配过程）
客户端可以只知道目标类和适配器类，不知道被适配类

代码

#include <iostream>

using std::cout;
using std::endl;

// 被适配类（客户端 期望/可以使用/形式上使用 的 接口；适配者）
class Adaptee
{
public:
    void adaptee_func() const
    {
        cout << "adaptee_func()" << endl;

        return;
    }
};

// 目标类（客户端 期望/可以使用/形式上使用 的 接口；适配者）
class Target
{
public:
    virtual void target_func() const = 0;
};

// 适配器类（中间者）
// 适配器类 继承 目标类
class Adapter : public Target
{
public:
    Adapter() : adaptee() {} // 被适配类的 默认构造方法初始化 被适配类对象

    // 适配器类中 形式上使用的接口 调用 实际上使用的接口（适配过程）
    void target_func() const override // 形式上使用的接口
    {
        adaptee.adaptee_func(); // 实际上使用的接口
    }

private:
    Adaptee adaptee; // 适配器类 封装 被适配类对象
};

// 客户端
int main()
{
    // 客户端 可以只知道 目标类和适配器类，不知道被适配类
    Target *target = new Adapter(); // 适配器类的 默认构造方法初始化 适配器类对象
    target->target_func();          // 形式上使用的接口
    delete target;

    return 0;
}
/*
输出：
adaptee_func()
*/