消息关闭
    暂无新消息!
今天又整理了一下思路,重新简要写了一下实现动态识别的机制
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;
}


4个回答

︿ 1
感觉以后写类库的时候,都可以且应该不要写成静态类!而应该都写成类模板!这样代码的抽象性更高,代码重用更高。
︿ 1
忘了加头文件!
设计了一些感觉直观的宏!
更完善的版本!

代码:


#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;
}


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

#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;
}