Bridge Pattern（桥接模式）

/*Abstraction.h*/
#ifndef ABSTRACTION_H
#define ABSTRACTION_H

class AbstractionImp;
class Abstraction
{
public:
    virtual ~Abstraction();
    virtual void Operation()=0;
protected:
    Abstraction();
private:
};

class RefinedAbstraction:public Abstraction
{
public:
    RefinedAbstraction(AbstractionImp *imp);
    ~RefinedAvstraction();
    void Operation();
protected:
private:
    AbstractionImp *imp_;
};
#endif

/*Abstraction.cpp*/
#include "Abstraction.h"
#include "AbstractionImp.h"
#include <iostream>

Abstraction::Abstraction()
{
}

Abstraction::~Abstraction()
{
}

RefinedAbstraction::RefinedAbstraction(AbstractionImp *imp)
{
    imp_=imp;
}

RefinedAbstraction::~RefinedAbstraction()
{
}

void RefinedAbstraction::Operation()
{
    imp_->Operation();
}

/*AbstractionImp.h*/
#ifndef ABSTRACTIONIMP_H
#define ABSTRACTIONIMP_H

class AbstractionImp
{
public:
    virtual ~AbstractionImp();
    virtual void Operation()=0;
protected:
    AbstractionImp();
private:
};

class ConcreteAbstractionImpA:public AbstractionImp
{
public:
    ConcreteAbstractionImpA();
    ~ConcreteAbstractionImpA();
    virtual void Operation();
protected:
private:
};

class ConcreteAbstractionImpB:public AbstractionImp
{
public:
    ConcreteAbstractionImpB();
    ~ConcreteAbstractionImpB();
    virtual void Operation();
protected:
private:
};
#endif

/*AbstractionImp.cpp*/
#include "AbstractionImp.h"

AbstractionImp::AbstractionImp()
{
}

AbstractionImp::~AbstractionImp()
{
}

void AbstractionImp::Operation()
{
    std::cout<<"AbstractionImp..."<<std::endl;
}

ConcreteAbstractionImpA::ConcreteAbstractionImpA()
{
}

ConcreteAbstractionImpA::~ConcreteAbstractionImpA()
{
}

void ConcreteAbstractionImpA::Operation()
{
    std::cout<<"ConcreteAbstractionImpA..."<<std::endl;
}

ConcreteAbstractionImpB::ConcreteAbstractionImpB()
{
}

ConcreteAbstractionImpB::~ConcreteAbstractionImpB()
{
}

void ConcreteAbstractionImpB::Operation()
{
    std::cout<<"ConcreteAbstractionImpB..."<<std::endl;
}

/*main.cpp*/
#include "Abstraction.h"
#include "AbstracionImp.h"

int main()
{
    AbstractionImp *imp=new ConcreteAbstractionImpA();
    Abstraction *abs=new RefinedAbstraction(imp);
    abs->Operation();
    return 0;
}