动态类型识别以及池创建

 

由于频敏的new效率较低，需要避免直接new,这有两种办法:

1. 让程序重载new统一将内存分级别链来管理分配内存(可参考nebula1中的内存管理）

2. 使用对象池(可参考boost object pool)

 

我这里临时使用boost的object pool以及u2的rtti类概念写了一个池创建类

这样处理后就可以很方便地将类似派生树这样的类分别使用池方式统一接口来管理。类似

class kWindow;

class kButton : public kWindow;

class kLabel : public kWindow;

假如有很多这样的控件，如果你用类boost的object pool，那你要手写每个类对应一个pool mgr，

在释放时还要知道释放的对象属于哪个poolmgr， 再用这个poolmgr来释放。。。。

 

使用下面的类可简化为:

kButton *p = kTClass::Create("kButton"); // 统一创建接口（只需控件类名称）

p->Release(); // 统一释放接口

 

 template <typename T, bool bTPool>
struct kAllocMgr;
template <typename T>
struct kAllocMgr<T, false>
{
 static object_new_delete<T, default_user_allocator_new_delete> pool;
};
template <typename T>
object_new_delete<T, default_user_allocator_new_delete> kAllocMgr<T, false>::pool;

template <typename T>
struct kAllocMgr<T, true>
{
 static object_pool<T, default_user_allocator_new_delete> pool;
};
template <typename T>
object_pool<T, default_user_allocator_new_delete> kAllocMgr<T, true>::pool;

//------------------------------------------------------------
// flipcode@msn.com
class kRoot;

class kClass
{
 friend class kKernelServer;
 LPCTSTR       m_szClassName;     
 INT        m_nObjSize;     
 kRoot*       (*m_pfnCreate)();    
 kClass*       m_pBaseClass;      
 kClass*       m_pNextClass;     
public:
 kClass (LPCTSTR szClassName, int nObjSize, kRoot* (*NewObject)(), kClass *baseClass); 
 LPCTSTR GetName(){
  return m_szClassName;
 }
};

//根据类名取得定义类
#define GETCLASS(ClassName)  (&ClassName::m_class##ClassName)

//类定义声明宏
#define K_RTTI_DEC(ClassName) \
public: \
 static kClass    m_class##ClassName; \
 virtual const kClass*  GetClass(VOID) const; \
 static kRoot* Create(); \
 void Destory();

//类定义实现宏
#define K_RTTI_IMP(ClassName, baseClass) \
 static TCHAR sz##ClassName[] = _T(#ClassName); \
 kClass ClassName::m_class##ClassName(sz##ClassName, sizeof(ClassName), ClassName::Create, baseClass); \
 const kClass* ClassName::GetClass() const \
  { return &ClassName::m_class##ClassName; } \
 kRoot* ClassName::Create() \
 { \
  ClassName *p = kAllocMgr<ClassName, true>::pool.construct(); \
  return p; \
 } \
 void ClassName::Destory(){ \
  kAllocMgr<ClassName,true>::pool.destroy(this); \
 }

另外配合nebula的结点结象树的方法可以作到比较的对象管理(几年前我已写过教程):
class kKernelServer : public kSingleton<kKernelServer>
{
 friend class kClass;
 map<STRING, kClass*> m_ClassMap;
 kClass *m_pFirstClass;
 kRoot m_Root;
 kRoot *m_pCWD;
 kRoot*  _NewObject( LPCTSTR szClassName, LPCTSTR szName );
 void ReisgerClass(kClass* pNewClass);
public:
 kKernelServer(void);
 ~kKernelServer(void);

 kRoot*   NewNode( LPCTSTR szClassName, LPCTSTR szPath );
 kRoot*   NewNode( LPCTSTR szClassName, LPCTSTR szPath, LPCTSTR szName);
 kRoot*   Lookup( LPCTSTR szPath );
 void   SetCwd( kRoot *o ){
  this->m_pCWD = o ? o : &m_Root;
 }
 kClass*   GetClass(LPCTSTR szClassName);
 BOOL   IsKindOf(const kClass* pThisClass, const kClass* pBaseClass) const;
 BOOL   LoadPlugin(LPCTSTR szPluginName, void * pParam);
 void   ShutDown(void);

protected:
 struct PLUGININFO
 {
  HMODULE   hModule;
  STRING   strPluginFile;
  FUNDLLINIT pfnDllInit;
  FUNDLLRELEASE pfnDllRelease;
 };
 void FreeAllPlugin(void);
 std::vector< PLUGININFO > m_vecPlugin;
};