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

1.单例模式

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

　　代码如下： 

            #include <iostream>
            using namespace std;
            class Single
            {
            public:
                static Single* CreateSingle()
                {
                if(ss == NULL)
                {
                    ss = new Single();
                }
                return ss;
                }
            private:
                static Single* ss;
                Single()
                {
                cout << "Single()" << endl;
                }
            };
            Single* Single::ss = NULL;
            int main()
            {
                Single* ss = Single::CreateSingle();
            }    

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.原型模式

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

　　例如：

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

　　代码如下：

            #include <iostream>
            using namespace std;
            class Resume
            {
            public:
                Resume(){}
                virtual ~Resume(){}
                virtual Resume* Clone() = 0;
            };
            class ResumeA:public Resume
            {
            public:
                ResumeA(){}
                ResumeA(ResumeA& rr)
                {
                cout << "Copy ResumeA(ResumeA&)" << endl;
                }
                Resume* Clone()
                {
                return new ResumeA(*this);
                }
                ~ResumeA(){}
            };

            int main()
            {
                ResumeA aa;
                Resume* a = aa.Clone();
            }

4.策略模式

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

　　例如：

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

　　代码如下：

            #include <iostream>
            using namespace std;
            class ReplaceAlgorithm
            {
            public:
                virtual void Replace() = 0;
            };
            class FIFO_ReplaceAlgorithm:public ReplaceAlgorithm
            {
            public:
                void Replace()
                {
                cout << "FIFO_ReplaceAlgorithm" << endl;
                }
            };
            class LRU_ReplaceAlgorithm:public ReplaceAlgorithm
            {
            public:
                void Replace()
                {
                    cout << "LRU_ReplaceAlgorithm" << endl;
                }
            };

            class Random_ReplaceAlgorithm:public ReplaceAlgorithm
            {
            public:
                void Replace()
                {
                    cout << "Random_ReplaceAlgorithm" << endl;
                }
            };

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

            class Cache
            {
            public:
                Cache(ReplaceAlgorithm* ra)
                {
                mm = ra;
                }
                ~Cache(){delete mm;}
                void Replace(){ mm->Replace();}
            private:
                ReplaceAlgorithm* mm;
            };

            int main()
            {
                Cache mm(new Random_ReplaceAlgorithm());
                mm.Replace();
            }

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

            enum RA {LRU,FIFO,RANDOM};
            class Cache
            {
            public:
                Cache(enum RA ss)
                {
                    if(ss == LRU)
                    mm = new LRU_ReplaceAlgorithm();
                else if(ss == FIFO)
                    mm = new FIFO_ReplaceAlgorithm();
                else
                    mm = new Random_ReplaceAlgorithm();
                }
                ~Cache(){delete mm;}
                void Replace(){ mm->Replace();}
            private:
                ReplaceAlgorithm* mm;
            };
            int main()
            {
                Cache mm(LRU);
                mm.Replace();
            }

第三种类模板实现

            template <typename RA>
            class Cache
            {
            public:
                Cache(){}
                ~Cache(){}
                void Replace(){ mm.Replace();}
            private:
                RA mm;
            };
            int main()
            {
                Cache<FIFO_ReplaceAlgorithm> mm;
                mm.Replace();
            }

5.适配器模式

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

　　例如：

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

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

　　代码如下：

            #include <iostream>
            using namespace std;
            class Sequence
            {
            public:
                Sequence(){};
                virtual void push(int num) = 0;
                virtual void pop() = 0;
            };

            /*
             * 默认数组大小是10；
             * 插入，如果数组已满，重新申请size+10的空间
             * 删除，如果数组为空，删除返回-1；
             *               不为空，返回当前删除的值；
             * 获取指定位置的数值，如果指定位置超出当前的数据长度，返回-1，并显示数据长度
             *                                 在当前的数据长度，返回指定位置的数值
             * 设置指定位置的数值，如果指定位置超出当前空间的大小，显示空间大小
             *                                 
             */ 
            class Array
            {
            public:
                Array()
                {
                size = 10;
                len = 0;
                    p = new int[size];
                *p = 0;
                }
                Array(int len)
                {
                
                p = new int[len];
                this->len = 0;
                this->size = len;
                }
                Array(int len, int data)
                {
                this->size = len;
                this->len = len-1;
                p = new int[size];
                for(int i=0; i<size; i++)
                {
                    *(p+i) = data;
                }
                //cout << "Arrat(int,int)" << endl;
                }
                int get(int index)
                {
                if(index > len)
                {
                        cout << "超出范围" << endl;
                    cout << "当前最后数据长度:"<<len;
                    return -1;
                }
                return p[index];
                }
                void set(int index, int data)
                {
                if(index > size)
                {
                    cout << "超出范围" << endl; 
                    cout << "当前空间大小为：" << size << endl;
                    return;
                }   
                p[index] = data;
                }
                void push_back(int data)
                {
                if(isFull() == true)
                {
                   //空间已满,重新申请内存(为避免多次申请内存，每次申请size+10的空间)，释放原来内存
                   getNewKongjian();
                }
                len += 1;
                p[len] = data;
                cout << "push_back()" << endl;
                }
                void push_front(int data)
                {
                if(isFull() == true)
                {
                    getNewKongjian();
                }
                for(int i = len;i >= 0; i--)
                {
                    p[i+1] = p[i];
                }
                len += 1;
                p[0] = data;
                cout << "push_fron" << endl;
                }
                int pop_back()
                {
                if(isEmpty() == true)
                {
                    cout << "没有数据可以删除，当墙空间为空" << endl;
                    cout << "当前空间大小是：" << this->size << endl;
                    return -1;
                }
                int temp = p[len];
                len -= 1;

                cout << "pop_back()" << endl;
                return temp;
                }
                int pop_front()
                {
                if(isEmpty() == true)
                    {
                        cout << "没有数据可以删除，当前空间为空" << endl;
                        cout << "当前空间大小是：" << this->size << endl;
                        return -1;
                    }
                int temp = p[0];
                for(int i = 0; i <= len; i++)
                {
                    p[i] = p[i+1];
                }
                p[len] = 0;
                len -= 1;
                cout << "pop_front()" << endl;
                return temp;
                }
                ~Array()
                {
                delete[] p;
                p = NULL;
                len = 0;
                cout << "~Array" << endl;
                }
                void Show()
                {
                    for(int i = 0; i < len; i++)
                    cout << p[i] <<" ";
                cout << endl;
                }

            private:
                int * p;
                int len;
                int size;
                bool isFull()
                {
                if(len == size-1)
                    return true;
                else
                    return false;
                }
                bool isEmpty()
                {
                if(len == -1)
                    return true;
                else
                    return false;
                }
                void getNewKongjian()
                {
                
                size += 10;
                    int* temp = new int[size];
                    //将原来数据拷贝到新内存中
                    for(int i=0;i<=len;i++)
                    { 
                        temp[i] = p[i];
                    }
                    delete[] p;
                    p = temp;
                }
            };
            class Queue:public Sequence
            {
            public:
                Queue():a(){}    
                Queue(int len):a(len){}
                Queue(int len, int data):a(len,data){}
                ~Queue()
                {
                cout << "~Queue" << endl;
                }
                void push(int num)
                {
                a.push_back(num);
                }
                void pop()
                {
                cout << a.pop_back() << endl;
                }
            private:
                Array a;
            };

            int main()
            {
                {
                    Sequence* da = new Queue(2,3);
                    da->push(1);
                    da->pop();
                da->pop();
                da->pop();
                da->pop();
                delete da;
                }
            }