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产品;
各司其职,有序完成各自的任务!!