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 }