動態類型識別以及池創建

 

由于頻敏的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;
};