虚对象的拷贝

/******************************************************************** 
 file name : Factory.h 
 author  :   Clark/陈泽丹 
 created :   2012-5-8
 *********************************************************************/ 

#pragma 
#include <map>
#include <algorithm>

using namespace std;

//映射工厂
template
<
	typename _IdType,
	class _Fn
>
class Factory
{
public:
	bool Register(const _IdType& _ID, const _Fn& _Func)
	{
		return m_FunMap.insert(IdToFunMap::value_type(_ID, _Func)).second;
	}

	bool Unregister(const _IdType& _ID)
	{
		return m_FunMap.erase(_ID) == 1;
	}

protected:
	Factory(){}
	typedef map<_IdType, _Fn> IdToFunMap;
	IdToFunMap m_FunMap;

};


//工厂错误处理-----------------------------------------------------------
template<typename _IdType, typename _ResultType>
class FactoryError
{
protected:
	_ResultType OnUnknownType(const _IdType& _ID)
	{
		cout<<"Unknow object type pass to factory!"<<endl;
		return 0;
	}
};




//建造者工厂-----------------------------------------------------------
//辅助函数
template<class _ResultType>
class BaseCreater
{
public:
	typedef _ResultType result_type;
	virtual result_type operator()() = 0;
	virtual BaseCreater<_ResultType>* clone() = 0; //{ return new BaseCreater<_ResultType>(*this);}
};
template< class _Creater = BaseCreater<int> >
class createfun
{
public:
	typedef typename _Creater::result_type result_type;
	createfun(_Creater* _pCreater):m_pCreater(NULL)
	{ 
		m_pCreater = _pCreater->clone(); 
	}
	createfun(const createfun& _other)
	{
		m_pCreater = _other.m_pCreater->clone();
	}
	~createfun(){ if(NULL != m_pCreater) delete m_pCreater; m_pCreater = NULL; }
	virtual result_type operator()(){ return (*m_pCreater)(); }
private:
	_Creater* m_pCreater;
};
template
<
	typename _IdType,
	class _Creater,
	template<typename, typename> class _FactoryErrorPolicy = FactoryError
>
class CreaterFactory: public Factory<_IdType, createfun<_Creater> >, _FactoryErrorPolicy<_IdType, typename createfun<_Creater> ::result_type>
{
public:
	typename createfun<_Creater> ::result_type CreateObject(const _IdType& _ID)
	{
		typename IdToFunMap::iterator it = m_FunMap.find(_ID);
		if( m_FunMap.end() != it)
		{
			return (it->second)();
		}
		return OnUnknownType(_ID);
	}
};

 

#include <vld.h> 
#include <iostream>  
#include "Factory.h"


using namespace std; 


class A: public BaseCreater<int>
{
public:
	virtual result_type operator()(){ return 5;}
	virtual BaseCreater<int>* clone(){ return new A(*this);}
};


class B: public BaseCreater<int>
{
public:
	virtual result_type operator()(){ return 7;}
	virtual BaseCreater<int>* clone(){ return new B(*this);}
};


void main()
{
	CreaterFactory<int, BaseCreater<int> > createrFactory;
	createrFactory.Register(1,createfun< BaseCreater<int> >(&B()));
	cout<<createrFactory.CreateObject(1)<<endl;
	system("pause");
}