C++有時會用到單例模式，比如和資料庫連線的類，我們只需要一個物件，那麼這時候我們就要限制類物件產生的數量，允許一個類產生一個物件，如何讓一個類產生一個物件呢，也就是實現單例模式？

方法一：將建構函式宣告為私有的，這樣派生類，外部的程式就不能隨意產生物件

程式碼如下：

#include <iostream>
using namespace std;
class Single
{
public:
	static Single * getInstance()
	{
		if(s == NULL)
		{
			s = new Single();
			cout<<"create s success"<<endl;
		}
		return s;
	}
	static void release()
	{
		if(s!=NULL)  //必須有，不然記憶體洩露
		{
			cout<<"delete"<<endl;
			delete s;
			s=NULL;
		}
	}
private:
	Single() {}
	static Single * s;  //必須是靜態的，這樣的話就可以保證只產生一個物件；

};
Single * Single::s = NULL;
int main()
{
	Single * s = Single::getInstance();
	Single * s1 = Single::getInstance();
	s->release();
	s1->release();
	system("pause");
	return 0;

}
 

#include <iostream>
using namespace std;
class Singleton  
{  
public:  
	static Singleton * GetInstance()  
	{  
		if(NULL == m_pInstance)  
			m_pInstance = new Singleton();  
		return m_pInstance;  
	}  
	static void Release()                    //必須，否則會導致記憶體洩露   
	{  
		if(NULL != m_pInstance)  
		{  
			delete m_pInstance;  
			m_pInstance = NULL;  
		}  
	}  

protected:  
	Singleton()  
	{  
		cout<<"C++ Singleton"<<endl;  
	};  
	static Singleton * m_pInstance;  
}; 

Singleton* Singleton::m_pInstance = NULL;  

class SingleDraw:public Singleton  
{  
public:  
	static SingleDraw* GetInstance()  
	{  
		if(NULL == m_pInstance)  
			m_pInstance = new SingleDraw();  
		return (SingleDraw*)m_pInstance;  
	}  
protected:  
	SingleDraw()  
	{  
		cout<<"C++ SingleDraw"<<endl;  
	}  
};  

int main()  
{  
	SingleDraw* s1 = SingleDraw::GetInstance();  
	SingleDraw* s2 = SingleDraw::GetInstance();  
	s2->Release();  
	system("pause");
	return 0;  
}
 

實現程式碼

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

class AbstractPruduct
{
public:
	AbstractPruduct(){} 
	~AbstractPruduct(){}
	virtual void print()=0;

};

class ProductA:public AbstractPruduct
{
public:
	ProductA(){cout<<"ProductA"<<endl;}
	~ProductA(){}
	void print()
	{
		cout<<"I'm ProductA"<<endl;
	}
};

class ProductB:public AbstractPruduct
{
public:
	ProductB(){cout<<"ProductB"<<endl;}
	~ProductB(){}
	void print()
	{
		cout<<"I'm ProductB"<<endl;
	}
};

class AbstractFactory
{
public:
	AbstractFactory(){}
	~AbstractFactory(){}


};

class	FactoryA:public AbstractFactory
{
public:
	FactoryA(){cout<<"FactoryA"<<endl;}
	~FactoryA(){}
	ProductA* createProduct()
	{
		return new ProductA();
	}
};

class FactoryB:public AbstractFactory
{
public:
	FactoryB(){cout<<"FactoryB"<<endl;}
	~FactoryB(){}
	ProductB* createProduct()
	{
		return new ProductB();
	}
};


int main()
{

	FactoryB fa;                            //抽象工廠模式
	AbstractPruduct* ap=fa.createProduct();
	ap->print();
	system("pause");
	return 0;
}
 

不僅抽象了產品，也抽象了工廠，A工廠生產a產品，B 共產生產b產品；

各司其職，有序完成各自的任務！！