用途
在一個UI與邏輯模塊交互比較多的程序中，因為并不想讓兩個模塊發生太大的耦合，基本目標是
可以完全不改代碼地換一個UI。邏輯模塊需要在產生一些事件后通知到UI模塊，并且在這個通知
里攜帶足夠多的信息（數據）給接收通知的模塊，例如UI模塊。邏輯模塊還可能被放置于與UI模
塊不同的線程里。
最初的結構
最開始我直接采用最簡單的方法，邏輯模塊保存一個UI模塊傳過來的listener。當有事件發生時，
就回調相應的接口將此通知傳出去。大致結構如下：
/**//// Logic
class EventNotify
{
public:
virtual void OnEnterRgn( Player *player, long rgn_id );
};
/**//// UI class EventNotifyImpl : public EventNotify
{
};
/**//// Logic GetEventNotify()->OnEnterRgn( player, rgn_id );
但是，在代碼越寫越多之后，邏輯模塊需要通知的事件越來越多之后，EventNotify這個類開始
膨脹：接口變多了、不同接口定義的參數看起來也越來越惡心了。
改進
于是我決定將各種事件通知統一化：
struct Event
{
long type; // 事件類型
// 附屬參數
};
這樣，邏輯模塊只需要創建事件結構，兩個模塊間的通信就只需要一個接口即可：
void OnNotify( const Event &event );
但是問題又來了，不同的事件類型攜帶的附屬參數（數據）不一樣。也許，可以使用一個序列化
的組件，將各種數據先序列化，然后在事件處理模塊對應地取數據出來。這樣做總感覺有點大動
干戈了。當然，也可以使用C語言里的不定參數去解決，如：
void OnNotify( long event_type, ... )
其實，我需要的就是一個可以表面上類型一樣，但其內部保存的數據卻多樣的東西。這樣一想，
模塊就能讓事情簡單化：
template <typename P1, typename P2>
class Param
{
public:
Param( P1 p1, P2 p2 ) : _p1( p1 ), _p2( p2 )
{
}
P1 _p1;
P2 _p2;
};
template <typename P1, typename P2>
void OnNotify( long event_type, Param<P1, P2> param );
GetNotify()->OnNotify( ET_ENTER_RGN, Param<Player*, long>( player, rgn_id ) );
GetNotify()->OnNotify( ET_MOVE, Param<long, long>( x, y ) );
在上面這個例子中，雖然通過Param的包裝，邏輯模塊可以在事件通知里放置任意類型的數據，但
畢竟只支持2個參數。實際上為了實現支持多個參數（起碼得有15個），還是免不了自己實現多個
參數的Param。
幸虧我以前寫過宏遞歸產生代碼的東西，可以自動地生成這種情況下諸如Param1、Param2的代碼。
如：
#define CREATE_PARAM( n ) \
template <DEF_PARAM( n )> \
struct Param##n \
{ \
DEF_PARAM_TYPE( n ); \
Param##n( DEF_FUNC_PARAM( n ) ) \
{ \
DEF_MEM_VAR_ASSIGN( n ); \
} \
DEF_VAR_DEF( n ); \
}
CREATE_PARAM( 1 );
CREATE_PARAM( 2 );
即可生成Param1和Param2的版本。其實這樣定義了Param1、Param2的東西之后，又使得OnNotify
的參數不是特定的了。雖然可以把Param也泛化，但是在邏輯層寫過多的模板代碼，總感覺不好。
于是又想到以前寫的一個東西，可以把各種類型包裝成一種類型---對于外界而言：any。any在
boost中有提到，我只是實現了個簡單的版本。any的大致實現手法就是在內部通過多態機制將各
種類型在某種程度上隱藏，如：
class base_type
{
public:
virtual ~base_type()
{
}
virtual base_type *clone() const = 0;
};
template <typename _Tp>
class var_holder : public base_type
{
public:
typedef _Tp type;
typedef var_holder<type> self;
public:
var_holder( const type &t ) : _t( t )
{
}
base_type *clone() const
{
return new self( _t );
}
public:
type _t;
}
這樣，any類通過一個base_type類，利用C++多態機制即可將類型隱藏于var_holder里。那么，
最終的事件通知接口成為下面的樣子：
void OnNotify( long type, any data );
OnNotify( ET_ENTER_RGN, any( create_param( player, rgn_id ) ) );其中，create_param
是一個輔助函數，用于創建各種Param對象。
事實上，實現各種ParamN版本，讓其名字不一樣其實有點不妥。還有一種方法可以讓Param的名字
只有一個，那就是模板偏特化。例如：
template <typename _Tp>
struct Param;
template <>
struct Param<void()>;
template <typename P1>
struct Param<void(P1)>
template <typename P1, typename P2>
struct Param<void(P1,P2)>
這種方法主要是通過組合出一種函數類型，來實現偏特化。因為我覺得構造一個函數類型給主模版，
并不是一種合情理的事情。但是，即使使用偏特化來讓Param名字看起來只有一個，但對于不同的
實例化版本，還是不同的類型，所以還是需要any來包裝。
實際使用
實際使用起來讓我覺得非常賞心悅目。上面做的這些事情，實際上是做了一個不同模塊間零耦合
通信的通道（零耦合似乎有點過激）?，F在邏輯模塊通知UI模塊，只需要定義新的事件類型，在
兩邊分別寫通知和處理通知的代碼即可。
PS:
針對一些評論，我再解釋下。其實any只是用于包裝Param列表而已，這里也可以用void*，再轉成
Param*。在這里過多地關注是用any*還是用void*其實偏離了本文的重點。本文的重點其實是Param：
OnNotify( NT_ENTER_RGN, ang( create_param( player, rgn_id ) ) );
->
void OnNotify( long type, any data )
{
Param2<Player*, long> ParamType;
ParamType *p = any_cast<ParamType>( &data );
Player *player = p->p1;
long rgn_id = p->p2;
}
下載相關代碼
IniFileParser.h
/*************************************************************************/
/* FileName:IniFileParser.cpp */
/* Describe:IniFile@read、write */
/* Author :Kagayaku */
/* Date :3.22.2010 */
/************************************************************************/
#ifndef _INIFILEPARSER_H_
#define _INIFILEPARSER_H_
#include <string>
#include <vector>
using namespace std;
struct CIniEntry
{
CIniEntry(){}
CIniEntry(char *szName,char *szValue):m_strIEName(szName),m_strIEValue(szValue){}
string m_strIEName;
string m_strIEValue;
};
struct CIniComment
{
CIniComment(){}
CIniComment(char *szIC):m_strIC(szIC){}
string m_strIC;
};
struct CIniSection
{
vector<CIniEntry> m_vecIE;
vector<CIniComment> m_vecIC;
string m_strISName;
};
class CIniFile
{
public:
CIniFile(const char *szIniFileFullPath);
~CIniFile();
bool ReadIniFile(const char *szinifile);
bool WriteIniFile(const char *szinifile);
void TrimIniFile(char* &szinifile) const;
void RemoveComment(char *szinifile) const;
bool SearchMatchingIniFileSectionGetEntryValue(const char *szinifile,const char *szsectionname,const char *szentryname);
bool SearchMatchingIniFileSectionSetEntryValue(const char *szinifile,const char *szsectionname,const char *szentryname,const char *szentryvalue);
private:
vector<CIniSection> m_vecIS;
string m_strBufIEValue;
string m_strIniFileName;
};
#endif
IniFileParser.cpp
#include "IniFileParser.h"
#include <fstream>
CIniFile::CIniFile(const char *szIniFileFullPath):m_strIniFileName(szIniFileFullPath)
{
ReadIniFile(szIniFileFullPath);
}
CIniFile::~CIniFile()
{
}
bool CIniFile::ReadIniFile(const char *szinifile)
{
if (NULL==szinifile)
{
return false;
}
ifstream inifile(szinifile);
if (NULL==inifile)
{
return false;
}
const int MAX_ROW_LENGTH=200;
char chLineBufArray[MAX_ROW_LENGTH]={0};
while(inifile.getline(chLineBufArray,MAX_ROW_LENGTH))
{
char *p=chLineBufArray;
TrimIniFile(p);
if (*p=='[')
{
RemoveComment(p);
char *pEnd=strchr(p,']');
if (NULL==pEnd || pEnd==p+1)
{
continue;
}
*pEnd = 0;
CIniSection is;
is.m_strISName=string(p+1);
m_vecIS.push_back(is);
continue;
}
if (m_vecIS.size()<1)
{
continue;
}
if (*p==';')
{
if (NULL==*(p+1))
{
continue;
}
else
{
CIniComment ic(p+1);
m_vecIS[m_vecIS.size()-1].m_vecIC.push_back(ic);
continue;
}
}
char *pFlag=strchr(p,'=');
if (NULL==pFlag || pFlag==p || NULL==*(pFlag+1))
{
continue;
}
else
{
*pFlag=0;
CIniEntry ie;
ie.m_strIEName=string(p);
ie.m_strIEValue=string(pFlag+1);
m_vecIS[m_vecIS.size()-1].m_vecIE.push_back(ie);
continue;
}
}
inifile.close();
return true;
}
bool CIniFile::WriteIniFile(const char *szinifile)
{
if (NULL==szinifile || m_strIniFileName!=szinifile)
{
return false;
}
ofstream inifile(szinifile);
if (NULL==inifile)
{
return false;
}
for (int i=0;i!=m_vecIS.size();++i)
{
inifile.write("[",1);
inifile.write(m_vecIS[i].m_strISName.c_str(),m_vecIS[i].m_strISName.size());
inifile.write("]",1);
inifile << endl;
for (int j=0;j!=m_vecIS[i].m_vecIE.size();++j)
{
inifile.write(m_vecIS[i].m_vecIE[j].m_strIEName.c_str(),m_vecIS[i].m_vecIE[j].m_strIEName.size());
inifile.write("=",1);
inifile.write(m_vecIS[i].m_vecIE[j].m_strIEValue.c_str(),m_vecIS[i].m_vecIE[j].m_strIEValue.size());
inifile << endl;
}
}
inifile.close();
return true;
}
void CIniFile::TrimIniFile(char* &szinifile) const
{
if (NULL==szinifile)
{
return;
}
char *p=szinifile;
while(*p==' ' || *p=='\t')
{
++p;
}
szinifile=p;
p=szinifile+strlen(szinifile)-1;
while(*p==' ' || *p=='\t'|| *p=='\r'|| *p=='\n')
{
*p=0;
--p;
}
}
void CIniFile::RemoveComment(char *szinifile) const
{
if (NULL==szinifile)
{
return;
}
char *p=strchr(szinifile,';');
*p = 0;
}
bool CIniFile::SearchMatchingIniFileSectionGetEntryValue(const char *szinifile,const char *szsectionname,const char *szentryname)
{
if (NULL==szinifile || NULL==szsectionname || NULL==szentryname)
{
return false;
}
if (m_strIniFileName!=szinifile)
{
return false;
}
bool temp=false;
for (vector<CIniSection>::iterator iterIS=m_vecIS.begin();iterIS!=m_vecIS.end();++iterIS)
{
if ((*iterIS).m_strISName==szsectionname)
{
for (vector<CIniEntry>::iterator iterIE=(*iterIS).m_vecIE.begin();iterIE!=(*iterIS).m_vecIE.end();++iterIE)
{
if ((*iterIE).m_strIEName==szentryname)
{
m_strBufIEValue=(*iterIE).m_strIEValue;
temp=true;
}
}
}
}
return temp;
}
bool CIniFile::SearchMatchingIniFileSectionSetEntryValue(const char *szinifile,const char *szsectionname,const char *szentryname,const char *szentryvalue)
{
if (NULL==szinifile || NULL==szsectionname || NULL==szentryname|| NULL==szentryvalue)
{
return false;
}
if (m_strIniFileName!=szinifile)
{
return false;
}
bool temp=false;
for (vector<CIniSection>::iterator iterIS=m_vecIS.begin();iterIS!=m_vecIS.end();++iterIS)
{
if ((*iterIS).m_strISName==szsectionname)
{
for (vector<CIniEntry>::iterator iterIE=(*iterIS).m_vecIE.begin();iterIE!=(*iterIS).m_vecIE.end();++iterIE)
{
if ((*iterIE).m_strIEName==szentryname)
{
(*iterIE).m_strIEValue=szentryvalue;
temp=true;
}
}
}
}
return temp?WriteIniFile(szinifile):false;
}