單例模式是一種常用的軟體設計模式。在它的核心結構中只包含一個被稱為單例的特殊類。通過單例模式可以保證系統中一個類只有一個例項而且該例項易於外界訪問，從而方便對例項個數的控制並節約系統資源。如果希望在系統中某個類的物件只能存在一個，單例模式是最好的解決方案

在單例類的內部實現只生成一個例項，同時它提供一個靜態的getInstance()工廠方法，讓客戶可以訪問它的唯一例項；為了防止在外部對其例項化，將其預設建構函式和拷貝建構函式設計為私有；在單例類內部定義了一個Singleton型別的靜態物件，作為外部共享的唯一例項。

#include<iostream>
#include<string>
using namespace std;


class single
{
        private:
                single(){}; //預設建構函式
                single(const single &p){};//拷貝建構函式
        public:
                static single * getinstance()
                {  return  pointer;}
                void test(string a)
                {   cout<<a<<endl;}
        private:
                static single *pointer;
};
single* single::pointer=new single;
int main()
{
   string b="單例模式";
   single *s1=single::getinstance();//唯一訪問的介面
   s1->test(b);
}
   

首先將 預設建構函式和拷貝建構函式設定為private

這樣設定以後 就無法建立 single s1；single s2;這樣不同的例項，它們建立的時候就需要呼叫預設建構函式 私有後無法訪問

為什麼拷貝建構函式也要私有化？ 如果我在 single* s1=single::getinstance()；下面再建立一個 single*s2= single1::getlinstance();

此時這兩個指標訪問的是同一個物件，但是我再加上一句：single * s3= new single(*s2)；此時會呼叫拷貝建構函式，由於是new

出來的空間，是一個深拷貝，s2和s3 所訪問的地址是不一樣的，為了滿足單例模式的要求，所以拷貝建構函式也要私有化。

下面是程式碼的測試：

#include<iostream>
#include<string>
using namespace std;


class single
{
        private:
                single(){}; //預設建構函式

        public:
                static single * getinstance()
                {  return  pointer;}
                void test(string a)
                {   cout<<a<<endl;}
        private:
                static single *pointer;
};
single* single::pointer=new single;
int main()
{
   string b="單例模式";
   single *s1=single::getinstance();//唯一訪問的介面
   single *s2=single::getinstance();
   single *s3=new single(*s2);
   if(s1==s2){cout<<"s1等於s2"<<endl;}
   if(s2!=s3){cout<<"s2不等於s3"<<endl;}
   s1->test(b);
}

測試的結果

接下來是再內部維護一個指標，這個指標也設定成private 如果再public中 用single*s1 =single::pointer去訪問；那我是不是可以設定single *s1=NULL；為了防止這種情況將維護的指標設定為私有

同時他是一個靜態成員變數，在類的外部進行初始化。

最後在public中 設定一個靜態成員函式提供一個訪問的介面。