设计模式(bridge和adapter)

关于设计模式部分，代码部分摘抄书上的。编写代码过程中，能更好的理解设计模式所带来的强大之处。
以博文形式记录，方便学习。

适配器模式（Adapter）：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
适配器模式有两种实现方式
类适配器

//Adapter.h
#ifndef _ADAPTER_H_
#define _ADAPTER_H_

class Target
{
    public:
        Target();
        virtual ~Target();
        virtual void Request();
    protected:
    private:
};
class Adaptee
{
    public:
        Adaptee();
        ~Adaptee();
        void SpecificRequest();
    protected:
    private:
};

class Adapter:public Target, private Adaptee
{
    public:
        Adapter();
        ~Adapter();
        void Request();
    protected:
    private:
};
#endif
//Adapter.cpp
#include"Adapter.h"
#include<iostream>
using namespace std;

Target::Target()
{
}
Target::~Target()
{
}
void Target::Request()
{
    cout<<"Target::Request"<<endl;
}
Adaptee::Adaptee()
{
}
Adaptee::~Adaptee()
{
}
void Adaptee::SpecificRequest()
{
    cout<<"Adaptee::SpecificRequest"<<endl;
}
Adapter::Adapter()
{
}
Adapter::~Adapter()
{
}
void Adapter::Request()
{
    this->SpecificRequest();
}
//main.cpp
#include"Adapter.h"
#include<iostream>
using namespace std;

int main(int argc, char *argv[])
{
    Target *adt = new Adapter();
    adt->Request();
    return 0;
}

对象适配器：

//Adapter1.h
#ifndef _ADAPTER1_H_
#define _ADAPTER1_H_

class Target
{
    public:
        Target();
        virtual ~Target();
        virtual void Request();
};
class Adaptee
{
    public:
        Adaptee();
        ~Adaptee();
        void SpecificRequest();
};

class Adapter:public Target
{
    public:
        Adapter(Adaptee *adaptee);
        ~Adapter();
        void Request();
    private:
        Adaptee * _adaptee;
};
#endif
//Adapter1.cpp
#include"Adapter1.h"
#include<iostream>
using namespace std;

Target::Target()
{
}
Target::~Target()
{
}
void Target::Request()
{
    cout<<"Target::Request"<<endl;
}


Adaptee::Adaptee()
{
}
Adaptee::~Adaptee()
{
}
void Adaptee::SpecificRequest()
{
    cout<<"Adaptee::SpecificRequest"<<endl;
}


Adapter::Adapter(Adaptee *  adaptee)
{
    _adaptee = adaptee;
}
Adapter::~Adapter()
{
}
void Adapter::Request()
{
    _adaptee->SpecificRequest();
}
//main.cpp
#include"Adapter1.h"
#include<iostream>
using namespace std;

int main(int argc, char *argv[])
{
    Target *adt = new Adapter(new Adaptee());
    // 需要先创建一个被适配类的对象作为参数
    adt->Request();
    return 0;
}

// ***测试结果与上面的一致。***

bridge模式：
系统被分为两个独立的部分，抽象部分和实现部分。这两个部分可以互相独立的进行修改。
抽象的部分

class AbstractionImp;

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

RefinedAbstraction::RefinedAbstraction(AbstractionImp * imp)
{
    _imp = imp;
}
RefinedAbstraction::~RefinedAbstraction()
{
}
void RefinedAbstraction::Operation()
{
    _imp->Operation();
}
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:
};
AbstractionImp::AbstractionImp()
{
}

AbstractionImp::~AbstractionImp()
{
}

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

ConcreteAbstractionImpA::ConcreteAbstractionImpA()
{
}

ConcreteAbstractionImpA::~ConcreteAbstractionImpA()
{
}

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

ConcreteAbstractionImpB::~ConcreteAbstractionImpB()
{
}

void ConcreteAbstractionImpB::Operation()
{
    cout<<"ConcreteAbstractionImpB..."<<endl;
};
#include<iostream>
using namespace std;

int main(int argc, char *argv[])
{
    AbstractionImp *imp = new ConcreteAbstractionImpA();
    //根据传入的参数来决定调用哪一个具体的实现类
    Abstraction *abs = new RefinedAbstraction(imp);
    abs->Operation();
    return 0;
}