1 #ifndef _ABSTRACTION_H_
 2 #define _ABSTRACTION_H_
 3
 4 class AbstractionImplement;
 5
 6 class Abstraction
 7 {
 8 public:
 9     virtual void Operation()=0;//定义接口，表示该类所支持的操作
10     virtual ~Abstraction();
11 protected:
12     Abstraction();
13 };
14
15 class RefinedAbstractionA:public Abstraction
16 {
17 public:
18     RefinedAbstractionA(AbstractionImplement* imp);//构造函数
19     virtual void Operation();//实现接口
20     virtual ~RefinedAbstractionA();//析构函数
21 private:
22     AbstractionImplement* _imp;//私有成员
23 };
24
25 class RefinedAbstractionB:public Abstraction
26 {
27 public:
28     RefinedAbstractionB(AbstractionImplement* imp);//构造函数
29     virtual void Operation();//实现接口
30     virtual ~RefinedAbstractionB();//析构函数
31 private:
32     AbstractionImplement* _imp;//私有成员
33 };
34 #endif

 1 #include "Abstraction.h"
 2 #include "AbstractionImplement.h"
 3 #include <iostream>
 4
 5 using namespace std;
 6
 7 Abstraction::Abstraction()
 8 {}
 9
10 Abstraction::~Abstraction()
11 {}
12
13 RefinedAbstractionA::RefinedAbstractionA(AbstractionImplement* imp)
14 {
15     this->_imp = imp;
16 }
17
18 RefinedAbstractionA::~RefinedAbstractionA()
19 {
20     delete this->_imp;
21     this->_imp = NULL;
22 }
23
24 void RefinedAbstractionA::Operation()
25 {
26     cout << "RefinedAbstractionA::Operation" << endl;
27     this->_imp->Operation();
28 }
29
30 RefinedAbstractionB::RefinedAbstractionB(AbstractionImplement* imp)
31 {
32     this->_imp = imp;
33 }
34
35 RefinedAbstractionB::~RefinedAbstractionB()
36 {
37     delete this->_imp;
38     this->_imp = NULL;
39 }
40
41 void RefinedAbstractionB::Operation()
42 {
43     cout << "RefinedAbstractionB::Operation" << endl;
44     this->_imp->Operation();
45 }

 1 #ifndef _ABSTRACTIONIMPLEMENT_H_
 2 #define _ABSTRACTIONIMPLEMENT_H_
 3
 4 //抽象基类，定义了实现的接口
 5 class AbstractionImplement
 6 {
 7 public:
 8     virtual void Operation()=0;//定义操作接口
 9     virtual ~AbstractionImplement();
10 protected:
11     AbstractionImplement();
12 };
13
14 // 继承自AbstractionImplement,是AbstractionImplement的不同实现之一
15 class ConcreteAbstractionImplementA:public AbstractionImplement
16 {
17 public:
18     ConcreteAbstractionImplementA();
19     void Operation();//实现操作
20     ~ConcreteAbstractionImplementA();
21 protected:
22 };
23
24 // 继承自AbstractionImplement,是AbstractionImplement的不同实现之一
25 class ConcreteAbstractionImplementB:public AbstractionImplement
26 {
27 public:
28     ConcreteAbstractionImplementB();
29     void Operation();//实现操作
30     ~ConcreteAbstractionImplementB();
31 protected:
32 };
33 #endif

 1 #include "AbstractionImplement.h"
 2 #include <iostream>
 3
 4 using namespace std;
 5
 6 AbstractionImplement::AbstractionImplement()
 7 {}
 8
 9 AbstractionImplement::~AbstractionImplement()
10 {}
11
12 ConcreteAbstractionImplementA::ConcreteAbstractionImplementA()
13 {}
14
15 ConcreteAbstractionImplementA::~ConcreteAbstractionImplementA()
16 {}
17
18 void ConcreteAbstractionImplementA::Operation()
19 {
20     cout << "ConcreteAbstractionImplementA Operation" << endl;
21 }
22
23 ConcreteAbstractionImplementB::ConcreteAbstractionImplementB()
24 {}
25
26 ConcreteAbstractionImplementB::~ConcreteAbstractionImplementB()
27 {}
28
29 void ConcreteAbstractionImplementB::Operation()
30 {
31     cout << "ConcreteAbstractionImplementB Operation" << endl;
32 }

 1 #include "Abstraction.h"
 2 #include "AbstractionImplement.h"
 3 #include <iostream>
 4
 5 using namespace std;
 6
 7 int main()
 8 {
 9     /* 将抽象部分与它的实现部分分离，使得它们可以独立地变化
10
11     1、抽象Abstraction与实现AbstractionImplement分离;
12
13     2、抽象部分Abstraction可以变化，如new RefinedAbstractionA(imp)、new RefinedAbstractionB(imp2);
14
15     3、实现部分AbstractionImplement也可以变化，如new ConcreteAbstractionImplementA()、new ConcreteAbstractionImplementB();
16
17     */
18
19     AbstractionImplement* imp = new ConcreteAbstractionImplementA();        //实现部分ConcreteAbstractionImplementA
20     Abstraction* abs = new RefinedAbstractionA(imp);                        //抽象部分RefinedAbstractionA
21     abs->Operation();
22
23     cout << "-----------------------------------------" << endl;
24
25     AbstractionImplement* imp1 = new ConcreteAbstractionImplementB();        //实现部分ConcreteAbstractionImplementB
26     Abstraction* abs1 = new RefinedAbstractionA(imp1);                        //抽象部分RefinedAbstractionA
27     abs1->Operation();
28
29     cout << "-----------------------------------------" << endl;
30
31     AbstractionImplement* imp2 = new ConcreteAbstractionImplementA();        //实现部分ConcreteAbstractionImplementA
32     Abstraction* abs2 = new RefinedAbstractionB(imp2);                        //抽象部分RefinedAbstractionB
33     abs2->Operation();
34
35     cout << "-----------------------------------------" << endl;
36
37     AbstractionImplement* imp3 = new ConcreteAbstractionImplementB();        //实现部分ConcreteAbstractionImplementB
38     Abstraction* abs3 = new RefinedAbstractionB(imp3);                        //抽象部分RefinedAbstractionB
39     abs3->Operation();
40
41     cout << endl;
42     return 0;
43 }