一 适配器模式

运行结果；

类图；

文件；

代码；

#include "Adaptee.h"
#include <stdio.h>

Adaptee::Adaptee()
{
}

Adaptee::~Adaptee()
{

}

void Adaptee::specificRequest()
{
    fprintf(stderr, "this is specificRequest\n");
}

#include "Adapter.h"

Target::Target()
{

}

Target::~Target()
{

}

Adapter::Adapter():
    adaptee(new Adaptee())
{

}
 
Adapter::~Adapter()
{

}

void Adapter::request()
{
    adaptee->specificRequest();
}

#include "Adapter.h"
 
int main()
{
   Target* tar = new Adapter();
   tar->request();
   return 0;
}

#ifndef _ADAPTEE_H_
#define _ADAPTEE_H_

class Adaptee
{
public:
    Adaptee();
    ~Adaptee();

    void specificRequest();

};

#endif

 #ifndef _ADAPTER_H_
 #define _ADAPTER_H_
 
 #include "Adaptee.h"
  
 class Target
 {
 public:
    Target();
    virtual ~Target();

    virtual void request() = 0;
};


class Adapter: public Target
{
public:
    Adapter();
    ~Adapter();

    void request();


private:
    Adaptee* adaptee;
};

#endif

二 桥接模式

#include "Abstraction.h"

Abstraction::Abstraction()
{
}

Abstraction::~Abstraction()
{

}

DefinedAbstraction::DefinedAbstraction(AbstractionImplement* absImp)
{
    this->absImp = absImp;
}

DefinedAbstraction::~DefinedAbstraction()
{
}

void DefinedAbstraction::operation()
{
    absImp->operation();
}

#include "AbstractionImplement.h"
#include <stdio.h>

AbstractionImplement::AbstractionImplement()
{

}

AbstractionImplement::~AbstractionImplement()
{

}

ConcreteAbstractionImplement1::ConcreteAbstractionImplement1()
{

}

ConcreteAbstractionImplement1::~ConcreteAbstractionImplement1()
{

}

void ConcreteAbstractionImplement1::operation()
{
    fprintf(stderr, "ConcreteAbstractionImplement1\n" );
}

ConcreteAbstractionImplement2::ConcreteAbstractionImplement2()
{

}

ConcreteAbstractionImplement2::~ConcreteAbstractionImplement2()
{

}

void ConcreteAbstractionImplement2::operation()
{
    fprintf(stderr, "ConcreteAbstractionImplement2\n" );
}

#include "Abstraction.h"

int main()
{
    AbstractionImplement* absImp1 = new ConcreteAbstractionImplement1();
    Abstraction* abs1 = new DefinedAbstraction(absImp1);

    abs1->operation();

    AbstractionImplement* absImp2 = new ConcreteAbstractionImplement2();
    Abstraction* abs2 = new DefinedAbstraction(absImp2);

    abs2->operation();    
    return 0;
}

#ifndef _ABSTRACTION_H_
#define _ABSTRACTION_H_

#include "AbstractionImplement.h"

class Abstraction
{
public:
    Abstraction();
    virtual ~Abstraction();

    virtual void operation() = 0;

};

class DefinedAbstraction: public Abstraction
{
public:
    DefinedAbstraction(AbstractionImplement* absImp);
    ~DefinedAbstraction();

    void operation();

private:
    AbstractionImplement* absImp;
};

#endif

#ifndef _ABSTRACTIONIMPLEMENT_H_
#define _ABSTRACTIONIMPLEMENT_H_

class AbstractionImplement
{
public:
    AbstractionImplement();
    virtual ~AbstractionImplement();

    virtual void operation() = 0;
};

class ConcreteAbstractionImplement1:public AbstractionImplement
{
public:
    ConcreteAbstractionImplement1();
    ~ConcreteAbstractionImplement1();

    void operation();
};

class ConcreteAbstractionImplement2:public AbstractionImplement
{
public:
    ConcreteAbstractionImplement2();
    ~ConcreteAbstractionImplement2();

    void operation();
};

#endif