用过C#的朋友都觉得C#的确是个好语言，但有时由于特殊需要，不得不用C++，在C++中要想实现C#中的Thread等也是可行的，不过代码要稍复杂。

以例子来说明：

view plaincopy to clipboardprint?
class   Sdk   
{   
public:   
    void   DoSomething();     
};   
 
class   client   
{   
public:   
    Sdk   m_sdk;   
    void   DoSomething{}   
    {   
        m_sdk.DoSomething();   
    }   
 
    void   OnMessage()   
    {   
        //   
    }   
}  
class   Sdk
{
public:
 void   DoSomething();  
};

class   client
{
public:
 Sdk   m_sdk;
 void   DoSomething{}
 {
  m_sdk.DoSomething();
 }

 void   OnMessage()
 {
  //
 }
} 

这个例子比较简单，Sdk用来实现某个功能，client是客户程序，要想在m_sdk做处理的时候能发送通知到client，有几个方法可以实现， 其一是发线程消息，其一是回调，但传统的回调对面向对象的支持并不好，这就是实现delegate的出发点。 下面是一个实现：

view plaincopy to clipboardprint?
class   Delegate   
{   
public:   
    virtual   ~Delegate(void){   }   
    virtual   void   operator()(void)   =   0;   
};   
template <typename   C>   
class   DelegateImpl   :   public   Delegate   
{   
private:   
    typedef   void   (C::*F)(void);   
    C*   m_class;   
    F   m_fun;   
public:   
    DelegateImpl(C*   c,   F   f){   m_class   =   c;   m_fun   =   f;   }   
    virtual   void   operator()(void)   
    {   
        if(m_class)   
            return   (m_class-> *m_fun)();   
    }   
};  
class   Delegate
{
public:
 virtual   ~Delegate(void){   }
 virtual   void   operator()(void)   =   0;
};
template <typename   C>
class   DelegateImpl   :   public   Delegate
{
private:
 typedef   void   (C::*F)(void);
 C*   m_class;
 F   m_fun;
public:
 DelegateImpl(C*   c,   F   f){   m_class   =   c;   m_fun   =   f;   }
 virtual   void   operator()(void)
 {
  if(m_class)
   return   (m_class-> *m_fun)();
 }
};
 

有了上面代码，再稍加修改sdk和client代码就能实现事件通知了：

view plaincopy to clipboardprint?
class   Sdk   
{   
public:   
    Delegate*   pEvent;   
    sdk():   pEvent(NULL)   {   }   
    void   DoSomething()   
    {   
        cout < <"opened" < <endl;   
        if(pEvent   !=   NULL)   
            (*pEvent)(   );   
    }   
};   
 
class   client   
{   
private:   
    Sdk   m_sdk;   
 
public:   
    client()   
    {   
        m_sdk.pEvent   =   new   Delegate <client> (this,   OnOpen);   
    }   
    void   DoSomething()   
    {   
        m_sdk.DoSomething();   
    }   
 
    void   OnDoSomething()   
    {   
        cout < <"event   fired" < <endl;   
    }   
}  
class   Sdk
{
public:
 Delegate*   pEvent;
 sdk():   pEvent(NULL)   {   }
 void   DoSomething()
 {
  cout < <"opened" < <endl;
  if(pEvent   !=   NULL)
   (*pEvent)(   );
 }
};

class   client
{
private:
 Sdk   m_sdk;

public:
 client()
 {
  m_sdk.pEvent   =   new   Delegate <client> (this,   OnOpen);
 }
 void   DoSomething()
 {
  m_sdk.DoSomething();
 }

 void   OnDoSomething()
 {
  cout < <"event   fired" < <endl;
 }
}
 

上面的实现有不少局限性，事件处理方法的返回值和参数设置不是十分灵活，因此可以用宏定义优代以上代码， 下面给出我的全部代码，请朋友指正。

view plaincopy to clipboardprint?
//////////////////////////////////////////////////////////////////////////  
//delegate 0  
#define DEFINE_DELEGATE(NAME, R)\  
class NAME##Delegate\  
{\  
public:\  
    virtual ~NAME##Delegate(void){ }\  
    virtual R operator()(void) = 0;\  
};\  
    template<typename C>\  
class NAME##DelegateImpl : public NAME##Delegate\  
{\  
private:\  
    typedef R (C::*F)(void);\  
    C* m_class;\  
    F m_fun;\  
public:\  
    NAME##DelegateImpl(C* c, F f){ m_class = c; m_fun = f; }\  
    virtual R operator()(void)\  
{\  
    if(m_class)\  
    return (m_class->*m_fun)();\  
}\  
};\  
    template<typename C, typename F>\  
    NAME##Delegate* Make##NAME##Delegate(C* c, F f)\  
{\  
    return new NAME##DelegateImpl<C>(c, f);\  
}  
//////////////////////////////////////////////////////////////////////////  
//delegate 1  
#define DEFINE_DELEGATE(NAME, R, P1)\  
class NAME##Delegate\  
{\  
public:\  
    virtual ~NAME##Delegate(void){ }\  
    virtual R operator()(P1 p1) = 0;\  
};\  
    template<typename C>\  
class NAME##DelegateImpl : public NAME##Delegate\  
{\  
private:\  
    typedef R (C::*F)(P1);\  
    C* m_class;\  
    F m_fun;\  
public:\  
    NAME##DelegateImpl(C* c, F f){ m_class = c; m_fun = f; }\  
    virtual R operator()(P1 p1)\  
{\  
    if(m_class)\  
    return (m_class->*m_fun)(p1);\  
}\  
};\  
    template<typename C, typename F>\  
    NAME##Delegate* Make##NAME##Delegate(C* c, F f)\  
{\  
    return new NAME##DelegateImpl<C>(c, f);\  
}  
//////////////////////////////////////////////////////////////////////////  
//delegate 2  
#define DEFINE_DELEGATE(NAME, R, P1, P2)\  
class NAME##Delegate\  
{\  
public:\  
    virtual ~NAME##Delegate(void){ }\  
    virtual R operator()(P1 p1, P2 p2) = 0;\  
};\  
    template<typename C>\  
class NAME##DelegateImpl : public NAME##Delegate\  
{\  
private:\  
    typedef R (C::*F)(P1, P2);\  
    C* m_class;\  
    F m_fun;\  
public:\  
    NAME##DelegateImpl(C* c, F f){ m_class = c; m_fun = f; }\  
    virtual R operator()(P1 p1, P2 p2)\  
{\  
    if(m_class)\  
    return (m_class->*m_fun)(p1, p2);\  
}\  
};\  
    template<typename C, typename F>\  
    NAME##Delegate* Make##NAME##Delegate(C* c, F f)\  
{\  
    return new NAME##DelegateImpl<C>(c, f);\  
}  
 
/* 
////////////////////////////////////////////////////////////////////////// 
//sample 
DEFINE_DELEGATE(Open, void, int, string) 
class sdk 
{ 
public: 
    OpenDelegate* pEvent; 
    sdk(): pEvent(NULL) { } 
    void Open() 
    { 
        cout<<"opened"<<endl; 
        if(pEvent != NULL) 
            (*pEvent)(100, "你好"); 
    } 
}; 
class client 
{ 
private: 
    sdk m_sdk; 
public: 
    client() 
    { 
        m_sdk.pEvent = MakeOpenDelegate(this, OnOpen2); 
    } 
    void Open() 
    { 
        m_sdk.Open(); 
    } 
    void OnOpen() 
    { 
        cout<<"Open event fired"<<endl; 
    } 
    void OnOpen2(int t, string str) 
    { 
        cout<<"Open event fired, Param = "<<t<<"param2 = "<<str.c_str()<<endl; 
    } 
}; 
*/ 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/gisfarmer/archive/2009/04/13/4068283.aspx

int i = 100;
long l = 2001;
float f=300.2;
double d=12345.119;
char username[]="MediX医用计算与数据系统";
char temp[200];
char *buf;
CString str;
_variant_t v1;
_bstr_t v2;

一、其它数据类型转换为字符串

短整型(int)
itoa(i,temp,10);///将i转换为字符串放入temp中,最后一个数字表示十进制
itoa(i,temp,2); ///按二进制方式转换
长整型(long)
ltoa(l,temp,10);

二、从其它包含字符串的变量中获取指向该字符串的指针

CString变量
str = "2008北京奥运";
buf = (LPSTR)(LPCTSTR)str;
BSTR类型的_variant_t变量
v1 = (_bstr_t)"程序员";
buf = _com_util::ConvertBSTRToString((_bstr_t)v1);

三、字符串转换为其它数据类型
strcpy(temp,"123");

短整型(int)
i = atoi(temp);
长整型(long)
l = atol(temp);
浮点(double)
d = atof(temp);

四、其它数据类型转换到CString
使用CString的成员函数Format来转换,例如:

整数(int)
str.Format("%d",i);
浮点数(float)
str.Format("%f",i);
字符串指针(char *)等已经被CString构造函数支持的数据类型可以直接赋值
str = username;

五、BSTR、_bstr_t与CComBSTR

CComBSTR、_bstr_t是对BSTR的封装,BSTR是指向字符串的32位指针。
char *转换到BSTR可以这样: BSTR b=_com_util::ConvertStringToBSTR("数据");///使用前需要加上头文件comutil.h
反之可以使用char *p=_com_util::ConvertBSTRToString(b);

六、VARIANT 、_variant_t 与 COleVariant

VARIANT的结构可以参考头文件VC98\Include\OAIDL.H中关于结构体tagVARIANT的定义。
对于VARIANT变量的赋值：首先给vt成员赋值，指明数据类型，再对联合结构中相同数据类型的变量赋值，举个例子：
VARIANT va;
int a=2001;
va.vt=VT_I4;///指明整型数据
va.lVal=a; ///赋值

对于不马上赋值的VARIANT，最好先用Void VariantInit(VARIANTARG FAR* pvarg);进行初始化,其本质是将vt设置为VT_EMPTY,下表我们列举vt与常用数据的对应关系:

unsigned char bVal; VT_UI1
short iVal; VT_I2
long lVal; VT_I4
float fltVal; VT_R4
double dblVal; VT_R8
VARIANT_BOOL boolVal; VT_BOOL
SCODE scode; VT_ERROR
CY cyVal; VT_CY
DATE date; VT_DATE
BSTR bstrVal; VT_BSTR
IUnknown FAR* punkVal; VT_UNKNOWN
IDispatch FAR* pdispVal; VT_DISPATCH
SAFEARRAY FAR* parray; VT_ARRAY|*
unsigned char FAR* pbVal; VT_BYREF|VT_UI1
short FAR* piVal; VT_BYREF|VT_I2
long FAR* plVal; VT_BYREF|VT_I4
float FAR* pfltVal; VT_BYREF|VT_R4
double FAR* pdblVal; VT_BYREF|VT_R8
VARIANT_BOOL FAR* pboolVal; VT_BYREF|VT_BOOL
SCODE FAR* pscode; VT_BYREF|VT_ERROR
CY FAR* pcyVal; VT_BYREF|VT_CY
DATE FAR* pdate; VT_BYREF|VT_DATE
BSTR FAR* pbstrVal; VT_BYREF|VT_BSTR
IUnknown FAR* FAR* ppunkVal; VT_BYREF|VT_UNKNOWN
IDispatch FAR* FAR* ppdispVal; VT_BYREF|VT_DISPATCH
SAFEARRAY FAR* FAR* pparray; VT_ARRAY|*
VARIANT FAR* pvarVal; VT_BYREF|VT_VARIANT
void FAR* byref; VT_BYREF

_variant_t是VARIANT的封装类，其赋值可以使用强制类型转换，其构造函数会自动处理这些数据类型。
例如：
long l=222;
ing i=100;
_variant_t lVal(l);
lVal = (long)i;

COleVariant的使用与_variant_t的方法基本一样，请参考如下例子：
COleVariant v3 = "字符串", v4 = (long)1999;
CString str =(BSTR)v3.pbstrVal;
long i = v4.lVal;

七、其它

对消息的处理中我们经常需要将WPARAM或LPARAM等32位数据(DWORD)分解成两个16位数据(WORD),例如：
LPARAM lParam;
WORD loValue = LOWORD(lParam);///取低16位
WORD hiValue = HIWORD(lParam);///取高16位
对于16位的数据(WORD)我们可以用同样的方法分解成高低两个8位数据(BYTE),例如:
WORD wValue;
BYTE loValue = LOBYTE(wValue);///取低8位
BYTE hiValue = HIBYTE(wValue);///取高8位  

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/icycoffee/archive/2008/02/27/2125360.aspx

// 注：设置语言环境以便输出WideChar
setlocale(LC_ALL,"chs");

// 注： char* 转换 wchar_t*
// 注： wchar_t 未重载 << ，所以不可使用 cout << 输出
pWideChar = AnsiToUnicode( pChar );
// 注：printf("%ls") 和 wprintf(L"%s") 一致
printf( "%ls\n", pWideChar );

// 注：wchar_t* 转换 wchar_t[]
wcscpy ( tagWideCharList, pWideChar );
wprintf( L"%s\n", tagWideCharList );

// 注：wchar_t[] 转换 wchar_t*
pWideChar = tagWideCharList;
wprintf( L"%s\n", pWideChar );

// 注：char 转换 string
str.insert( str.begin(), ch );
cout << str << endl;

// 注：wchar_t* 转换 string
pWideChar = new wchar_t[str.length()];
swprintf( pWideChar, L"%s", str.c_str());
wprintf( L"%s\n", pWideChar );

// 注：string 转换 char*
pChar = const_cast<char*>(str.c_str());
cout << pChar << endl;

// 注：char* 转换 string
str = std::string(pChar);
// 注： cout 的 << 重载了string, 若printf 的话必须 printf("%s", str.c_str());
//   而不可 print( "%s", str ); 因为 str 是个 string 类
cout << str << endl;

// 注：string 转换 char[]
str = "无聊啊无聊";
strcpy( tagChar, str.c_str() );
printf( "%s\n", tagChar );

// 注：string 转换 CString;
cStr = str.c_str();

// 注：CString 转换 string
str = string(cStr.GetBuffer(cStr.GetLength()));

// 注：char* 转换 CString
cStr = pChar;

// 注：CString 转换 char*
pChar = cStr.GetBuffer( cStr.GetLength() );

// 注：CString 转换 char[]
strncpy( tagChar, (LPCTSTR)CString, sizeof(tagChar));

// 注：CString 转换 wchar_t*
pWideChar = cStr.AllocSysString();
printf( "%ls\n", pWideChar );
}