理了一下思路，实现动态识别和创建对象

[liron71]

今天又整理了一下思路，重新简要写了一下实现动态识别的机制

include "targetver.h"

#include <stdio.h>
#include <tchar.h>


// TODO: 在此处引用程序需要的其他头文件

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

#include <functional>
#include <iostream>
#include <unordered_map>

#include <codecvt>

using namespace std;


class CMyObject;
typedef CMyObject * (* FP)();

class B;
class C;
class D;

struct reg_map;
typedef reg_map DynamicManageClass;


struct reg_map
{
	static std::unordered_map<std::wstring , FP> className_To_Construct; 

	reg_map( const std::wstring & classNameStr , const FP & pConstructFunc )
	{
		if (classNameStr.empty())				
			return;	
		
		reg_map::className_To_Construct[classNameStr] = pConstructFunc;
	}

	static CMyObject * ConstructInst(const wchar_t * nameStr)
	{
		if ( nameStr == nullptr )
			return nullptr;

		if ( reg_map::className_To_Construct.count( nameStr ) <= 0 )
		{
			wcout << L"\n" << nameStr << L" is not a class name! Construct Instance is failed!";
			return nullptr;
		}

		FP pf = reg_map::className_To_Construct[nameStr];
		if ( pf == nullptr )
		{
			wcout << L"\nclass " << nameStr << L" does not support dynamic creation (only dynamic identification)! Construct Instance is failed!" ;
			return nullptr;
		}
		
		return (* pf)();	
	}

};
 std::unordered_map<std::wstring , FP> reg_map::className_To_Construct; 	
 
 
template <typename Type>
class dy
{
public:	
//	typedef Type _classType;
	static const reg_map _initMap;
};

template <typename Type>
class dyc
{
public:	
//	typedef Type _classType;
	static CMyObject * ConstructInst(){ return new Type(); }
	static const reg_map _initMap;
};


#define DECLARE_DYNAMIC()\
	virtual bool isKindof(const wchar_t * nameStr);\
	virtual std::wstring getClassName();\
	virtual std::wstring getBaseClassName();\
	virtual std::wstring getRootBasetClassName();


#define IMPLEMENT_DYNAMIC(class_name, baseclass_name)\
	class class_name;\
	template class dy<class_name>;\
	const reg_map dy<class_name>::_initMap(L#class_name , nullptr);\
	bool class_name::isKindof(const wchar_t * nameStr)\
	{\
		if ( nameStr == nullptr )\
			return false;\
		if ( std::wstring(L#class_name).compare( nameStr ) == 0 )\
		{	\
			wcout << L"\nobject is kind of " << L#class_name;\
			return true;\
		}\
		else \
		{\
			return baseclass_name::isKindof( nameStr );\
		}\
	}\
	std::wstring class_name::getClassName(){ return L#class_name; }\
	std::wstring class_name::getBaseClassName(){ return baseclass_name::getClassName(); }\
	std::wstring class_name::getRootBasetClassName(){ return baseclass_name::getRootBasetClassName(); }


#define IMPLEMENE_DYCREATE(class_name, baseclass_name)\
	class class_name;\
	template class dyc<class_name>;\
	const reg_map dyc<class_name>::_initMap(L#class_name , dyc<class_name>::ConstructInst);\
	bool class_name::isKindof(const wchar_t * nameStr)\
	{\
		if ( nameStr == nullptr )\
			return false;\
		if ( std::wstring(L#class_name).compare( nameStr ) == 0 )\
		{	\
			wcout << L"\nobject is kind of " << L#class_name;\
			return true;\
		}\
		else \
		{\
			return baseclass_name::isKindof( nameStr );\
		}\
	}\
	std::wstring class_name::getClassName(){ return L#class_name; }\
	std::wstring class_name::getBaseClassName(){ return baseclass_name::getClassName(); }\
	std::wstring class_name::getRootBasetClassName(){ return baseclass_name::getRootBasetClassName(); }


class CMyObject
{
public:
	virtual ~CMyObject(){ ; }

public:
	virtual bool isKindof(const wchar_t * nameStr) 
	{
		if ( nameStr == nullptr )
		{
			return false;
		}
		
		if ( std::wstring(L"CMyObject").compare( nameStr ) == 0 )
		{
			wcout << L"\nobject is kind of CMyObject.";
			return true;
		}

		wcout << L"\nobject is not kind of " << nameStr;
		return false;
	}
	virtual std::wstring getClassName(){ return L"CMyObject"; }
	//类里没有了static 的construct()函数，放到外部一个模板实例类里了。
	//省字节，被模板实例占字节了，平衡
	virtual std::wstring getBasetClassName(){ return L"\0"; }
	virtual std::wstring getRootBasetClassName(){ return getClassName(); }

	virtual void fun() = 0; //注意派生类内必须定义，才能动态创建对象实例
};
template class dy<CMyObject>;
const reg_map dy<CMyObject>::_initMap(L"CMyObject" , nullptr);

class B : public CMyObject
{
public:
	virtual ~B(){ ; }

public:	

DECLARE_DYNAMIC()
};
IMPLEMENT_DYNAMIC(B, CMyObject)//动态识别


class C :  public B
{
public:
	virtual ~C(){ ; }

public:	
	virtual void fun() { ; }

DECLARE_DYNAMIC()
};
IMPLEMENE_DYCREATE(C, B) //动态创建



class D :  public C
{
public:
	virtual ~D(){ ; }

public:	

DECLARE_DYNAMIC()	
};
IMPLEMENE_DYCREATE(D, C)  //动态创建


int _tmain(int argc, _TCHAR* argv[])
{
	CMyObject * pObj = DynamicManageClass::ConstructInst(L"CMyObject");
	if ( pObj != nullptr )
	{
		pObj->isKindof( L"CMyObject" );
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}
	
	cout << "\n";

	pObj = DynamicManageClass::ConstructInst(L"B");
	if ( pObj != nullptr )
	{
		pObj->isKindof( L"CMyObject" );
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}

	cout << "\n";
		
	pObj = DynamicManageClass::ConstructInst(L"C");
	if ( pObj != nullptr )
	{
		pObj->isKindof( L"CMyObject" );		
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}

	cout << "\n";
		
	pObj = DynamicManageClass::ConstructInst(L"D");
	if ( pObj != nullptr )
	{
		pObj->isKindof( L"CMyObject" );
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}
	
	cout << "\n";

	return 0;
}

[战在春秋]

支持原创，感谢分享！！

[liron71]

今天又把静态类的形式，用模板类的形式重写一遍，实现动态识别、动态创建机制的模板类！ 希望大家都提点建议，完善起来，供大家共享！ 代码分享如下！

#include "stdafx.h"

using std::wcout;

template<typename retType> class reg_Str_Func_Map;
template<typename _classType, typename _rootClassType> struct Dynamic;
template<typename _classType, typename _rootClassType> struct Dycreate;


//
//宏定义时尚未实际实例化，故可以放在前面位置，实例化时，宏里面要用到的类型定义必须可见
//

#define DECLARE_DYNAMIC()\
	public:\
	virtual bool isKindof(const wchar_t * nameStr);\
	virtual const std::wstring & getClassName();\
	virtual const std::wstring & getBaseClassName(std::wstring & str);\
	virtual const std::wstring & getRootBasetClassName(std::wstring & str);\
	public:\
	static const std::wstring s_className;


#define IMPLEMENT_DYNAMIC_ROOTCLASS_TYPE(class_name, baseclass_name, rootclass_name)\
	template struct Dynamic<class_name, rootclass_name>;\
	typedef Dynamic<class_name, rootclass_name> class_name##_##RunTimeX;\
	const std::wstring class_name::s_className(L#class_name);/*必须在前定义,下述初始化用来设置才准确*/\
	const reg_Str_Func_Map<rootclass_name> Dynamic<class_name, rootclass_name>::_initMap(class_name::s_className , nullptr);\
	bool class_name::isKindof(const wchar_t * nameStr)\
	{\
		if ( nameStr == nullptr )\
			return false;\
		if ( std::wstring(this->getClassName()).compare( nameStr ) == 0 )\
		{\
			wcout << L"\nobject is kind of " << this->getClassName();\
			return true;\
		}\
		else\
		{\
			return baseclass_name::isKindof( nameStr );\
		}\
	}\
	const std::wstring & class_name::getClassName(){ return class_name::s_className; }\
	const std::wstring & class_name::getBaseClassName(std::wstring & str){ return str = baseclass_name::getClassName(); }\
	const std::wstring & class_name::getRootBasetClassName(std::wstring & str){ return str = baseclass_name::getRootBasetClassName(str); }


#define IMPLEMENE_DYCREATE_ROOTCLASS_TYPE(class_name, baseclass_name, rootclass_name)\
	template struct Dycreate<class_name, rootclass_name>;\
	typedef Dycreate<class_name, rootclass_name> class_name##_##RunTimeX;\
	const std::wstring class_name::s_className(L#class_name);/*必须在前定义,下述初始化用来设置才准确*/\
	const reg_Str_Func_Map<rootclass_name> Dycreate<class_name, rootclass_name>::_initMap(class_name::s_className , Dycreate<class_name, rootclass_name>::ConstructInst);\
	bool class_name::isKindof(const wchar_t * nameStr)\
	{\
		if ( nameStr == nullptr )\
			return false;\
		if ( std::wstring(this->getClassName()).compare( nameStr ) == 0 )\
		{	\
			wcout << L"\nobject is kind of " << this->getClassName();\
			return true;\
		}\
		else\
		{\
			return baseclass_name::isKindof( nameStr );\
		}\
	}\
	const std::wstring & class_name::getClassName(){ return class_name::s_className; }\
	const std::wstring & class_name::getBaseClassName(std::wstring & str){ return str = baseclass_name::getClassName(); }\
	const std::wstring & class_name::getRootBasetClassName(std::wstring & str){ return str = baseclass_name::getRootBasetClassName(str); }


#define ROOTCLASS_IMPLEMENT(PROJECT_NAME)\
/**/\
	struct PROJECT_NAME{};\
	template class CObject<PROJECT_NAME>;/*基类模板实例化*/\
	const std::wstring CObject<PROJECT_NAME>::s_className( L"CObject<"##L#PROJECT_NAME##L">" );/*实例化的模板内部static变量定义*/\
/**/\
	template class reg_Str_Func_Map<CObject<PROJECT_NAME>>;/*关联类名与构造函数的模板实例化*/\
	typedef reg_Str_Func_Map<CObject<PROJECT_NAME>> CObject_##PROJECT_NAME##_RunTimeX;/*给上述模板的特化实例取个别名*/\
std::unordered_map<std::wstring, CObject_##PROJECT_NAME##_RunTimeX::FP> CObject_##PROJECT_NAME##_RunTimeX::className_To_Construct; /*模板实例化后的内部static变量必须在外部定义*/\
/**/\
	template struct Dynamic<CObject<PROJECT_NAME>, CObject<PROJECT_NAME>>;/*实现基类动态的模板特化*/\
	typedef Dynamic<CObject<PROJECT_NAME>, CObject<PROJECT_NAME>> CObject_##PROJECT_NAME##_Dynamic;/*对基类建立关联的特化实例取个别名*/\
	const CObject_##PROJECT_NAME##_RunTimeX CObject_##PROJECT_NAME##_Dynamic::_initMap(CObject<PROJECT_NAME>::s_className, nullptr);/*对基类建立关联，实现动态识别*/


#define ROOTCLASS(project)  CObject<project>
#define ROOTCLASS_NAME_STR(project)  L"CObject<"##L#project##L">"


template<typename retType>
class reg_Str_Func_Map
{
public:
	typedef retType retClassType;
	typedef retType * (* FP)();

private:
	static std::unordered_map<std::wstring , FP> className_To_Construct; 

public:
	reg_Str_Func_Map( const std::wstring & classNameStr , const FP & pConstructFunc )
	{
		if (classNameStr.empty())				
			return;	
		
		reg_Str_Func_Map::className_To_Construct[classNameStr] = pConstructFunc;
	}

	static retType * ConstructInst(const wchar_t * nameStr)
	{
		if ( nameStr == nullptr )
			return nullptr;

		if ( reg_Str_Func_Map::className_To_Construct.count( nameStr ) <= 0 )
		{
			wcout << L"\n" << nameStr << L" is not a class name! Construct Instance is failed!";
			return nullptr;
		}

		FP pf = reg_Str_Func_Map::className_To_Construct[nameStr];
		if ( pf == nullptr )
		{
			wcout << L"\nclass " << nameStr << L" does not support dynamic creation (only dynamic identification)! Construct Instance is failed!" ;
			return nullptr;
		}
		
		return (* pf)();	
	}

};



template<typename _classType, typename _rootClassType>
struct Dynamic
{
	typedef _classType classType;
	typedef _rootClassType rootClassType;
	static const reg_Str_Func_Map<_rootClassType> _initMap;
};


template<typename _classType, typename _rootClassType>
struct Dycreate
{
	typedef _classType classType;
	typedef _rootClassType rootClassType;
	static _rootClassType * ConstructInst(){ return new _classType(); }
	static const reg_Str_Func_Map<_rootClassType> _initMap;
};



template<typename Type>
class CObject
{
public:
	virtual ~CObject(){ ; }

public:
	virtual bool isKindof(const wchar_t * nameStr) 
	{
		if ( nameStr == nullptr )
		{
			return false;
		}		

		if ( std::wstring(this->getClassName()).compare( nameStr ) == 0 )
		{
			wcout << L"\nobject is kind of " << this->getClassName();
			return true;
		}

		wcout << L"\nobject is not kind of " << nameStr;
		return false;
	}

	virtual const std::wstring & getClassName(){ return CObject::s_className; }
	//类里没有了static 的construct()函数，放到外部一个模板实例类里了。
	//省字节，被模板实例占字节了，平衡
	virtual const std::wstring & getBasetClassName(std::wstring & str){ return str = L"\0"; }
	virtual const std::wstring & getRootBasetClassName(std::wstring & str){ return str = getClassName(); }

	virtual void fun() = 0; //注意派生类内必须定义，才能动态创建对象实例

public:
	static const std::wstring s_className;
};
ROOTCLASS_IMPLEMENT(project)
	

#define IMPLEMENT_DYNAMIC_PROJECT(class_name, baseclass_name)\
		IMPLEMENT_DYNAMIC_ROOTCLASS_TYPE(class_name, baseclass_name, ROOTCLASS(project))
	

#define IMPLEMENE_DYCREATE_PROJECT(class_name, baseclass_name)\
		IMPLEMENE_DYCREATE_ROOTCLASS_TYPE(class_name, baseclass_name, ROOTCLASS(project))


	
class B : public ROOTCLASS(project)
{
public:
	virtual ~B(){ ; }

public:	

DECLARE_DYNAMIC()
};
IMPLEMENT_DYNAMIC_PROJECT(B, ROOTCLASS(project))//动态识别


class C : public B
{
public:
	virtual ~C(){ ; }

	typedef C _classType;

public:	
	virtual void fun() { ; }

DECLARE_DYNAMIC()
};
IMPLEMENE_DYCREATE_PROJECT(C, B) //动态创建
	

class D : public C
{
public:
	virtual ~D(){ ; }

public:	

DECLARE_DYNAMIC()	
};
IMPLEMENE_DYCREATE_PROJECT(D, C)  //动态创建
	


int _tmain(int argc, _TCHAR* argv[])
{
	CObject_project_RunTimeX::retClassType * pObj = CObject_project_RunTimeX::ConstructInst(L"CObject<project>");

	if ( pObj != nullptr )
	{
		pObj->isKindof( ROOTCLASS_NAME_STR(project) );
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}
	
	cout << "\n1";

	pObj = CObject_project_RunTimeX::ConstructInst(L"B");
	if ( pObj != nullptr )
	{
		pObj->isKindof( ROOTCLASS_NAME_STR(project) );
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}

	cout << "\n2";
		
	pObj = CObject_project_RunTimeX::ConstructInst(L"C");
	if ( pObj != nullptr )
	{
		pObj->isKindof( ROOTCLASS_NAME_STR(project) );		
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}

	cout << "\n3";
		
	pObj = CObject_project_RunTimeX::ConstructInst(L"D");
	if ( pObj != nullptr )
	{
		pObj->isKindof( ROOTCLASS_NAME_STR(project) );
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}
	
	cout << "\n4";

	pObj = CObject_project_RunTimeX::ConstructInst(L"One");
	if ( pObj != nullptr )
	{
		pObj->isKindof( ROOTCLASS_NAME_STR(project) );
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}

	cout << "\n5\n";



	return 0;
}

[liron71]

忘了加头文件！ 设计了一些感觉直观的宏！ 更完善的版本！ 代码：

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>


// TODO: 在此处引用程序需要的其他头文件

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

#include <functional>
#include <iostream>
#include <unordered_map>

#include <codecvt>

using namespace std;


template<typename retType> class reg_Str_Func_Map;
template<typename _classType, typename _rootClassType> struct Dynamic;
template<typename _classType, typename _rootClassType> struct Dycreate;


//
//宏定义时尚未实际实例化，故可以放在前面位置，实例化时，宏里面要用到的类型定义必须可见
//

#define DECLARE_DYNAMIC()\
	public:\
	virtual bool isKindof(const wchar_t * nameStr);\
	virtual const std::wstring & getClassName();\
	virtual const std::wstring & getBaseClassName(std::wstring & str);\
	virtual const std::wstring & getRootBasetClassName(std::wstring & str);\
	public:\
	static const std::wstring s_className;


#define IMPLEMENT_DYNAMIC_ROOTCLASS_TYPE(class_name, baseclass_name, rootclass_name)\
	template struct Dynamic<class_name, rootclass_name>;\
	typedef Dynamic<class_name, rootclass_name> class_name##_##RuntimeX;\
	const std::wstring class_name::s_className(L#class_name);/*必须在前定义,下述初始化用来设置才准确*/\
	const reg_Str_Func_Map<rootclass_name> Dynamic<class_name, rootclass_name>::_initMap(class_name::s_className , nullptr);\
	bool class_name::isKindof(const wchar_t * nameStr)\
	{\
		if ( nameStr == nullptr )\
			return false;\
		if ( std::wstring(this->getClassName()).compare( nameStr ) == 0 )\
		{\
			wcout << L"\nobject is kind of " << this->getClassName();\
			return true;\
		}\
		else\
		{\
			return baseclass_name::isKindof( nameStr );\
		}\
	}\
	const std::wstring & class_name::getClassName(){ return class_name::s_className; }\
	const std::wstring & class_name::getBaseClassName(std::wstring & str){ return str = baseclass_name::getClassName(); }\
	const std::wstring & class_name::getRootBasetClassName(std::wstring & str){ return str = baseclass_name::getRootBasetClassName(str); }


#define IMPLEMENE_DYCREATE_ROOTCLASS_TYPE(class_name, baseclass_name, rootclass_name)\
	template struct Dycreate<class_name, rootclass_name>;\
	typedef Dycreate<class_name, rootclass_name> class_name##_##RuntimeX;\
	const std::wstring class_name::s_className(L#class_name);/*必须在前定义,下述初始化用来设置才准确*/\
	const reg_Str_Func_Map<rootclass_name> Dycreate<class_name, rootclass_name>::_initMap(class_name::s_className , Dycreate<class_name, rootclass_name>::ConstructInst);\
	bool class_name::isKindof(const wchar_t * nameStr)\
	{\
		if ( nameStr == nullptr )\
			return false;\
		if ( std::wstring(this->getClassName()).compare( nameStr ) == 0 )\
		{	\
			wcout << L"\nobject is kind of " << this->getClassName();\
			return true;\
		}\
		else\
		{\
			return baseclass_name::isKindof( nameStr );\
		}\
	}\
	const std::wstring & class_name::getClassName(){ return class_name::s_className; }\
	const std::wstring & class_name::getBaseClassName(std::wstring & str){ return str = baseclass_name::getClassName(); }\
	const std::wstring & class_name::getRootBasetClassName(std::wstring & str){ return str = baseclass_name::getRootBasetClassName(str); }


#define ROOTCLASS_IMPLEMENT(PROJECT_NAME)\
/**/\
	struct PROJECT_NAME{};\
	template class CObject<PROJECT_NAME>;/*基类模板实例化*/\
	const std::wstring CObject<PROJECT_NAME>::s_className( L"CObject<"##L#PROJECT_NAME##L">" );/*实例化的模板内部static变量定义*/\
/**/\
	template class reg_Str_Func_Map<CObject<PROJECT_NAME>>;/*关联类名与构造函数的模板实例化*/\
	typedef reg_Str_Func_Map<CObject<PROJECT_NAME>> CObject_##PROJECT_NAME##_RuntimeX;/*给上述模板的特化实例取个别名*/\
std::unordered_map<std::wstring, CObject_##PROJECT_NAME##_RuntimeX::FP> CObject_##PROJECT_NAME##_RuntimeX::className_To_Construct; /*模板实例化后的内部static变量必须在外部定义*/\
/**/\
	template struct Dynamic<CObject<PROJECT_NAME>, CObject<PROJECT_NAME>>;/*实现基类动态的模板特化*/\
	typedef Dynamic<CObject<PROJECT_NAME>, CObject<PROJECT_NAME>> CObject_##PROJECT_NAME##_Dynamic;/*对基类建立关联的特化实例取个别名*/\
	const CObject_##PROJECT_NAME##_RuntimeX CObject_##PROJECT_NAME##_Dynamic::_initMap(CObject<PROJECT_NAME>::s_className, nullptr);/*对基类建立关联，实现动态识别*/


#define ROOTCLASS(project)  CObject<project>
#define ROOTCLASS_NAME_STR(project)  L"CObject<"##L#project##L">"

#define RuntimeX(project)   CObject_##project##_RuntimeX


template<typename retType>
class reg_Str_Func_Map
{
public:
	typedef retType retClassType;
	typedef retType * (* FP)();

private:
	static std::unordered_map<std::wstring , FP> className_To_Construct; 

public:
	reg_Str_Func_Map( const std::wstring & classNameStr , const FP & pConstructFunc )
	{
		if (classNameStr.empty())				
			return;	
		
		reg_Str_Func_Map::className_To_Construct[classNameStr] = pConstructFunc;
	}

	static retType * ConstructInst(const wchar_t * nameStr)
	{
		if ( nameStr == nullptr )
			return nullptr;

		if ( reg_Str_Func_Map::className_To_Construct.count( nameStr ) <= 0 )
		{
			wcout << L"\n" << nameStr << L" is not a class name! Construct Instance is failed!";
			return nullptr;
		}

		FP pf = reg_Str_Func_Map::className_To_Construct[nameStr];
		if ( pf == nullptr )
		{
			wcout << L"\nclass " << nameStr << L" does not support dynamic creation (only dynamic identification)! Construct Instance is failed!" ;
			return nullptr;
		}
		
		return (* pf)();	
	}

};


template<typename _classType, typename _rootClassType>
struct Dynamic
{
	typedef _classType classType;
	typedef _rootClassType rootClassType;
	static const reg_Str_Func_Map<_rootClassType> _initMap;
};


template<typename _classType, typename _rootClassType>
struct Dycreate
{
	typedef _classType classType;
	typedef _rootClassType rootClassType;
	static _rootClassType * ConstructInst(){ return new _classType(); }
	static const reg_Str_Func_Map<_rootClassType> _initMap;
};


template<typename Type>
class CObject
{
public:
	virtual ~CObject(){ ; }

public:
	virtual bool isKindof(const wchar_t * nameStr) 
	{
		if ( nameStr == nullptr )
		{
			return false;
		}		

		if ( std::wstring(this->getClassName()).compare( nameStr ) == 0 )
		{
			wcout << L"\nobject is kind of " << this->getClassName();
			return true;
		}

		wcout << L"\nobject is not kind of " << nameStr;
		return false;
	}

	virtual const std::wstring & getClassName(){ return CObject::s_className; }
	//类里没有了static 的construct()函数，放到外部一个模板实例类里了。
	//省字节，被模板实例占字节了，平衡
	virtual const std::wstring & getBasetClassName(std::wstring & str){ return str = L"\0"; }
	virtual const std::wstring & getRootBasetClassName(std::wstring & str){ return str = getClassName(); }

	virtual void fun() = 0; //注意派生类内必须定义，才能动态创建对象实例

public:
	static const std::wstring s_className;
};



ROOTCLASS_IMPLEMENT(project)
	

#define IMPLEMENT_DYNAMIC_PROJECT(class_name, baseclass_name)\
		IMPLEMENT_DYNAMIC_ROOTCLASS_TYPE(class_name, baseclass_name, ROOTCLASS(project))
	

#define IMPLEMENE_DYCREATE_PROJECT(class_name, baseclass_name)\
		IMPLEMENE_DYCREATE_ROOTCLASS_TYPE(class_name, baseclass_name, ROOTCLASS(project))

	
class B : public ROOTCLASS(project)
{
public:
	virtual ~B(){ ; }

public:	

DECLARE_DYNAMIC()
};
IMPLEMENT_DYNAMIC_PROJECT(B, ROOTCLASS(project))//动态识别


class C : public B
{
public:
	virtual ~C(){ ; }

	typedef C _classType;

public:	
	virtual void fun() { ; }

DECLARE_DYNAMIC()
};
IMPLEMENE_DYCREATE_PROJECT(C, B) //动态创建
	

class D : public C
{
public:
	virtual ~D(){ ; }

public:	

DECLARE_DYNAMIC()	
};
IMPLEMENE_DYCREATE_PROJECT(D, C)  //动态创建
	


int _tmain(int argc, _TCHAR* argv[])
{
	RuntimeX(project)::retClassType * pObj = RuntimeX(project)::ConstructInst( ROOTCLASS_NAME_STR(project) );

	if ( pObj != nullptr )
	{
		pObj->isKindof( ROOTCLASS_NAME_STR(project) );
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}
	
	cout << "\n1";

	pObj = RuntimeX(project)::ConstructInst(L"B");
	if ( pObj != nullptr )
	{
		pObj->isKindof( ROOTCLASS_NAME_STR(project) );
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}

	cout << "\n2";
		
	pObj = RuntimeX(project)::ConstructInst(L"C");
	if ( pObj != nullptr )
	{
		pObj->isKindof( ROOTCLASS_NAME_STR(project) );		
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}

	cout << "\n3";
		
	pObj = RuntimeX(project)::ConstructInst(L"D");
	if ( pObj != nullptr )
	{
		pObj->isKindof( ROOTCLASS_NAME_STR(project) );
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}
	
	cout << "\n4";

	pObj = RuntimeX(project)::ConstructInst(L"One");
	if ( pObj != nullptr )
	{
		pObj->isKindof( ROOTCLASS_NAME_STR(project) );
		pObj->isKindof( L"B" );
		pObj->isKindof( L"C" );
		pObj->isKindof( L"D" );
		delete pObj;
	}

	cout << "\n5\n";



	return 0;
}

[liron71]

感觉以后写类库的时候，都可以且应该不要写成静态类！而应该都写成类模板！这样代码的抽象性更高，代码重用更高。