Bridge 模式

 1 ///////////////Abstraction.h/////////////
 2 #pragma once
 3 class AbstractionImp ;
 4 class Abstraction
 5 {
 6 public:
 7     virtual ~Abstraction();
 8     virtual void Operation() = 0 ;
 9 protected:
10     Abstraction();
11 private:
12 };
13 
14 class RefinedAbstraction : public Abstraction
15 {
16 public:
17     ~RefinedAbstraction();
18     RefinedAbstraction();
19     RefinedAbstraction(AbstractionImp* imp);
20     void Operation();
21 protected:
22 private:
23     AbstractionImp* _imp ;
24 };

///////////////Abstraction.cpp/////////////
#include "Abstraction.h"
#include "AbstractionImp.h"
Abstraction::~Abstraction()
{

}
Abstraction::Abstraction()
{

}
void Abstraction::Operation()
{

}

RefinedAbstraction::~RefinedAbstraction()
{

}
RefinedAbstraction::RefinedAbstraction()
{

}
RefinedAbstraction::RefinedAbstraction(AbstractionImp* imp)
{
    _imp = imp ;
}
void RefinedAbstraction::Operation()
{
    _imp->Operation();
}

 1 ///////////////AbstractionImp.h/////////////
 2 #pragma once
 3 class AbstractionImp
 4 {
 5 public:
 6     virtual ~AbstractionImp();
 7     virtual void Operation() = 0;
 8 
 9 protected:
10     AbstractionImp();
11 private:
12 };
13 
14 class ConcreteAbstractionImpA : public AbstractionImp
15 {
16 public:
17     ~ConcreteAbstractionImpA();
18     ConcreteAbstractionImpA();
19     void Operation();
20 protected:
21 private:
22 };
23 
24 class ConcreteAbstractionImpB : public AbstractionImp
25 {
26 public:
27     ~ConcreteAbstractionImpB();
28     ConcreteAbstractionImpB();
29     void Operation();
30 protected:
31 private:
32 };

 1 ///////////////AbstractionImp.cpp/////////////
 2 #include "AbstractionImp.h"
 3 #include <iostream>
 4 using namespace std;
 5 AbstractionImp::~AbstractionImp()
 6 {
 7 
 8 }
 9 AbstractionImp::AbstractionImp()
10 {
11 
12 }
13 void AbstractionImp::Operation()
14 {
15 
16 }
17 ConcreteAbstractionImpA::~ConcreteAbstractionImpA()
18 {
19 
20 }
21 ConcreteAbstractionImpA::ConcreteAbstractionImpA()
22 {
23 
24 }
25 void ConcreteAbstractionImpA::Operation()
26 {
27     cout<<"ConcreteAbstractionImpA...."<<endl; 
28 }
29 
30 
31 ConcreteAbstractionImpB::~ConcreteAbstractionImpB()
32 {
33 
34 }
35 ConcreteAbstractionImpB::ConcreteAbstractionImpB()
36 {
37 
38 }
39 void ConcreteAbstractionImpB::Operation()
40 {
41     cout<<"ConcreteAbstractionImpB...."<<endl; 
42 }

 1 ///////////////main.cpp/////////////
 2 #include "Abstraction.h"
 3 #include "AbstractionImp.h"
 4 #include <iostream>
 5 using namespace std ;
 6 int main()
 7 {
 8     AbstractionImp* impA = new ConcreteAbstractionImpA();
 9     Abstraction* abs = new RefinedAbstraction(impA);
10     abs->Operation();
11     system("pause");
12     return 0;
13 }