C++------单例模式，模版模式，原型模式，策略模式和适配器模式

1.单例模式

　　单例模式是一种常用的软件模式。在它的核心结构中只有一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类只有一个实例。
　　Ps:
　　1）单例类只能有一个实例。
　　2）单例类必须自己创建自己的唯一实例。
　　3）单例类必须给所有其他对象提供这一实例。
　　4）单例类的构造方法是私有的

　　代码如下： 

 1             #include <iostream>
 2             using namespace std;
 3             class Single
 4             {
 5             public:
 6                 static Single* CreateSingle()
 7                 {
 8                 if(ss == NULL)
 9                 {
10                     ss = new Single();
11                 }
12                 return ss;
13                 }
14             private:
15                 static Single* ss;
16                 Single()
17                 {
18                 cout << "Single()" << endl;
19                 }
20             };
21             Single* Single::ss = NULL;
22             int main()
23             {
24                 Single* ss = Single::CreateSingle();
25             }

2.模版模式

　　模版模式是一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

　　例如：
　　　　我门填写简历，每个人简历不同，但填写顺序一致　　

　　代码如下：

            #include <iostream>
            using namespace std;
            class Info
            {
            public:
                void TemplateMethod()
                {
                first();
                second();
                third();
                }
            private:
                virtual void first() = 0;
                virtual void second() = 0;    
                virtual void third() = 0;
            };

            class Info1:public Info
            {
            public:
            private:
                void first()
                {
                cout << "first" << endl;
                }
                void second()
                {
                cout << "second" << endl;
                }
                void third()
                {
                cout << "third" << endl;
                }
            };

            int main()
            {
                Info1 man;
                man.TemplateMethod();
            }

3.原型模式

　　　　是指指定创建对象的类型，并且通过拷贝这些原型创建新的对象。通过拷贝构造函数实现。

　　例如：

　　　　修改简历，只需要修改一份，然后通过打印机设备复印多份即可

　　代码如下：

 1             #include <iostream>
 2             using namespace std;
 3             class Resume
 4             {
 5             public:
 6                 Resume(){}
 7                 virtual ~Resume(){}
 8                 virtual Resume* Clone() = 0;
 9             };
10             class ResumeA:public Resume
11             {
12             public:
13                 ResumeA(){}
14                 ResumeA(ResumeA& rr)
15                 {
16                 cout << "Copy ResumeA(ResumeA&)" << endl;
17                 }
18                 Resume* Clone()
19                 {
20                 return new ResumeA(*this);
21                 }
22                 ~ResumeA(){}
23             };
24 
25             int main()
26             {
27                 ResumeA aa;
28                 Resume* a = aa.Clone();
29             }

4.策略模式

　　　　策略模式是指定义一系列的算法进行分别封装，它们可以相互替换。本模式可以使算法独立于使用它的客户而变化。对外的接口是一样的，完成的功能是一样的,只是各自实现的上有差异。

　　例如：

　　　　Cache的替换算法；cache高速缓冲存储器一种特殊的存储器子系统,其中复制了频繁使用的数据以利于快速访问。

　　代码如下：

 1             #include <iostream>
 2             using namespace std;
 3             class ReplaceAlgorithm
 4             {
 5             public:
 6                 virtual void Replace() = 0;
 7             };
 8             class FIFO_ReplaceAlgorithm:public ReplaceAlgorithm
 9             {
10             public:
11                 void Replace()
12                 {
13                 cout << "FIFO_ReplaceAlgorithm" << endl;
14                 }
15             };
16             class LRU_ReplaceAlgorithm:public ReplaceAlgorithm
17             {
18             public:
19                 void Replace()
20                 {
21                     cout << "LRU_ReplaceAlgorithm" << endl;
22                 }
23             };
24 
25             class Random_ReplaceAlgorithm:public ReplaceAlgorithm
26             {
27             public:
28                 void Replace()
29                 {
30                     cout << "Random_ReplaceAlgorithm" << endl;
31                 }
32             };

Cache有三种方法使用第一种通过构造函数参数获取算法类对象

 1             class Cache
 2             {
 3             public:
 4                 Cache(ReplaceAlgorithm* ra)
 5                 {
 6                 mm = ra;
 7                 }
 8                 ~Cache(){delete mm;}
 9                 void Replace(){ mm->Replace();}
10             private:
11                 ReplaceAlgorithm* mm;
12             };
13 
14             int main()
15             {
16                 Cache mm(new Random_ReplaceAlgorithm());
17                 mm.Replace();
18             }

第二种，通过算法名的标签创建算法类对象

 1             enum RA {LRU,FIFO,RANDOM};
 2             class Cache
 3             {
 4             public:
 5                 Cache(enum RA ss)
 6                 {
 7                     if(ss == LRU)
 8                     mm = new LRU_ReplaceAlgorithm();
 9                 else if(ss == FIFO)
10                     mm = new FIFO_ReplaceAlgorithm();
11                 else
12                     mm = new Random_ReplaceAlgorithm();
13                 }
14                 ~Cache(){delete mm;}
15                 void Replace(){ mm->Replace();}
16             private:
17                 ReplaceAlgorithm* mm;
18             };
19             int main()
20             {
21                 Cache mm(LRU);
22                 mm.Replace();
23             }

第三种类模板实现

 1             template <typename RA>
 2             class Cache
 3             {
 4             public:
 5                 Cache(){}
 6                 ~Cache(){}
 7                 void Replace(){ mm.Replace();}
 8             private:
 9                 RA mm;
10             };
11             int main()
12             {
13                 Cache<FIFO_ReplaceAlgorithm> mm;
14                 mm.Replace();
15             }

5.适配器模式

　　　　是指将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能在一起工作的哪些类可以一起工作

　　例如：

　　　　读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。

　　　　有一个类需要实现数据插入和删除，现在有一个数组类里面有插入和删除的方法，通过适配器实现调用数组类的方法。

　　代码如下：

  1             #include <iostream>
  2             using namespace std;
  3             class Sequence
  4             {
  5             public:
  6                 Sequence(){};
  7                 virtual void push(int num) = 0;
  8                 virtual void pop() = 0;
  9             };
 10 
 11             /*
 12              * 默认数组大小是10；
 13              * 插入，如果数组已满，重新申请size+10的空间
 14              * 删除，如果数组为空，删除返回-1；
 15              *               不为空，返回当前删除的值；
 16              * 获取指定位置的数值，如果指定位置超出当前的数据长度，返回-1，并显示数据长度
 17              *                                 在当前的数据长度，返回指定位置的数值
 18              * 设置指定位置的数值，如果指定位置超出当前空间的大小，显示空间大小
 19              *                                 
 20              */ 
 21             class Array
 22             {
 23             public:
 24                 Array()
 25                 {
 26                 size = 10;
 27                 len = 0;
 28                     p = new int[size];
 29                 *p = 0;
 30                 }
 31                 Array(int len)
 32                 {
 33                 
 34                 p = new int[len];
 35                 this->len = 0;
 36                 this->size = len;
 37                 }
 38                 Array(int len, int data)
 39                 {
 40                 this->size = len;
 41                 this->len = len-1;
 42                 p = new int[size];
 43                 for(int i=0; i<size; i++)
 44                 {
 45                     *(p+i) = data;
 46                 }
 47                 //cout << "Arrat(int,int)" << endl;
 48                 }
 49                 int get(int index)
 50                 {
 51                 if(index > len)
 52                 {
 53                         cout << "超出范围" << endl;
 54                     cout << "当前最后数据长度:"<<len;
 55                     return -1;
 56                 }
 57                 return p[index];
 58                 }
 59                 void set(int index, int data)
 60                 {
 61                 if(index > size)
 62                 {
 63                     cout << "超出范围" << endl; 
 64                     cout << "当前空间大小为：" << size << endl;
 65                     return;
 66                 }   
 67                 p[index] = data;
 68                 }
 69                 void push_back(int data)
 70                 {
 71                 if(isFull() == true)
 72                 {
 73                    //空间已满,重新申请内存(为避免多次申请内存，每次申请size+10的空间)，释放原来内存
 74                    getNewKongjian();
 75                 }
 76                 len += 1;
 77                 p[len] = data;
 78                 cout << "push_back()" << endl;
 79                 }
 80                 void push_front(int data)
 81                 {
 82                 if(isFull() == true)
 83                 {
 84                     getNewKongjian();
 85                 }
 86                 for(int i = len;i >= 0; i--)
 87                 {
 88                     p[i+1] = p[i];
 89                 }
 90                 len += 1;
 91                 p[0] = data;
 92                 cout << "push_fron" << endl;
 93                 }
 94                 int pop_back()
 95                 {
 96                 if(isEmpty() == true)
 97                 {
 98                     cout << "没有数据可以删除，当墙空间为空" << endl;
 99                     cout << "当前空间大小是：" << this->size << endl;
100                     return -1;
101                 }
102                 int temp = p[len];
103                 len -= 1;
104 
105                 cout << "pop_back()" << endl;
106                 return temp;
107                 }
108                 int pop_front()
109                 {
110                 if(isEmpty() == true)
111                     {
112                         cout << "没有数据可以删除，当前空间为空" << endl;
113                         cout << "当前空间大小是：" << this->size << endl;
114                         return -1;
115                     }
116                 int temp = p[0];
117                 for(int i = 0; i <= len; i++)
118                 {
119                     p[i] = p[i+1];
120                 }
121                 p[len] = 0;
122                 len -= 1;
123                 cout << "pop_front()" << endl;
124                 return temp;
125                 }
126                 ~Array()
127                 {
128                 delete[] p;
129                 p = NULL;
130                 len = 0;
131                 cout << "~Array" << endl;
132                 }
133                 void Show()
134                 {
135                     for(int i = 0; i < len; i++)
136                     cout << p[i] <<" ";
137                 cout << endl;
138                 }
139 
140             private:
141                 int * p;
142                 int len;
143                 int size;
144                 bool isFull()
145                 {
146                 if(len == size-1)
147                     return true;
148                 else
149                     return false;
150                 }
151                 bool isEmpty()
152                 {
153                 if(len == -1)
154                     return true;
155                 else
156                     return false;
157                 }
158                 void getNewKongjian()
159                 {
160                 
161                 size += 10;
162                     int* temp = new int[size];
163                     //将原来数据拷贝到新内存中
164                     for(int i=0;i<=len;i++)
165                     { 
166                         temp[i] = p[i];
167                     }
168                     delete[] p;
169                     p = temp;
170                 }
171             };
172             class Queue:public Sequence
173             {
174             public:
175                 Queue():a(){}    
176                 Queue(int len):a(len){}
177                 Queue(int len, int data):a(len,data){}
178                 ~Queue()
179                 {
180                 cout << "~Queue" << endl;
181                 }
182                 void push(int num)
183                 {
184                 a.push_back(num);
185                 }
186                 void pop()
187                 {
188                 cout << a.pop_back() << endl;
189                 }
190             private:
191                 Array a;
192             };
193 
194             int main()
195             {
196                 {
197                     Sequence* da = new Queue(2,3);
198                     da->push(1);
199                     da->pop();
200                 da->pop();
201                 da->pop();
202                 da->pop();
203                 delete da;
204                 }
205             }
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/zhangzeze/p/9397979.html