设计模式-适配器模式

1 适配器模式

• 在软件系统中，由于应用环境的变化，常常需要将“一些现存的对象”放在新的环境中应用，但是新环境要求的接口是这些现存对象所不满足的。
• 将一个类的接口转换成客户希望的另一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作

2 适配器v1

适配器模式

// 目标接口（新接口）
class ITarget{
public:
    virtual void process() = 0;
};

// 遗留接口（老接口）
class IAdaptee{
public:
    virtual void foo(int data) = 0;
    virtual int bar() = 0;
};

// 遗留类型
class OldClass: public IAdaptee{
public:
    virtual void foo(int data){
        // ...
    }
    virtual int bar(){
        // ...
    }
};

// 对象适配器（推荐）
class Adapter: public ITarget{ // 继承
protected:
    IAdaptee* pAdaptee; // 组合（多态）
    
public:
    Adapter(IAdaptee* pAdaptee){
        this->pAdaptee=pAdaptee;
    }
    
    virtual void process(){
        int data=pAdaptee->bar();
        pAdaptee->foo(data);
    }
};

// 类适配器（十分不推荐）
class Adapter: public ITarget, protected OldClass{ // 多继承（无复用性，绑死OldClass）
    // ...
}

int main(){
    IAdaptee* pAdaptee = new OldClass(); // 老接口
    ITarget* pTarget = new Adapter(pAdaptee);
    pTarget->process();
}

class stack{ // STL中stack包含deque，看作是种适配器
    deqeue container;
    // ...
};

class queue{ // STL中queue包含deque，看作是种适配器
    deqeue container;
    // ...
};

3 适配器v2（可执行）

对象适配器（继承新+组合旧）

// The Target defines the domain-specific interface used by the client code.
class Target {
public:
    virtual ~Target() = default;

    virtual std::string Request() const {
        return "Target: The default target's behavior.";
    }
};

/**
 * The Adaptee contains some useful behavior, but its interface is incompatible
 * with the existing client code. The Adaptee needs some adaptation before the
 * client code can use it.
 */
class Adaptee {
public:
    std::string SpecificRequest() const {
        return ".eetpadA eht fo roivaheb laicepS";
    }
};

/**
 * The Adapter makes the Adaptee's interface compatible with the Target's
 * interface.
 */
class Adapter : public Target {
private:
    Adaptee *adaptee_;

public:
    Adapter(Adaptee *adaptee) : adaptee_(adaptee) {}
    std::string Request() const override {
        std::string to_reverse = this->adaptee_->SpecificRequest();
        std::reverse(to_reverse.begin(), to_reverse.end());
        return "Adapter: (TRANSLATED) " + to_reverse;
    }
};


// The client code supports all classes that follow the Target interface.
void ClientCode(const Target *target) {
    std::cout << target->Request();
}

int main() {
    std::cout << "Client: I can work just fine with the Target objects:\n";
    Target *target = new Target;
    ClientCode(target);
    std::cout << "\n\n";
    Adaptee *adaptee = new Adaptee;
    std::cout << "Client: The Adaptee class has a weird interface. See, I don't understand it:\n";
    std::cout << "Adaptee: " << adaptee->SpecificRequest();
    std::cout << "\n\n";
    std::cout << "Client: But I can work with it via the Adapter:\n";
    Adapter *adapter = new Adapter(adaptee);
    ClientCode(adapter);
    std::cout << "\n";
    delete target;
    delete adaptee;
    delete adapter;
    return 0;
}

4 总结

• Adapter模式主要应用于“希望复用一些现存的类，但是接口又与复用坏境要求不一致的情况"，在遗留代码复用、类库迁移等方面非常有用。
• GoF-23定义了两种Adapter模式的实现结构∶对象适配器和类适配器。但类适配器采用“多继承"的实现方式，一般不推荐使用。对象适配器采用“对象组合”的方式，更符合松耦合精神。
• Adapter模式可以实现的非常寻活，不必拘泥于GoF-23中定义的两种结构。例如，完全可以将Adapter模式中的“现存对象”作为新的接口方法参数，来达到适配的目的

5 参考

• 《设计模式》 GoF
• 李建忠设计模式
• C++ 23种设计模式
• 设计模式