c++设计模式：适配器模式(Adapter Pattern)

定义：适配器模式将一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。

场景：我们有一只鸭子和一只火鸡，鸭子会嘎嘎叫，而火鸡会咯咯叫，鸭子飞的要远一点，而火鸡只能飞行一小段距离。火鸡和鸭子都会叫，但是他们的叫声不同，接口也不同，飞行的接口相同但是飞行的行为不同。

 

对象适配器：使用对象的组合，以修改的接口包装被适配者。该种做法的优点是被适配者的任何子类都可以搭配着适配器使用。我们分别实现鸭子和火鸡的适配器，鸭子适配器关联了一个鸭子对象，继承自火鸡对象，这样我们可以覆盖火鸡的接口以适应鸭子的行为。同样，火鸡适配器关联了一个火鸡对象，继承自鸭子对象，这样我们就可以覆盖鸭子的接口以适应火鸡的行为。这样我们使用鸭子适配器就可以把我们的鸭子包装称一个火鸡，虽然这个火鸡的叫声和飞行距离跟实际的火鸡不同。

类图：

c++代码如下：

#include <iostream>
using namespace std;

class Duck
{
public:
    virtual void quack() = 0;
    virtual void fly() = 0;
};

class MallardDuck : public Duck
{
public:
    void quack();
    void fly();
};

class Turkey
{
public:
    virtual void gobble() = 0;
    virtual void fly() = 0;
};

class WildTurkey : public Turkey
{
public:
    void gobble();
    void fly();
};

class DuckAdapter : public Turkey
{
public:
    DuckAdapter(Duck* pDuck);
    void gobble();
    void fly();
private:
    Duck* m_pDuck;
};

class TurkeyAdapter : public Duck
{
public:
    TurkeyAdapter(Turkey* pTurkey);
    void quack();
    void fly();
private:
    Turkey* m_pTurkey;
};


void MallardDuck::quack()
{
    printf("Quack\n");
}
void MallardDuck::fly()
{
    printf("I'm flying\n");
}

void WildTurkey::gobble()
{
    printf("Gobble gobble\n");
}
void WildTurkey::fly()
{
    printf("I'm flying a short distance\n");
}

DuckAdapter::DuckAdapter(Duck* pDuck)
{
    m_pDuck = pDuck;
}

void DuckAdapter::gobble()
{
    m_pDuck->quack();
}
void DuckAdapter::fly()
{
    m_pDuck->fly();
}

TurkeyAdapter::TurkeyAdapter(Turkey* pTurkey)
{
    m_pTurkey = pTurkey;
}

void TurkeyAdapter::quack()
{
    m_pTurkey->gobble();
}
void TurkeyAdapter::fly()
{
    m_pTurkey->fly();
}

int main()
{
    MallardDuck mallardDuck;
    WildTurkey wildTurkey;

    DuckAdapter turkey(&mallardDuck);
    TurkeyAdapter duck(&wildTurkey);

    printf("Duck quack :");
    duck.quack();
    printf("Duck fly   :");
    duck.fly();

    printf("Turkey gobble :");
    turkey.gobble();
    printf("Turkey fly    :");
    turkey.fly();

    return 0;
}

 

类适配器：使用多重继承，继承被适配者和目标类，当目标类接收到调用时，实际上操作的是被适配者的方法。该做法的优点是可以覆盖被适配者的行为。

类图：

c++代码如下：

#include <iostream>
using namespace std;

class Duck
{
public:
    virtual void quack() = 0;
    virtual void fly() = 0;
};

class MallardDuck : public Duck
{
public:
    void quack();
    void fly();
};

class Turkey
{
public:
    virtual void gobble() = 0;
    virtual void fly() = 0;
};

class WildTurkey : public Turkey
{
public:
    void gobble();
    void fly();
};

class DuckAdapter : public MallardDuck , public WildTurkey
{
public:
    void gobble();
    void fly();
};

class TurkeyAdapter : public MallardDuck , public WildTurkey
{
public:
    void quack();
    void fly();
};


void MallardDuck::quack()
{
    printf("Quack\n");
}
void MallardDuck::fly()
{
    printf("I'm flying\n");
}

void WildTurkey::gobble()
{
    printf("Gobble gobble\n");
}
void WildTurkey::fly()
{
    printf("I'm flying a short distance\n");
}

void DuckAdapter::gobble()
{
    quack();
}
void DuckAdapter::fly()
{
    MallardDuck::fly();
}

void TurkeyAdapter::quack()
{
    gobble();
}
void TurkeyAdapter::fly()
{
    WildTurkey::fly();
}

int main()
{
    DuckAdapter turkey;
    TurkeyAdapter duck;

    printf("Duck quack :");
    duck.quack();
    printf("Duck fly   :");
    duck.fly();

    printf("Turkey gobble :");
    turkey.gobble();
    printf("Turkey fly    :");
    turkey.fly();

    return 0;
}

注：我们实现鸭子适配和火鸡适配的时候，可以通过覆盖被适配者的方法来修改适配器的行为。

 

运行结果如下：

Duck quack :Gobble gobble
Duck fly :I'm flying a short distance
Turkey gobble :Quack
Turkey fly :I'm flying

 

参考图书：《Head First 设计模式》