動(dòng)態(tài)類型識(shí)別以及池創(chuàng)建

 

由于頻敏的new效率較低，需要避免直接new,這有兩種辦法:

1. 讓程序重載new統(tǒng)一將內(nèi)存分級(jí)別鏈來(lái)管理分配內(nèi)存(可參考nebula1中的內(nèi)存管理）

2. 使用對(duì)象池(可參考boost object pool)

 

我這里臨時(shí)使用boost的object pool以及u2的rtti類概念寫了一個(gè)池創(chuàng)建類

這樣處理后就可以很方便地將類似派生樹這樣的類分別使用池方式統(tǒng)一接口來(lái)管理。類似

class kWindow;

class kButton : public kWindow;

class kLabel : public kWindow;

假如有很多這樣的控件，如果你用類boost的object pool，那你要手寫每個(gè)類對(duì)應(yīng)一個(gè)pool mgr，

在釋放時(shí)還要知道釋放的對(duì)象屬于哪個(gè)poolmgr， 再用這個(gè)poolmgr來(lái)釋放。。。。

 

使用下面的類可簡(jiǎn)化為:

kButton *p = kTClass::Create("kButton"); // 統(tǒng)一創(chuàng)建接口（只需控件類名稱）

p->Release(); // 統(tǒng)一釋放接口

 

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

//根據(jù)類名取得定義類
#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();

//類定義實(shí)現(xiàn)宏
#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的結(jié)點(diǎn)結(jié)象樹的方法可以作到比較的對(duì)象管理(幾年前我已寫過教程):
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;
};