C++如何实现单例模式

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产品；

各司其职，有序完成各自的任务！！