Thunk的原理其实说起来很简单：巧妙的将数据段的几个字节的数据设为特殊的值，然后告诉系统，这几个字节的数据是代码（即将一个函数指针指向这几个字节的第一个字节），让系统来执行。

让API回调成员函数：

直接用成员函数的地址传给作为API的回调函数显然会编译出错的，原因是他们的调用规则不一致，C++编译器不允许这样做。具体可以参考：

http://hi.baidu.com/shongbee2/blog/item/7867de9744e3c26155fb9611.html

而刚好THUNK技术就是让数据段当做代码断用，如果我把回调函数地址用一个数据段给他，然后在数据段中再跳转到成员函数的地址。这样就可以间接的调用成员函数了。不错，我就是学习的这个方法。嘻嘻。。

大致方向知道了，还得了解一下细节，函数调用的规则：

建议看一下http://hi.baidu.com/shongbee2/blog/item/7867de9744e3c26155fb9611.html（也就是上一篇文章啦。）需要注意的：调用者怎么处理栈，被调用者怎么使用栈和处理栈。系统回调函数基本上都是_stdcall的调用方式，成员函数是__thiscall的调用方式。他们的区别为：

发现他们唯一不同的就是__thiscall把this指针保存到了ECX的寄存器中。其他都是一样的。这种情况我们就方便了，我们只需在他调用我们的时候，我们吧this指针保存到ECX，然后跳转到期望的成员函数地址就可以了。

//我认为思路就是这样了。接下来是实现，贴源代码：

#include "stdafx.h"
#include "wtypes.h"

#include <iostream>
using namespace std;

typedef void (*FUNC)(DWORD dwThis);
typedef int (_stdcall *FUNC1)(int a, int b);
#pragma pack(push,1)
typedef struct tagTHUNK
{
    BYTE    bMovEcx;   //MOVE ECX 将this指针移动到ECX的指令
    DWORD    dwThis;   // this   this指针的地址
    BYTE    bJmp;    //jmp   跳转指令
    DWORD    dwRealProc; //proc offset 跳转偏移

    void Init(DWORD proc,void* pThis)
    {
   bMovEcx = 0xB9;        //注释见下面说明^_^
        dwThis = (DWORD)pThis;
        bJmp = 0xE9;
        dwRealProc = DWORD((INT_PTR)proc - ((INT_PTR)this+sizeof(THUNK)));
        FlushInstructionCache(GetCurrentProcess(),this,sizeof(THUNK));
    }
}THUNK;
#pragma pack(pop)
/**************************************************************************************
void Init(DWORD proc,void* pThis)里面的说明：
0xB9 为MOVE ECX的指令， 0xE9 跳转的指令，这段初始化表示：
0013FF54 mov         ecx, ptr [this]
0013FF59 jmp         dwRealProc
这个单步一下便知。
下面那个API ：FlushInstructionCache，查MSDN，表示刷新缓存，
因为我们修改了数据，建议他重新载入一下。

我最不能理解的是jmp的偏移是为什么是那样计算，所以这里也着重说明一下：
jmp跳转的是当前指令地址的偏移，我们参数中proc是实际函数的地址，我们需要
把他转为jmp的偏移: 实际函数地址-jmp指令地址。
实际函数地址就是proc,jmp地址就是((INT_PTR)this+sizeof(THUNK))，所以就得到
dwRealProc = DWORD((INT_PTR)proc - ((INT_PTR)this+sizeof(THUNK)));这行代码
还有一点，我对汇编不了解，下面是YY：为什么不是：
dwRealProc = DWORD((INT_PTR)proc - ((INT_PTR)this+sizeof(THUNK)) - sizeof(dwRealProc))
直观上看jmp地址不是：this + sizeof(bMoveEcx) + sizeof(dwThis) + sizeof(bJmp)吗？
也就是((INT_PTR)this+sizeof(THUNK)) - sizeof(dwRealProc) 啊。可是我看了一下编译的结果，
发现0013FF59 jmp         dwRealProc 是一行的，也就是jmp地址实际就是:
((INT_PTR)this+sizeof(THUNK)) 这个地址。经过测试也没有问题，我就认为是这样了，不对的还
忘多指出。嘻嘻。
还有一个容易混淆的，就是我们会传入this指针，在dwRealProc里面和 FlushInstructionCache
里面都用到了this。这里要注意啦：如果你不知道传入的参数this指针和使用的这个this的话，你就该
重新复习一下C++基础了。解释一下：传入的this指针变为参数pThis，使用的this是THUNK的this。^_^
*****************************************************************************************/

template<typename dst_type,typename src_type>
dst_type pointer_cast(src_type src)
{
return *static_cast<dst_type*>( static_cast<void*>(&src) );
}

class Test
{
public:
int m_nFirst;
    THUNK m_thunk;
    int      m_nTest;

    //构造函数中初始化为3，仅为测试，以便查看外面的方法JmpedTest是否可以正确取得这个值
    Test() : m_nTest(3),m_nFirst(4)
    {}

    void TestThunk()
    {
   m_thunk.Init(pointer_cast<int>(&Test::Test2),this);
        FUNC1 f = (FUNC1)&m_thunk;
        f(1,2);
        cout << "Test::TestThunk()" << endl;
    }

int Test2(int a, int b)
{
   cout << a << " " << b << " " << m_nFirst << " " << m_nTest << endl;
   return 0;
}
};

int _tmain(int argc, _TCHAR* argv[])
{
    Test t;
    t.TestThunk();
    system("pause");
    return 0;
}

总结：

这个明显是暴力的去强制跳转，直接把指令写入到数据段中，增加了出错的风险，而且可移植性变的很差。所以尽量少用。

要弄清楚函数调用规则和堆栈的平衡。如果你用_cedcl规则的函数调用的话，就会出错啦。

学习代码中只是处理了简单的情况，还有几种方式，例如不是强制跳转，而是用call的方式调用，也可以实现。对于其他的函数规则例如成员函数是_stdcall，他是参数压栈的，这个THUNK的写法也不一样了。。

因为数据段中用到了this,函数回调中会用到它，所以一定要保证这个this有效。特别是窗口回调函数，如果释放了变量，但是窗口没有销毁是很容易出问题的。窗口回调函数也有比较喜欢用一个静态的分配器，通过窗口识别，把他分配到不同的成员处理函数中的方式。

这个只是初学，原因是发现ATL的窗口回调是这样做的。觉得很神奇，所以学习了一下，有不对的地方还望多多指教。嘻嘻。。。

找到的资料：

http://www.vckbase.com/document/viewdoc/?id=1821

http://www.codeproject.com/KB/cpp/GenericThunks.aspx

http://blog.csdn.net/superarhow/archive/2006/07/10/898261.aspx

http://www.cnblogs.com/homeofish/archive/2009/02/20/1395208.html

CComptr<IDispatch> ptrDisp;
IDispatch* pDisp = ptrDisp;

对此很是疑惑，为什么两个完全不同的类型可以无差别的转换。
猜测1：
认为IDispatch重载了赋值操作符。0.1秒的时间否定。他只是一个接口，定义很明确的4的方法。不可能。由于不相信，还特意去看了一下他的接口定义。彻底死心。
猜测2.
CComptr<IDispatch>重载了赋值操作符。但是想来想去应该和他的重载没有关系，因为这个操作在他的左边，和他的赋值操作符全然没有关系。不信之，进去看了一下，并且把重载给注释掉，结果还是能编译成功，彻底确信不是赋值的作用。

真相：
终于拿出杀手锏，F11，单步，哈哈，进去发现原来有：

    operator T*() const throw()
    {
        return p;
    }

这段代码。哈哈。。问了大牛知道是重载强制转换。哈哈。纵欲知道原因了。。。
自己也模仿写了一下：

class A1 
{
public:
    int operator*()
    {
        return 6;
    }
    operator int() //const
    {
        return 6;
    }
};
int main()
{
    int a(5);
    int a1 = int(6);
    A1 aa1;
    int a2 = aa1;  
    return 0;
}

编译成功，爽。。。。

可是用来用去都不正确。网上去找的资料都是一个版本的，我最后的代码为：

bool charToUtf_8(IN const char* strSrc, IN OUT char** pstrDst)
{
 //u2g(in_utf8,strlen(in_utf8),out,OUTLEN);
 iconv_t cd = iconv_open("utf-8", "ANSI_X3.4-1986");
 //iconv_t cd = iconv_open("utf-8", "CP_ACP");
 if (cd == (iconv_t)(-1))
 {
  return false;
 }

 size_t ilen = ::strlen(strSrc) + 1;
 size_t olen = ilen * 4;

 char *inbuf = new char[ilen];
 char *outbuf = new char[olen];

 memset(inbuf, 0, ilen);
 memset(outbuf, 0, olen);

  const char *in = inbuf;
  char *out = outbuf;
// 
  memcpy(inbuf, strSrc, ilen);
 size_t ret = iconv(cd, &in, &ilen, &out, &olen);

 //下面这种方式会出错，为什么?
 //size_t ret = iconv(cd, &inbuf, &ilen, &outbuf, &olen);

//  if (ret == (size_t)(-1))
//  {
//   cerr << "iconv error" << endl;
//  }
//  else
//  {
//   cout << outbuf << endl;
//  }

 delete[] inbuf;
 delete outbuf;
 iconv_close(cd);
 return true;
}

当然这些代码是从网上拷贝下来再改的。编译通过，运行就不行了。

后来我放弃了。直接用windows的方法。（还好我是在windows上开发）

bool CharToUtf_8(IN const char* strSrc, IN OUT char** pstrDst)
{
 assert(pstrDst);
 int nSize = MultiByteToWideChar(CP_ACP,NULL, strSrc, -1, NULL, 0);
 WCHAR* pwchTemp = new WCHAR[nSize];
 nSize = MultiByteToWideChar(CP_ACP,NULL, strSrc, -1, pwchTemp, nSize);
 nSize = WideCharToMultiByte(CP_UTF8, NULL, pwchTemp, -1, NULL, 0, 0, 0);
 *pstrDst = new char[nSize];
 nSize = WideCharToMultiByte(CP_UTF8, NULL, pwchTemp, -1, *pstrDst, nSize, 0, 0);
 return true;
}

这样就可以饿了。呵呵。。哎。。。。
不过挺郁闷的，为什么ICONV不能用啊，有高手指点一下吗？

1. map简介
2. map的功能
3. 使用map
4. 在map中插入元素
5. 查找并获取map中的元素
6. 从map中删除元素

2。map简介

map是一类关联式容器。它的特点是增加和删除节点对迭代器的影响很小，除了那个操作节点，对其他的节点都没有什么影响。对于迭代器来说，可以修改实值，而不能修改key。

3。map的功能

1. 自动建立Key － value的对应。key 和 value可以是任意你需要的类型。
2. 根据key值快速查找记录，查找的复杂度基本是Log(N)，如果有1000个记录，最多查找10次，1,000,000个记录，最多查找20次。
3. 快速插入Key - Value 记录。
4. 快速删除记录
5. 根据Key 修改value记录。
6. 遍历所有记录。

4。使用map

使用map得包含map类所在的头文件
#include <map> //注意，STL头文件没有扩展名.h

map对象是模板类，需要关键字和存储对象两个模板参数：
std:map<int, string> personnel;
这样就定义了一个用int作为索引,并拥有相关联的指向string的指针.

为了使用方便，可以对模板类进行一下类型定义，

typedef map<int, CString> UDT_MAP_INT_CSTRING;
UDT_MAP_INT_CSTRING enumMap;

5。在map中插入元素

改变map中的条目非常简单，因为map类已经对[]操作符进行了重载

enumMap[1] = "One";
enumMap[2] = "Two";
.....

这样非常直观，但存在一个性能的问题。插入2时,先在enumMap中查找主键为2的项，没发现，然后将一个新的对象插入enumMap，键是2，值是一个空字符串，插入完成后，将字符串赋为"Two"; 该方法会将每个值都赋为缺省值，然后再赋为显示的值，如果元素是类对象，则开销比较大。我们可以用以下方法来避免开销：

enumMap.insert(map<int, CString> :: value_type(2, "Two"))

6。查找并获取map中的元素

下标操作符给出了获得一个值的最简单方法：

CString tmp = enumMap[2];

但是,只有当map中有这个键的实例时才对，否则会自动插入一个实例，值为初始化值。

我们可以使用Find()和Count()方法来发现一个键是否存在。

查找map中是否包含某个关键字条目用find()方法，传入的参数是要查找的key，在这里需要提到的是begin()和end()两个成员，分别代表map对象中第一个条目和最后一个条目，这两个数据的类型是iterator.

int nFindKey = 2;            //要查找的Key
//定义一个条目变量(实际是指针)
UDT_MAP_INT_CSTRING::iterator it= enumMap.find(nFindKey); 
if(it == enumMap.end()) {
    //没找到
}
else {
    //找到
}

通过map对象的方法获取的iterator数据类型是一个std::pair对象，包括两个数据 iterator->first 和 iterator->second 分别代表关键字和存储的数据

7。从map中删除元素

移除某个map中某个条目用erase()

该成员方法的定义如下

1. iterator erase(iterator it); //通过一个条目对象删除
2. iterator erase(iterator first, iterator last);        //删除一个范围
3. size_type erase(const Key& key); //通过关键字删除

clear()就相当于 enumMap.erase(enumMap.begin(), enumMap.end());