用模板的偏特化和成员模板，重载函数调用运算符成功的实现了delegate,既可以绑定普通函数，也可以绑定对象及其成员函数
在cygnuwin下编译通过, 
还不支持一个delegate包含多个函数的用法,不过相信很简单，从std::list派生一个类 
就可以了 
我用的cygun有些毛病， 
my_delegate d2=my_delegate(t,&Test::f); 
                           ^如果写成&t，就会导致编译器内部错误，没办法了 
  
我本来写程序是加空行的，贴到BBS上就没了，忍受一下吧 
Win32下的各种调用约定很讨厌，没有考虑，不过实现起来不费什么脑筋，就是麻烦， 
不管了 
  
// Test.cpp : Defines the entry point for the console application. 
// 
#include <stddef.h> 
template<class T> 

//函数traits,用来提取函数的返回类型

struct function_traits 
{ 
}; 
template<class RT> 
struct function_traits< RT(*)() > 
{ 
 typedef RT result_type; 
}; 
template<class RT,class AT> 
struct function_traits< RT(*)(AT) > 
{ 
 typedef RT result_type; 
 typedef AT argument_type; 
}; 
template<class RT,class AT1,class AT2> 
struct function_traits< RT(*)(AT1,AT2) > 
{ 
 typedef RT result_type; 
 typedef AT1 first_argument_type; 
 typedef AT2 second_argument_type; 
};

// 函数traits,用来提取类成员函数的返回类型

template<class RT, class OT> 
struct function_traits< RT (OT::*)() > 
{ 
 typedef OT object_type; 
 typedef RT result_type; 
}; 
template<class RT, class OT, class AT> 
struct function_traits< RT (OT::*)(AT) > 
{ 
 typedef OT object_type; 
 typedef RT result_type; 
 typedef AT argument_type; 
  
 typedef AT first_argument_type; 
}; 
template<class RT,class OT,class AT1,class AT2> 
struct function_traits< RT (OT::*)(AT1,AT2) > 
{ 
 typedef OT object_type; 
 typedef RT result_type; 
 typedef AT1 first_argument_type; 
 typedef AT2 second_argument_type; 
};

// 把一个普通函数类向转化为类型兼容的指定类的成员函数类型 
template <typename OT, typename PFT> 
struct to_member_function_pointer 
{ 
}; 
template <typename OT,typename RT> 
struct to_member_function_pointer< OT, RT(*)() > 
{ 
 typedef RT (OT::*type)(); 
}; 
template <typename OT, typename RT, typename AT> 
struct to_member_function_pointer< OT, RT(*)(AT) > 
{ 
 typedef RT (OT::*type)(AT); 
}; 
template <typename OT, typename RT, typename AT1, typename AT2> 
struct to_member_function_pointer< OT, RT(*)(AT1,AT2) > 
{ 
 typedef RT (OT::*type)(AT1,AT2); 
}; 
template <typename OT, typename RT, typename AT1, typename AT2, typename AT3> 
struct to_member_function_pointer< OT, RT(*)(AT1,AT2,AT3) > 
{ 
 typedef RT (OT::*type)(AT1,AT2,AT3); 
}; 

// 转化为const 成员函数

template <typename OT, typename PFT> 
struct to_const_member_function_pointer 
{ 
}; 
template <typename OT, typename RT> 
struct to_const_member_function_pointer< OT, RT(*)() > 
{ 
 typedef RT (OT::*type)() const; 
}; 
template <typename OT, typename RT, typename AT> 
struct to_const_member_function_pointer< OT, RT(*)(AT) > 
{ 
 typedef RT (OT::*type)(AT) const; 
}; 
template <typename OT, typename RT, typename AT1, typename AT2> 
struct to_const_member_function_pointer< OT, RT(*)(AT1,AT2) > 
{ 
 typedef RT (OT::*type)(AT1,AT2) const; 
}; 
template <typename OT, typename RT, typename AT1, typename AT2, typename AT3> 
struct to_const_member_function_pointer< OT, RT(*)(AT1,AT2,AT3) > 
{ 
 typedef RT (OT::*type)(AT1,AT2,AT3) const; 
}; 

// delegate的实现

template <typename PFT> 
class delegate 
{ 
 class object 
 { 
 }*m_pObject; // 对象指针，是一个代理对象
 typedef typename to_member_function_pointer<object, PFT>::type object_member_fuunction_pointer; 
 union 
 { 
  PFT m_pf; 
  object_member_function_pointer m_pmf; 
 }; // 函数指针和成员函数指针的联合体
 public: 
  typedef typename function_traits<PFT>::result_type result_type; 
  
  delegate() 
  { 
   m_pObject=NULL; 
   m_pf=NULL; 
  } 
  
  delegate(PFT pf) 
  { 
   operator=(pf); 
  } 
  
  template<typename OT> 
   delegate( 
   OT *pObject, 
   typename to_member_function_pointer<OT, PFT>::type pmf 
   ) 
  { 
   m_pObject=reinterpret_cast<object*>(pObject); 
   m_pmf=*(reinterpret_cast<object_member_function_pointer*>(&pmf)); 
  } 
  
  template<typename OT> 
   delegate( 
   OT &pObject, 
   typename to_member_function_pointer<OT, PFT>::type pmf 
   ) 
  { 
   m_pObject=reinterpret_cast<object*>(&pObject); 
   m_pmf=*(reinterpret_cast<object_member_function_pointer*>(&pmf)); 
  } 
  
  template<typename OT> 
   delegate( 
   const OT *pObject, 
   typename to_const_member_function_pointer<OT, PFT>::type pmf 
   ) 
  { 
   m_pObject=const_cast<object*>(reinterpret_cast<object*>(pObject)); 
   m_pmf=*(reinterpret_cast<object_member_function_pointer*>(&pmf)); 
  } 
  
  template<typename OT> 
   delegate( 
   const OT &pObject, 
   typename to_const_member_function_pointer<OT, PFT>::type pmf 
   ) 
  { 
   m_pObject=const_cast<object*>(reinterpret_cast<object*>(&pObject)); 
   m_pmf=*(reinterpret_cast<object_member_function_pointer*>(&pmf)); 
  } 
  
  delegate & operator=(PFT pf) 
  { 
   m_pf=pf; 
   m_pObject=0; 
   return *this; 
  } 
  template<int> 
:gcc的函数模板不许无参数，加了个占位的"int"才能通过 
   result_type operator()() 
  { 
   if(m_pObject) 
    return (m_pObject->*m_pmf)(); 
   else 
    return m_pf(); 
  } 
  template<typename AT> 
   result_type operator()( 
   AT a1 
   ) 
  { 
   if(m_pObject) 
    return (m_pObject->*m_pmf)(a1); 
   else 
    return m_pf(a1); 
  } 
  template<typename AT1, typename AT2> 
   result_type operator()( 
   AT1 a1, 
   AT2 a2 
   ) 

{ 
   if(m_pObject) 
    return (m_pObject->*m_pmf)(a1,a2); 
   else 
    return m_pf(a1,a2); 
  } 
  template<typename AT1, typename AT2, typename AT3> 
   result_type operator()( 
   AT1 a1, 
   AT2 a2, 
   AT3 a3 
   ) 
  { 
   if(m_pObject) 
    return (m_pObject->*m_pmf)(a1,a2,a3); 
   else 
    return m_pf(a1,a2,a3); 
  } 
}; 
int gf(int) 
{ 
 return 0; 
} 
class Test 
{ 
public: 
 int f(int){return 0;} 
}; 
typedef delegate < int (*)(int) > my_delegate; 
int main() 
{ 
 Test t;

 my_delegate d1=&gf; // 普通函数
 my_delegate d2=my_delegate(t,&Test::f); //对象和类成员函数
 d1(0); //调用
 d2(2); 
}

2.一个简单的资源高速缓存管理器
    下面我将向你展示一个比较简单的资源高速缓存管理器，源代码来自我上一个游戏，如果你需要知道更多关于资源高速缓存方面的知识，请参考<<Game Coding Complete>>的第八章。
首先，需要一个机制来唯一标识一个资源，我们用下面这个结构来做资源句柄：
struct ResHandle
{
     ResHandle(std::string &resName, void *buffer, int size)
     {
         m_resName = resName;
         m_size   = size;
         m_buffer = buffer;
     }

     ~ResHandle()
     {
         if (m_buffer != 0) delete[] m_buffer;
     }

     std::string   m_resName;    //资源名
     void          *m_buffer;    //资源句柄所标识的资源
     DWORD         m_size;       //资源所占内存大小

};

好了，现在我们可以从资源名来找出这个资源了，接下来实现这个资源高速缓存管理器：
class CacheManager
{
public:
     CacheManager();
     ~CacheManager();

     //载入资源，resName为资源名，若载入成功size被设为该资源的大小
    //注意，管理中的资源不能在管理器外用delete显示的删除它
    void*    Load(std::string resName, DWORD *size = 0);
    //设置缓存大小，单位MB
     void      SetCacheSize(int sizeMB)    { m_cacheSize = sizeMB * 1024 * 1024; }
     //得到缓存大小，单位MB
     int      GetCacheSize()              { return m_cacheSize / 1024 /1024; }

private:
     void     Free();                          //释放lru链表中最后一个资源
     void     *Update(ResHandle *res);         //更新lru链表
     ResHandle *Find(std::string &resName);     //找出该资源名的资源句柄

private:
     DWORD m_cacheSize;     //缓存大小
     DWORD m_allocated;     //已使用的缓存大小

//lru链表，记录最近被使用过的资源
     std::list<ResHandle*>                m_lru;  
    //资源标识映射
     std::map<std::string, ResHandle*>    m_resources;

};

CacheManager:: CacheManager ()
{
     m_cacheSize = 0;
     m_allocated = 0;

}

CacheManager::~ CacheManager ()
{
          while (!m_lru.empty()) Free();   //释放所有管理中的资源

}

void * CacheManager::Load(std::string resName, DWORD *size)
{
     ResHandle *handle = Find(resName);   //查找该资源是否在缓存中

     if (handle != 0) //如果找到该资源句柄，则返回该资源并更新lru链表
     {
         if (size != 0) *size = handle->m_size;
         return Update(handle);
     }
     else
     {
         //先检测资源大小
         DWORD _size = 资源大小;

         //是否有足够空间?
         while (_size > (m_cacheSize - m_allocated))
         {
              if (m_lru.empty()) break;
              Free();
         }
         m_allocated += _size;

         buffer = new char[_size];
//在这里用任何你能想到的办法载入资源文件到buffer
         …
         …

//记录当前资源
         ResHandle *handle = new ResHandle(resName, buffer, _size);
         m_lru.push_front(handle);
         m_resources[resName] = handle;

         if (size != 0) *size = _size;
         return buffer;
     }

     return 0;

}

void CacheManager::Free()
{
     std::list<ResHandle*>::iterator gonner = m_lru.end();
     gonner--;
     ResHandle *handle = *gonner;
     m_lru.pop_back();
     m_resources.erase(handle->m_resName);
     m_allocated -= handle->m_size;
     delete handle;

}

void * CacheManager::Update(ResHandle *res)
{
     m_lru.remove(res);
     m_lru.push_front(res);
     m_size = res->m_size;
     return res->m_buffer;

}

ResHandle * CacheManager::Find(std::string &resName)
{
     std::map<std::string, ResHandle*>::iterator it = m_resources.find(resName);
     if (it == m_resources.end()) return 0;
     return (*it).second;

}

至此，你已经可以在游戏中缓存任何你想缓存的资源了^_^

3. 资源管理进阶
    至此你已经可以在游戏中缓存任何你想缓存的资源了，但是你的任务还没完成，当你请求的资源存在于缓存之外时，那个闪耀的硬盘灯可能就是玩家最感兴趣的东西了。
因此你必须根据不同的游戏类型使用不同的载入方式： 
    一次载入所有东西：适用于任何以界面或关卡切换的游戏 
    只在关键点载入资源：很多射击游戏都使用这样的设计，如“半条命” 
    持续载入：适用于开放型地图的游戏，如“侠盗猎车手”
    如果有可能的话，你还可以使用缓存预测机制，当CPU有额外时间的时候可以把未来可能用到的资源载入到资源高速缓存。
    最后，尽管在游戏的资源管理中资源打包不是必须的，但仍然建议大家把资源文件按类型分别打包到单一的文件中，这将为你节省磁盘空间，并加快游戏的载入速度。

现代游戏已经不能没有声音，所以音频引擎成为游戏引擎中不可缺少的一部分．这是一篇介绍现代音频引擎的文章(http://hard.zol.com.cn/labs/2003/0520/60986.shtml)．FMOD音频引擎(http://www.fmod.org)是一个非常不错的音频引擎，其使用也比较简单，下面做一些简单介绍：
一．基本准备
它是免费的，你可以从它们的主站上下载API等文件．之后，你需要添加头文件和库文件，如下（C/C++）：

      cache 和 buffer的区别:
      Cache： 高速缓存,是位于CPU与主内存间的一种容量较小但速度很高的存储器。由于CPU的速度远高于主内存，CPU直接从内存中存取数据要等待一定时间周期， Cache中保存着CPU刚用过或循环使用的一部分数据，当CPU再次使用该部分数据时可从Cache中直接调用,这样就减少了CPU的等待时间,提高了 系统的效率。Cache又分为一级Cache(L1 Cache)和二级Cache(L2 Cache)，L1 Cache集成在CPU内部，L2 Cache早期一般是焊在主板上,现在也都集成在CPU内部，常见的容量有256KB或512KB L2 Cache。
 　Buffer：缓冲区，一个用于存储速度不同步的设备或优先级不同的设备之间传输数据的区域。通过缓冲区，可以使进程之间的相互等待变少，从而使从速度慢的设备读入数据时，速度快的设备的操作进程不发生间断。

顾名思义，按位运算符允许按照位来操作整型变量。可以把按位运算符应用于任意signed和unsigned整型，包括char类型。但是，它们通常应用于不带符号的整型。

这些运算符的一个常见应用是在整型变量中使用单个的位存储信息。例如标记，它用于描述二进制状态指示符。可以使用一个位来描述有两个状态的值：开或关、男或女，真或假。

也可以使用按位运算符处理存储在一个变量中的几个信息项。例如，颜色值常常记录为三个八位值，分别存储颜色中红、绿和蓝的强度。这些常常保存到四字 节变量中的三个字节。第四个字节也不会浪费，包含表示颜色透明度的值。显然，要处理各个颜色成分，需要从变量中分离出各个字节，按位运算符就可以做到这一 点。

再看另外一个例子，假定需要记录字体的信息，那么，只要存储每种字体的样式和字号，以及字体是黑体还是斜体，就可以把这些信息都存储在一个二字节的整型变量中，如图3-1所示。

图3-1 把字体数据存储在2个字节中

可以使用一位来记录字体是否为斜体—— 1表示斜体，0表示一般。同样，用另一位来指定字体是否为黑体。使用一个字节可以从多达256种不同的样式中选择一个，再用另外5位记录最多32磅的字 号。因此，在一个16位的字中，可以记录四个不同的数据项。按位运算符提供了访问和修改整数中单个位和一组位的便利方式，能方便地组合和分解一个16位的 字。

3.3.1 移位运算符

移位运算符可以把整型变量中的内容向左或向右移动指定的位数。移位运算符和其他按位运算符一起使用，可以获得前面描述的结果。>>运算符把位向右移动，<<运算符把位向左移动，移出变量两端的位被舍弃。

所有的按位操作都可以处理任何类型的整数，但本章的例子使用16位的变量，使例子较为简单。用下面的语句声明并初始化一个变量number：

unsigned short number=16387U;

如第2章所述，不带符号的字面量应在数字的最后添加字母U或u。

在下面的语句中，对这个变量的内容进行移位，并存储结果：

unsigned short result = number <<2; //Shift left two bit positions

移位运算符的左操作数是要移位的值，右操作数指定要移动的位数。图3-2列出了该操作的过程。

图3-2 移位运算

从图3-2可以看出，把数值16387向左移动两位，得到数值12。数值的这种剧烈变化是舍弃高位数字的结果。

把数值向右移动，可以使用下面的语句：

result = number >>2; //Shift right two bit positions

把数值16387向右移动两位，得到数值4096。向右移动两位相当于使该数值除以4。

只要没有舍弃位，向左移动n位就相当于把该数值乘以2的n次方。换言之，就等于把该数值乘以2ⁿ。同样，向右移动n位就相当 于把该数值除以2的n次方。但要注意，变量number向左移位时，如果舍弃了重要的位，结果就不是我们希望的那样了。可是，这与乘法运算并没有不同。如 果把2字节的数值乘以4，就会得到相同的结果，所以向左移位和相乘仍是等价的。出现问题的原因是相乘的结果超出了2字节整数的取值范围。

如果需要修改原来的值，可以使用op= 赋值运算符。在这种情况下，可以使用>>=或<<=运算符。例如：

number >>= 2; // Shift contents of number two positions to the right

这等价于：

number =number >> 2; // Shift contents of number two positions to the right

这些移位运算符跟前面用于输入输出的插入和提取运算符有可能搞混。从编译器的角度来看，其含义一般可以从上下文中判断出来。否则，编译器就会生成一个消息，但用户需要非常小心。例如，如果输出变量number向左移动两位的结果，就应编写下面的代码：

cout << (number << 2);

其中，括号是必不可少的。没有括号，编译器就会把移位运算符解释为流插入运算符，从而得不到想要的结果。

按位移动带符号的整数

可以把移位运算符应用于带符号和不带符号的整型数。但是，向右移位运算符在带符号整数类型的操作随系统的不同而不同，这取决于编译器的实现。在一些情况下，向右移位运算符会在左边空出来的位上填充0。在其他情况下，符号位向右移动，在左边空出来的位上填充1。

移动符号位的原因是为了保持向右移位和除法运算的一致性。可以用char类型的变量来说明这一点，解释其工作原理。假定把value定义为char类型，其初始值为–104(十进制)：

signed char value=–104;

其二进制表示为10011000。使用下面的操作把它向右移动两位：

value >>= 2; //Result 11100110

注释中显示了其二进制结果。右边溢出了两个0，因为符号位是1，就在左边空出来的位上填充1。该结果的十进制表示是–26，这正好是value的值除以4的结果。当然，对于不带符号的整数类型的操作，符号位不移动，在左边空出来的位上填充0。

前面说过，在向右移位负整数时，其操作是已定义好的，所以实现该操作时不一定要依赖它。因为在大多数情况下，使用这些运算符是为了进行按位操作，此时维护位模式的完整性是非常重要的。所以，应总是使用不带符号的整数，以确保避免高阶位的移位。

3.3.2 位模式下的逻辑运算

修改整数值中的位时，可以使用4个按位运算符，如表3-1所示。

表3-1 按位运算符

表3-1中的运算符按照其优先级排列，在这个集合中，按位求反运算符的优先级最高，按位或运算符的优先级最低。在附录D的运算符优先级表中，按位移动运算符<<和>>具有相同的优先级，它们位于～运算符的下面，&运算符的上面。

如果以前没有见过这些运算符，就会问“这非常有趣，但这是为什么？”。下面就将它们用于实践。

1. 使用按位与运算符

按位与运算符一般用于选择整数值中特定的一个位或一组位。为了说明这句话的含义，下面再次使用本节开头的例子，利用一个16位整数存储字体的特性。

假定声明并初始化一个变量，指定一种12磅字号、斜体、样式为6的字体。实际上，就是图3-1中的字体。样式的二进制值是00000110，斜体位 是1，黑体位是0，字号是01100。还有一个没有使用的位，需要把font变量的值初始化为二进制数0000 0110 0100 1100。

由于4位二进制数对应于一个16进制数，因此最简单的方法是以十六进制方式指定初 始值：

unsigned short font=0x064C; // Style 6, italic, 12 point

注释：

在建立像这样的位模式时，十六进制表示法要比十进制表示法更合适。

要使用字号，需要从font变量中提取它，这可以使用按位与运算符来实现。只有当两个位都是1时，按位与运算符才会产生1，所以可以定义一个值，在 将定义字号的位和font执行按位与操作时选择该位。为此，只需定义一个值，该值在我们感兴趣的位上包含1，在其他位上包含0。这种值称为掩码，用下面的 语句定义它：

unsigned short size_mask=0x1F; //Mask is 0000 0000 0001 1111

//to select size

font变量的5个低位表示其字号，把这些位设置为1，剩余的位设置为0，这样它们就会被舍弃(二进制数0000 0000 0001 1111可转换为十六进制数1F)。

现在可以用下面的语句提取font中的字号了：

unsigned short size=font & size_mask;

在&操作中，当两个对应的位是1时，结果位就是1。任何其他组合起来的结果就是0。因此组合起来的值如下：

font 0000 0110 0100 1100

size_mask 0000 0000 0001 1111

font & size_mask 0000 0000 0000 1100

把二进制值分解为4位一组的形式并不是很重要，这只是易于表示对应的十六进制数，看出其中有多少位。掩码的作用是把最右边的5位分隔出来，这5位表示点数(即字号)。

可以使用同样的方法选择字体的样式，只是还需要使用按位移动运算符把样式值向右移动。可以用下面的语句定义一个掩码，选择左边的8位，如下所示：

unsigned short style_mask=0xFF00; //Mask is 1111 1111 0000 0000

//for style

用下面的语句获取样式值：

unsigned short style＝(font & style_mask) >> 8; //Extract the style

该语句的结果如下：

font 0000 0110 0100 1100

style_mask 1111 1111 0000 0000

font & style_mask 0000 0110 0000 0000

(font & style_mask) >> 8 0000 0000 0000 0110

为表示斜体和黑体的位定义掩码，并把相应的位设置为1，就很容易把它们分隔出来。当然，还需要一种方式来测试得到的位，这部分内容详见第4章。

按位与运算符的另一个用途是关闭位。前面介绍的是掩码中为0的位在结果中也将输出0。例如，为了关闭表示斜体的位，其他的位不变，只需定义一个掩 码，使该掩码中的斜体位为0，其他位为1，再对font变量和该掩码进行按位与操作即可。实现此操作的代码将在按位或运算符一节中介绍。

2. 使用按位或运算符

可以使用按位或运算符设置一个或多个位。继续操作前面的font变量，现在需要设置斜体和黑体位。用下面的语句可以定义掩码，选择这些位：

unsigned short italic=0x40U; //Seventh bit from the right

unsigned short bold=0x20U; //Sixth bit from the right

用下面的语句设置黑体位：

font |= bold; // Set bold

位的组合如下：

font 0000 0110 0100 1100

bold 0000 0000 0010 0000

font | bold 0000 0110 0110 1100

现在，font变量指定它表示的字体是黑体和斜体。注意这个操作会设置位，而不考虑以前的状态。如果以前位的状态是开，则现在仍保持开的状态。

也可以对掩码执行按位或操作，设置多个位。下面的语句就同时设置了黑体和斜体：

font |= bold | italic; //Set bold and italic

该语言很容易让人选择错误的运算符。“设置斜体和黑体”很容易让人觉得应使用&运算符，而这是错误的。对两个掩码执行按位与操作会得到一个所有位都是0的值，这不会改变字体的任何属性。

如上一节最后所述，可以使用&运算符关闭位。也就是定义一个掩码，把其中要关闭的位设置为0，其他位设置为1。但如何指定这样的掩码？如果 要显式指定它，就需要知道变量中有多少个字节，如果希望程序可以任何方式移植，这就不很方便。可是，在通常用于打开位的掩码上使用按位求反运算符，就可以 得到这样的掩码。在bold掩码上关闭黑体位，就可以得到该掩码：

bold 0000 0000 0010 0000

~bold 1111 1111 1101 1111

按位求反运算符的作用是反转原数值中的每一位，使0变成1，1变成0。无论bold变量占用2个字节、4个字节还是8个字节，这都会生成我们期望的结果。

提示：

按位求反运算符有时称为NOT运算符，因为对于它操作的每个位，都会得到跟开始不同的值。

因此，在关闭黑体位时，只需对掩码bold的反码和font变量执行按位与操作，可用的语句如下所示：

font &= ~bold; //Turn bold off

还可以使用&运算符把几个掩码组合起来，再对结果跟要修改的变量执行按位与操作，将多个位设置为0。例如：

font &= ~bold & ~italic; //Turn bold and italic off

这个语句把font变量中的斜体和黑体位设置为0。注意这里不需要括号，因为~运算符的优先级高于&运算符。但是，如果不清楚运算符的优先级，就应加上括号，表示希望执行的操作。这肯定是无害的，在需要括号时还可以正常发挥作用。

3. 使用按位异或运算符

按位异或运算符的使用频率远远低于&和 | 运算符，有关它的使用例子也比较少。但它的一个重要应用是图形编程。在屏幕中创建动画的一种方式是绘制一个对象，删除它，再在一个新位置重新绘制。如果要 求动画很平滑，这个过程就需要重复得很快，其中删除是一个重要的部分。我们并不想删除和重新绘制整个屏幕，因为这非常费时，屏幕也会出现闪烁。最理想的 是，只删除屏幕上要移动的对象。使用所谓的异或模式就可以做到这一点，得到非常平滑的 动画。

异或模式的理念是，在屏幕上用给定的颜色绘制对象，如果接着用背景色重新绘制它，它就会消失。如图3-3所示。

图3-3 用异或模式绘图

以异或模式在屏幕上绘制对象时，每次绘制对象的颜色会自动在为对象所选的颜色和背景色之间来回变化。得到这一效果的关键是使用按位异或运算符快速而 自动地改变颜色。它使用异或运算符的一个特性，即如果对两个值进行异或操作，再对所得的结果和一个原始值执行异或操作，就会得到另一个值。这听起来很复 杂，下面就用一个例子来说明。

假定要在前景色(这里使用红色)和背景色(白色)之间来回切换。颜色通常用3个8位值来表示，分别对应于红、蓝、绿的亮度，存储在一个4字节的整数 中。通过改变颜色中的红、蓝和绿的比例，就可以获得大约1600万种不同的颜色，包括从白色到黑色之间的所有颜色。纯红色是0xFF0000，这时红色成 分设置为其最大值，其他两种颜色即蓝色和绿色的成分设置为0。在相同颜色模式下，绿色就是0xFF00，蓝色是0xFF。在白色中，红、蓝、绿的成分具有 相同的最大值，即0xFFFFFF。

可以用下面的语句定义表示红色和白色的变量：

unsigned long red=0XFF0000UL; //Color red

unsigned long white=0XFFFFFFUL; //Color white-RGB all maximum

接着创建一个掩码，用于在红色和白色之间来回切换，并把包含绘图颜色的变量初始化为红色：

unsigned long mask=red ^ white; //Mask for switching colors

unsigned long draw_color=red; //Drawing color

变量mask初始化为要切换的两种颜色的按位异或操作结果，因此：

red 1111 1111 0000 0000 0000 0000

white 1111 1111 1111 1111 1111 1111

mask(即red ^ white) 0000 0000 1111 1111 1111 1111

如果对mask和red执行异或操作，就会得到white，如果对mask和white执行异或操作，就会得到red。因此，使用draw_color中的颜色绘制对象，就可以通过下面的语句切换颜色：

draw_color ^= mask; //Switch the drawing color

当draw_color包含red时，其执行过程如下：

draw_color 1111 1111 0000 0000 0000 0000

mask 0000 0000 1111 1111 1111 1111

draw_color ^ mask 1111 1111 1111 1111 1111 1111

显然，draw_color的值从红色变为白色。再次执行这个语句，就会把颜色改回为红色：

draw_color^=mask; //Switch the drawing color

其执行过程如下：

draw_color 1111 1111 1111 1111 1111 1111

mask 0000 0000 1111 1111 1111 1111

draw_color ^ mask 1111 1111 0000 0000 0000 0000

draw_color又变成了红色。这个技术适用于任意两种颜色，当然它实际上与特定颜色没有一点关系，可以把它用于切换任意一对整型数值。

程序示例3.4—— 使用按位运算符

下面用一个例子来试验按位运算符，看看它们如何一起工作。本例还演示了如何使用异或运算符在两个值之间切换，以及如何使用掩码来选择和设置各个位。代码如下：

//Program 3.4 Using the bitwise operators

#include <iostream>

#include <iomanip>

using std::cout;

using std::endl;

using std::setfill;

using std::setw;

int main() {

unsigned long red=0xFF0000UL; //Color red

unsigned long white=0xFFFFFFUL; //Color white - RGB all maximum

cout << std::hex; //Set hexadecimal output format

cout << setfill('0'); //Set fill character for output

cout << "\nTry out bitwise AND and OR operators.";

cout << "\nInitial value red = "<< setw(8) << red;

cout << "\nComplement ~red = "<< setw(8) <<~ red;

cout << "\nInitial value white = "<< setw(8) << white;

cout << "\nComplement ~ white = "<< setw(8) <<~ white;

cout << "\n Bitwise AND red & white = " << setw(8) << (red & white);

cout << "\n Bitwise OR red | white = " << setw(8) << (red | white);

cout << "\n\nNow we can try out successive exclusive OR operations.";

unsigned long mask=red ^ white;

cout << "\n mask= red ^ white = " << setw(8) << mask;

cout << "\n mask ^ red = " << setw(8) << (mask ^ red);

cout << "\n mask ^ white = " << setw(8) << (mask ^ white);

unsigned long flags=0xFF; //Flags variable

unsigned long bit1mask=0x1; //Selects bit 1

unsigned long bit6mask=0x20; //Selects bit 6

unsigned long bit20mask=0x80000; //Selects bit 20

cout << "\n\nNow use masks to select or set a particular flag bit.";

cout << "\nSelect bit 1 from flags : " << setw(8) << (flags & bit1mask);

cout << "\nSelect bit 6 from flags : " << setw(8) << (flags & bit6mask);

cout << "\nSwitch off bit 6 in flags : " << setw(8) << (flags &= ~bit6mask);

cout << "\nSwitch on bit 20 in flags : " << setw(8) << (flags |= bit20mask);

cout <<endl;

return 0;

}

该例子的输出如下：

Try out bitwise AND and OR operators.

Initial value red = 00ff0000

Complement ~red = ff00ffff

Initial value white = 00ffffff

Complement ~ white = ff000000

Bitwise AND red & white = 00ff0000

Bitwise OR red | white = 00ffffff

Now we can try out successive exclusive OR operations.

mask= red ^ white =0000ffff

mask ^ red = 00ffffff

mask ^ white =00ff0000

Now use masks to select or set a particular flag bit.

Select bit 1 from flags : 00000001

Select bit 6 from flags : 00000020

Switch off bit 6 in flags : 000000df

Switch on bit 20 in flags : 000800df

例子的说明

本例中添加了对标准头文件<iomanip>的#include指令，这个头文件在第2章介绍过，因为代码将使用操纵程序控制输出的格式。首先，定义两个整数变量，它们包含的值表示要用于后续按位运算的颜色：

unsigned long red=0xFF0000UL; //Color red

unsigned long white=0xFFFFFFUL; //Color white - RGB all maximum

为了把数据显示为十六进制值，可用下面的语句指定：

cout << std::hex; //Set hexadecimal output format

其中hex是一个操纵程序，它把整数值的输出表示为十六进制。注意，这是模式化的，该程序以后在标准输出流中的所有整数输出都采用十六进制格式。不需要把hex发送给输出流cout。如果需要，可以用下面的语句把输出格式改回为十进制：

cout << std::dec; //Set decimal output format

这个语句使用dec操纵程序，把整数输出重新设置为默认的十进制表示。注意，把输出格式设置为十六进制，仅影响整数值。浮点数值会继续显示为一般的十进制。

如果在输出整数时加上前导0，就会使结果更清晰易懂。用下面的语句设置这种模式：

cout << setfill('0'); //Set fill character for output

其中setfill()是一个操纵程序，它把填充字符设置为括号中的字符。这也是模式化的，这样，以后的所有整数输出都会在需要时使用这个填充字符。它对十进制和十六进制输出都起作用。如果要用星号代替该填充字符，则可以使用下面的语句：

cout << setfill('*'); //Set fill character for output

要把填充字符设置回原来的默认值，只需在括号中使用空格：

cout << setfill(' '); //Set fill character for output

下面的语句显示red的值及其反码：

cout << "\nInitial value red = "<< setw(8) << red;

cout << "\nComplement ~red = "<< setw(8) <<~ red;

这里使用第2章介绍的setw()操纵程序，把输出字段宽度设置为8。如果所有的输出值都采用相同的字段宽度，就很容易比较它们。设置宽度不是模式化的，它只应用于跟在字段宽度设置点后面的下一条语句的输出。在red和white的输出中，～运算符反转了其操作数的位。

下面的语句使用按位与以及按位或运算符来合并red和white：

cout << "\n Bitwise AND red & white = " << setw(8) << (red & white);

cout << "\n Bitwise OR red | white = " << setw(8) << (red | white);

注意输出中表达式的括号。它们是必需的，因为<<的优先级高于&和|。没有括号，该语句就不会编译。如果查看一下输出，就会看 出它跟这里讨论的相同。若对两个值都为1的位执行按位与操作，就会得到1，否则结果就是0。在对两个位执行按位或操作时，除非两个位都是0，否则结果就是 1。

然后，创建一个掩码，在通过按位异或运算符组合两个值时，该掩码用于反转red和white的值。

unsigned long mask=red ^ white;

如果查看一下mask值的输出，就会发现在两个位的值不同时，对两个位执行异或操作的结果是1，在两个位的值相同时，该操作的结果是0。利用异或运算符把mask和两个颜色值中的一个组合起来，就会得到另一个颜色值。这可以用下面的语句来说明：

cout << "\n mask ^ red = " << setw(8) << (mask ^ red);

cout << "\n mask ^ white = " << setw(8) << (mask ^ white);

最后一组语句演示了如何使用掩码从一组标记位中选择一个位。选择某个位的掩码必须使该位的值为1，其他位的值为0。因此，从一个32位long变量中选择第1、6和20位的掩码定义如下：

unsigned long bit1mask=0x1; //Selects bit 1

unsigned long bit6mask=0x20; //Selects bit 6

unsigned long bit20mask=0x80000; //Selects bit 20

要从flags中选择一个位，只需对相应的掩码和flages的值执行按位与操作。例如：

cout << "\nSelect bit 6 from flags : " << setw(8) << (flags & bit6mask);

从输出中可以看到，表达式(flags & bit6mask)的结果是只设置了第6位的整数。当然，如果flages中的第6位为0，该表达式的结果就是0。

要关闭一个位，需要对flages变量和一个掩码执行按位与操作。在该掩码中，要关闭的那个位是0，其他位是1。对掩码和对应的位执行按位求反操作，也可以关闭该位。bit6mask就是这样的一个掩码。下面的语句把flags中的第6位关闭，并显示结果：

cout << "\nSwitch off bit 6 in flags : " << setw(8) << (flags &= ~bit6mask);

当然，如果第6位已经是0，该位就保持不变。要打开一个位，只需对flages和一个掩码执行按位或操作，在该掩码中，要打开的那个位是1：

cout << "\nSwitch on bit 20 in flags : " << setw(8) << (flags |= bit20mask);

这个语句把flags中的第20位设置为1，并显示结果。如果这个位已经是1，该位将保持不变。

4. 输出操纵程序

把第2章介绍的也算在内，到目前为止我们已介绍了5个模式化输出操纵程序，它们都是在<iostream>头文件中定义 的：scientific、fixed、dec、hex和oct。表3-2列出所有的其他相似的操纵程序。目前不介绍后两项中的bool值，它将在第4章 讨论。

表3-2 输出操纵程序

可以一次设置多种模式，方法是在流中插入多个操纵程序。例如，如果要把整型数据输出为十六进制值，且在输出字段中左对齐，就可以使用下面的语句：

std::cout << std::hex << std::left << value;

这个语句会把value(以及程序中后续的所有整数，除非改变了设置)输出为左对齐的十六进制数值。

表3-3列出了需要提供参数值的输出操纵程序。

表3-3 需要参数的输出操纵程序

  char 转换为 string 型
  char* str = "char 转换为 string 型";
  SendData.strSql = str;

//SendData.strSql 为std::string型

• 随笔 - 12
• 文章 - 5
• 评论 - 22
• 引用 - 0

常用链接

• 我的随笔
• 我的评论
• 我参与的随笔

留言簿(8)

• 给我留言
• 查看公开留言
• 查看私人留言

随笔分类

• C++学习资料(4) (rss)
• ICE FOR VC++6.0(4) (rss)
• ICE学习资料(4) (rss)

随笔档案

• 2006年11月 (1)
• 2006年9月 (1)
• 2006年4月 (2)
• 2006年2月 (2)
• 2005年12月 (6)

文章分类

• ICE中间件技术(3) (rss)

文章档案

• 2007年9月 (1)
• 2006年9月 (1)
• 2006年4月 (1)
• 2005年12月 (2)

搜索

最新评论

阅读排行榜

评论排行榜

• # re: std::string 与 char 类型的相互转换
  晕
  Posted @ 2006-06-17 17:18
  没有这个函数吧！大爷！！！我急啊！  回复  更多评论   
• # re: std::string 与 char 类型的相互转换
  偶尔看到
  Posted @ 2006-08-08 00:16
  补充一点，用完str后记得用free把内存释放，strdup会用malloc分配内存  回复  更多评论   
• # re: std::string 与 char 类型的相互转换
  haha
  Posted @ 2006-08-13 01:42
  @偶尔看到
  对头,应该在最后还加个这个语句
  delete str;//str即通过这个char* str = strdup ( SendData.strSql.c_str() );
  得到的指针
  
  不过在C++中最好不要用char 型变量,在大型项目中很容易引起内在溢出或者指针越界,应该尽量用string
    回复  更多评论   
• # re: std::string 与 char 类型的相互转换
  企业即时通讯
  Posted @ 2008-06-12 15:03
  不过在C++中最好不要用char 型变量,在大型项目中很容易引起内在溢出或者指针越界,应该尽量用string   回复  更多评论   
• # re: std::string 与 char 类型的相互转换
  luyu
  Posted @ 2008-07-17 11:16
  
  char* str = strdup ( SendData.strSql.c_str() );太好了，可以将const *转化为char *  回复  更多评论  
  

教你使用正则表达式

下载源代码

很久没有VCKbase发表文章了，这次发表一些比较基础的文章吧！看过"保证你现在和未来不失业的十种关键技术"这篇文章了吧，这次我就拿出一个不会让你失业的编程技术讲讲吧，老虾们千万不要拿鸡蛋砸我，我只是写给初学者的！
关于正则表达式的教程和用法网上有很多的资源，基本的用法我讲了也是浪费你的眼力，所以我会以一个实例来教你学习正则表达式，我两年前做的一个MIS 中使用过正则式，检验用户输入的日期是否为正确的日期格式！分析完这个正则表达式后，对于正则表达式你绝对会有一个深深的认识！但是还不能说你精通，当你 可能用正则表达式写一个编译器的时候，你就可以精通了!
“磨刀不误砍柴工”，要使用正则表达式，我们还要使用支持正则表达式的语言，解释性语言Ruby,Perl,Python等都支持正则表达 式，C#,Java,VB.net等也支持正则表达式，C++还需要第三方类库才能支持，VC.net提供了一个很好的正则表达式类库 CATLRegExp(全世界效率最高的正则表达式库哦)，可是却不能在VC6上使用，要在VC6上使用，可以使用VBS(Microsoft VBScript Regular Expression 5.5)来处理正则表达式，这是一个COM,拿一个COM来用我还是情愿用Boost库.

使用Boost库的时候，你需要编译库后你才能使用，不过这很容易。
1.下载Boost库
3.设定环境变量(以我本机的环境变量设定为例)





2.进入 boost_1_32_0\libs\regex\build 目录中，你可以看到vc6.mak文件 nmake vc6.mak就可以了，跟着会产生lib和dll文件，把它拷贝到你的程序目录下就可使用了!

你也可以全部编译，不过我只需要正则表达式库，所以我只编译这部分!

好了，砍柴刀磨好了！我们就开始正则表达式的实践吧!

当时我负责的MIS是医院的一个血液检验输入模块，要求输入的日期必须是合法的，这是第一要求，不然检验单就会报废。输入日期是可以 2006.04.02 或 2006/04/02 或 2006.4.2 或 2006/4/2 的格式，而且日期还是要合法的，比如说不可以出现 2006.02.31, 2006.4.41 这样的日期，不排除输入人员工作繁记忙输入错误会出现这种情况。
好了，用正则表达式如何解决这个问题，首先正则表达式是一个对文本匹配模式的使用方法，记得正则表达式的关键字用法是没有用的，各种语言的正则表达式中的关键字用法是不同的，要认识文本中字符的模式.比如说对以上日期的表示可以用正则表达式表示为
"^\\d{4}[\\s\\.-/]\\d{1,2}[\\s\\.-/]\\d{1,2}$" 但这是完全错误的，用文字对这句正则表达式的描述为字符串是由三组数字组成，每一组由四个数组成,第二和第三组由一个或两个数字组成,中间带有空格 或"/",4003.9/12,3344.0.40 都会被判为合法的字符,这就是错误的用法！有什么或以判别呢!
有闰日的年份叫闰年，一般年份365天，闰年为366天(二月则有29天),闰年的计算方法：公元纪年的年数可以被四整除，即为闰年；被100整除而 不能被400整除为平年；被100整除也可被400整除的为闰年.则这样我们可以这样设计正则表达式，第一个是要求其格式统一，第二个是要求其能正确表达 闰年！1000/2/29 合法, 2000/2/29 合法，1900/2/29 非法.
想一想,一年中不论闰年或平年有的月份都是固定的，1，3，5，7，8，10，12月都是 31天, 4, 6, 9, 11 月都是30 天, 2 月可能为 28 或 29天,我们则可以这样判断,除 2 月外, 1 到 12 月中日期为 29, 30 天内的都为合法，1，3，5，7，8，10，12月为31天的都为合法, 1 月到 12 月为 28 天的都为合法, 剩下的只要判断当年是否为闰年就行了，是闰年 2月29日就合法，否则非法!!!
呵，结果就出来了，用"或"把三条正则表达式组合起来就行了,第一条是判断除2月外日期的表达式，第二条是1到12 月都是1-28天的表达式,最后一条是判断是否闰年及合法2月的表达式,若符合其中一条的都为正确的日期.

第一条可以这样写除 2 月外 1 到 12 月都为 30 天的表达式为 (?:0?[1,3-9]|1[0-2])-(?:29|30)

除2 月外 1，3，5，7，8，10，12月都是 31天, ((?:0?[13578]|1[02])-31), 两条合并起来就是：
(??:0?[1,3-9]|1[0-2])-(?:29|30)|((?:0?[13578]|1[02])-31)) 第二条可以这样写 (?:0?[1-9]|1[0-2])-(?:0?[1-9]|1\d|2[0-8])

第三条表达式就是要求表示闰年了，能被4 整除的四位数是怎么组成的呢? 可以看出,四位数中最后两位能被四整除都可以得出这个四位数能被4整除,100内为4的倍数的值为 04,08,12,16,20,24,28,32,36，40，44，48，52，56，60，64，68，72，76，80，84，88，92，96, 能被100与400整除的四位数则可以为##00的形式了
则这样的闰年判别可以为：
(\d\d(?:0[48]|[2468][048]|[13579][26]))与 (?:0[48]00|[2468][048]00|[13579][26]00)合并后再加入2月日期合并为：
((?\d\d(?:0[48]|[2468][048]|[13579][26]))|(?:0[48]00|[2468][048]00|[13579][26]00))-0?2-29) 　　这样就可得出一条正确的表达式了：
^(?[0-9] {4}-(?:(?:0?[1,3-9]|1[0-2])-(?:29|30)|((?:0?[13578]|1[02])-31)))|([0-9] {4}-(?:0?[1-9]|1[0-2])-(?:0?[1-9]|1\d|2[0-8]))|(((?:(\d\d(?:0[48]|[2468] [048]|[13579][26]))|(?:0[48]00|[2468][048]00|[13579][26]00))-0?2-29)))$ 这条表达式匹配的日期为2004-02-29,2004-2-29,不匹配2007-2-29,格式固定为####-##-##,只有输入日期正确了 才会匹配。



这样就完成一条正则表达式了，不要被吓倒，当你对正则表达式理解越深刻的时候，你才发现它的优美!

在平时的工作中，你可以把一些常用的正则表达式封装成dll，当使用的时候，你可以方便地调用，提高你的效率！
这儿我顺便给出一些常用的正则表达!

合法Email的表达式
^([a-zA-Z0-9_\-])([a-zA-Z0-9_\-\.]*)@(\[((25[0-5]|2[0-4][0-9]|1[0-9] [0-9]|[1-9][0-9]|[0-9])\.){3}|((([a-zA-Z0-9\-]+)\.)+))([a-zA-Z]{2,}| (25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\])$ 合法时间表示表达式[1:00 AM], [12:00 PM], [1:00am]
^(1|01|2|02|3|03|4|04|5|05|6|06|7|07|8|08|9|09|10|11|12{1,2}):(([0-5]{1}[0-9]{1}\s{0,1})([AM|PM|am|pm]{2,2}))\W{0}$ 网站连接：
[http://207.68.172.254/home.ashx], [ftp://ftp.netscape.com/], [https://www.brinkster.com/login.asp] ^((https?|ftp)\://((\[?(\d{1,3}\.){3}\d{1,3}\]?)|(([-a-zA-Z0-9]+\.)+[a-zA-Z]{2,4}))(\:\d+)?(/[-a-zA-Z0-9._?,''+&%$#=~\\]+)*/?)$

标准c++中主要有四种强制转换类型运算符：     

const_cast，reinterpret_cast，static_cast，dynamic_cast等等。   

1）static_cast<T*>(a)   

将地址a转换成类型T，T和a必须是指针、引用、算术类型或枚举类型。   

表达式static_cast<T*>(a), a的值转换为模板中指定的类型T。在运行时转换过程中，不进行类型检查来确保转换的安全性。   

例子：   

class B {  };   

class D : public B {  };   

void f(B* pb, D* pd)   

{    

   D* pd2 = static_cast<D*>(pb);        // 不安全, pb可能只是B的指针   

   B* pb2 = static_cast<B*>(pd);        // 安全的   
    
} 

2）dynamic_cast<T*>(a)   

完成类层次结构中的提升。T必须是一个指针、引用或无类型的指针。a必须是决定一个指针或引用的表达式。   

表达式dynamic_cast<T*>(a) 将a值转换为类型为T的对象指针。如果类型T不是a的某个基类型，该操作将返回一个空指针。   

例子：   

class A {  };   

class B {  };    

void f()   

{   

  A* pa = new A;   

  B* pb = new B;   

  void* pv = dynamic_cast<A*>(pa);   

  // pv 现在指向了一个类型为A的对象   
   

  pv = dynamic_cast<B*>(pb);   

  // pv 现在指向了一个类型为B的对象   

}  

3）const_cast<T*>(a)   

去掉类型中的常量，除了const或不稳定的变址数，T和a必须是相同的类型。   

表达式const_cast<T*>(a)被用于从一个类中去除以下这些属性：const, volatile, 和 __unaligned。   

例子：   

class A {  };   

void f()   

{   

 const A *pa = new A;//const对象   

 A *pb;//非const对象   

//pb = pa; // 这里将出错，不能将const对象指针赋值给非const对象   

 pb = const_cast<A*>(pa); // 现在OK了   

..   }  

4）reinterpret_cast<T*>(a)   

任何指针都可以转换成其它类型的指针，T必须是一个指针、引用、算术类型、指向函数的指针或指向一个类成员的指针。   

表达式reinterpret_cast<T*>(a)能够用于诸如char* 到 int*，或者One_class* 到 Unrelated_class*等类似这样的转换，因此可能是不安全的。   

例子：   

class A {  };   

class B {  };   

void f()   

{   

  A* pa = new A;   

  void* pv = reinterpret_cast<A*>(pa);   

  // pv 现在指向了一个类型为B的对象，这可能是不安全的   

     

}  

 
本文转自http://www.libing.net.cn/read.php?520

我以前写线程时要么老老实实照着声明写,要么使用C++类的静态成员函数来作为回调函数,经常会因为线程代码而破坏封装.之前虽然知道类成员函数的展开形式，但从没想过利用过它，昨天看深入ATL时无意中学会了这一招:) 

类成员方法是一个比较特殊的函数，它在编译时会被转化成普通函数，比如有TMyClass类:
class TMyClass{
    void Func();
};

这个TMyClass::Func最终会转化成 void Func(TMyClass *this); 也就是说在原第一个参数前插入指向对象本身的this指针。

我们可以利用这个特性写一个非静态类成员方法来直接作为线程回调函数，先看_beginthread函数的定义:
unsigned long _RTLENTRY _EXPFUNC _beginthread (void (_USERENTRY *__start)(void *),unsigned __stksize, void *__arg);
其中的第一个参数就是作为线程执行主体的回调函数。它的原型是:void Func(void *)，这个void*参数是作为自定义数据传入的。对比一下上面所说的TMyClass::Func的最终形式，它正好可以符合这里的要求。

现在做个实验:
#include <stdio.h>
#include <process.h>

class TMyClass{
    int m_nCount;
    int m_nId;
public:
    TMyClass(int nId,int nCount)
        :m_nId(nId),m_nCount(nCount)
    {
    }

    void _USERENTRY ThreadProc()            // 类成员方法
    {
        for(int i=0; i<m_nCount; i++)       // 根据m_nCount成员打印一排数字
        {
            printf("Class%d : %d\n",m_nId,i);
        }
    }
};

int main(int argc, char* argv[])
{
    union {                                // 联合类，用于转换类成员方法指针到普通函数指针（试过编译器不允许在这两种函数之间强制转换），不知道有没有更好的方法。
        void (_USERENTRY *ThreadProc)(void *);
        void (_USERENTRY TMyClass::*MemberProc)();
    } Proc;                                // 尽管联合里的两种函数类型现在看起来有很大不同，但它们的最终形式是相同的。

    TMyClass MyClass1(1,10),MyClass2(2,5); // 产生两个TMyClass对象

    Proc.MemberProc = &TMyClass::ThreadProc;   // 转换，Proc.ThreadProc就是对应的普通函数指针了

    _beginthread(Proc.ThreadProc,4096,&MyClass1);   // 开始线程，这里的Proc.ThreadProc实际上是TMyClass::ThreadProc, 它要的this指针是我们给的&MyClass1。
    _beginthread(Proc.ThreadProc,4096,&MyClass2);
    system("pause");
    return 0;
}

运行！神奇吧？:-)

其实不止线程回调函数，其实只要是形如Func(void*,...)的回调函数都可以用这种方法直接使用类成员方法。(前提是第一个void*是自定义数据，也就是说它不能有其它功能)。

转自:http://blog.csdn.net/waiting4you/archive/2007/12/29/2000796.aspx