问个设工厂模式的问题

[jbz001]

我做了一个程序，用户到了工厂模式。工厂类是这样做的：

m_mapInst[nSytle1] = new CStyle1;
m_mapInst[nSytle2] = new CStyle2;
m_mapInst[nSytle3] = new CStyle3;
m_mapInst[nSytle4] = new CStyle4;
m_mapInst[nSytle5] = new CStyle5;

需要什么实例，调用工厂类的函数获取。
做完了之后发现，这样每个实例都是单利的。
而我的程序中可能需要将一个类实例化好几个，不能使用单例模式。
不知道我的这个工厂类应该怎么改？

[dickbarry]

呃，我没看出来LZ的代码是怎么用工厂模式的。。。

[jstar920]

如果要不同的实例， 那就应该要用不同的flag
是否应该是这样:

factory(Sytle1,1) = m_mapInst[nSytle11] = new CStyle1;
factory(Sytle1,2) = m_mapInst[nSytle12] = new CStyle1;
factory(Sytle2,1) = m_mapInst[nSytle21] = new CStyle2;
factory(Sytle2,2) = m_mapInst[nSytle22] = new CStyle2;
......

或者可以直接这样：

style1 = factory(Sytle1) = new CStyle1;
style2 = factory(Sytle2) = new CStyle2;

Destroy(style1 );
Destroy(style2 );

[stendson]

工厂模式是将对象的实例化延迟到子类,工厂根据类型创建子类对象 有两种方法 传参和模板
单例模式是一个类有且只有一个实例

#include <iostream>
#include <string>
//抽象基类定义调用接口
class Base                                                                                                                                                                                                                                                                                           
{
public:
	Base(){}
	virtual ~Base(){} //防止内存泄漏 必须为virtual
	virtual void print()=0;
	
};
class Derived_1: public Base
{
public:
	void print()
	{
		std::cout<<"derived_1.print()"<<std::endl;
	}
};
class Derived_2 : public Base
{
public:
	void print()
	{
		std::cout<<"derived_2.print()"<<std::endl;
	}
};

//工厂模式 模板创建法
template < typename T >
class Factory
{
public:
	Factory(){}
	Base* Create()
	{
		m_pBase = new T();
		return m_pBase;
	}
	~Factory()
	{
		delete m_pBase;
	}
private:
	Base* m_pBase;
};
//工厂模式 类型创建
class TypeFactory
{
public:
	TypeFactory(){}
	virtual ~TypeFactory()
	{
		delete m_pBase;
	}
	Base* Create(std::string type)
	{
		if( type == "Derived_1")
		{
			m_pBase = new Derived_1();
		}
		else
		{
			m_pBase = new Derived_2();
		}
		return m_pBase;
	}
private:
	Base* m_pBase;
};
//单例模式
class Singleton
{
public:
	static Singleton* Instance()
	{
		if( m_instance == 0)
		{
			m_instance = new Singleton();
		}
		return m_instance;
	}
	void AddCount()
	{
		std::cout<<"count:"<<count<<std::endl;
		count++;
	}
protected:
	Singleton():count(0){}			//无法通过外部访问 只有Instance接口创建
private:
	static Singleton* m_instance;	//全局唯一
	int count;
};

 Singleton* Singleton::m_instance = 0;

int main()
{
	//模板调用方法
	Factory<Derived_1> fd1;
	Factory<Derived_2> fd2;
	std::cout<<"template method:"<<std::endl;
	fd1.Create()->print();
	fd2.Create()->print();
	//类型参数
	TypeFactory tf;
	std::cout<<"Type method:"<<std::endl;
	tf.Create("Derived_1")->print();
	tf.Create("Derived_2")->print();
	//单例模式
	Singleton *pSingle = Singleton::Instance();
	pSingle->AddCount();
	pSingle->AddCount();
	return 0;
}

[ryfdizuo]

修改一下map，做成型别到创建函数的映射
Style1* CreateStyle1()
{
return new Style1;
}
m_mapInst[nSytle1] = CreateStyle1;

[炜娓道来程序人生]

工厂，单例，什么也看不出来呀，好好学习一下三楼的代码吧。