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不能用啊，有高手指点一下吗？

以前买了一个电脑，用不了多久就开始出问题了，开始是开不了机，听到3长响，我哪里知道是什么原因，更不敢拆来修，等了一个晚上，第二天又好了。不过好景不长，过了没几天有出现了，我继续等啊，等了一天还是不见好，就只有请人帮忙了，后来得知是内存有问题，我还以为还换内存呢。不过幸运的是，把内存拔出来擦擦，然后再插进去又好了。。原来有这种事。。呵呵。。就这样，我度过了N久的拔内存，擦内存的简单维修工作，不过说实话，这招真的很管用。（对了，现象是，什么都不出现。。一个黑屏）。

然后到了公司，给我了一台工作机，现在居然也有问题了。他的现象是可以进入开始的自检，但是不能跳过。所以可能是某个硬件坏了。我无语，自己更不敢修了。遂等了N久，信息部的大牛来修了。。他来，发现这个问题之后，就把电池给扣出来了，名曰：放电。过了几秒放进去后又好了。。真是神招，我还没有用过。呵呵。不过过了两天又出现这个问题了。

漫长的等待之后，他把显卡拆了，然后又OK了。。

幸运的是他告诉我：一般电脑开不了机其实并不是硬件真的坏了，有可能是接触不良等原因引起的，所以把对应的硬件拔出来，看看，然后在好的装回去就好了。对他的教导我也是有所感触。呵呵。不只是电脑方面。

所以我总结电脑修理的步骤：内存试试->放电->显卡->其他部件拆下试试。

虽然很傻的方式，不过迄今为止我都还觉得这些招挺管用的。哈哈。。

快速排序学习1            快速排序学习2（随机化版本）

快速排序学习3（最初版）  快速排序学习4（最初版加随机版）

插入排序   冒泡排序    选择排序

希尔排序   合并排序  堆排序  用堆实现优先队列

http://baike.baidu.com/view/178698.htm

http://www.cnblogs.com/nokiaguy/archive/2008/05/16/1199359.html

所以就不用写思路了哦，真笨，语文也得好好学学，不然组织语言的能力太差了。呵呵。

奉上源代码(因为是自己写的，所以还是贴一下)：

1.加入一个数组A = {5,3,6,2,4,7}，我们对他进行排序

2.确定最小的元素放在A[0]位置，我们怎么确定呢，首先默认最小元素为5,他的索引为0,然后用它跟3比较，比他打，则认为最小元素为3,他的索引为1，然后用3跟6比，发现比他小，最小元素还是3，然后跟2比，最小元素变成了2，索引为3，然后跟4比，跟7比。当比较结束之后，最小元素也尘埃落定了。就是2，索引为3，然后我们把他放在A[0]处。为了使A[0]原有数据部丢失，我们使A[0](要放的位置) 与A[3]（最小数据的位置）交换。这样就不可以了吗？

3.然后我们在来找第二小元素，放在A[1]，第三小元素，放在A[2]。。当寻找完毕，我们排序也就结束了。

4.不过，在找的时候要注意其实位置，不能在找A[2]的时候，还用A[2]的数据跟已经排好的A[0],A[1]比，一定要跟还没有确定位置的元素比。还有一个技巧就是我们不能每次都存元素值和索引，我们只存索引就可以了，通过索引就能找到元素了。呵呵。

5.他和冒泡的相似和区别，冒泡和他最大的区别是他发现比他小就交换，把小的放上面，而选择是选择到最小的在直接放在确定的位置。选择也是稳定的排序。

基本思路就这样了，奉上源代码：

冒泡排序的主要思路：

画个图先：

开始：1 和2 比，1比2小，浮上，然后1跟4比，再1跟3比，这样结构就变为1，3，4，2。最小的位置确定了，然后我们确定第二小的，同理2 vs 4, 2 vs 3 得到2， 再确定第3小数据，3 vs 4得到3，最后就是4为最大的数据，我们冒泡就排好了。

注：这里红色的1,2是前一次比较1 vs 2交换的结构。后面也一样。

大概思路就这样了，奉上源代码：

这里只需循环3次就出结果了。

<!--[if !supportLists]-->3.       <!--[endif]-->但是注意，我们必须要把个位排好。但是个位怎么排呢？这个是个问题。书上说的是一叠一叠的怎么合并，我是没有理解的。希望知道的有高手教我一下。

我是用的一个计数排序来排各位的，然后排十位。效率应该也低不到哪里去。呵呵。。

思路就这样咯。奉上源代码：

计数排序：

今天学习了计数排序，貌似计数排序的复杂度为o(n)。很强大。他的基本思路为：

1.       我们希望能线性的时间复杂度排序，如果一个一个比较，显然是不实际的，书上也在决策树模型中论证了，比较排序的情况为nlogn的复杂度。

2.       既然不能一个一个比较，我们想到一个办法，就是如果我在排序的时候就知道他的位置，那不就是扫描一遍，把他放入他应该的位置不就可以了嘛。

3.       要知道他的位置，我们只需要知道有多少不大于他不就可以了吗？

4.       以此为出发点，我们怎么确定不大于他的个数呢？我们先来个约定，如果数组中的元素都比较集中，都在[0, max]范围内。我们开一个max的空间b数组，把b数组下标对应的元素和要排序的A数组下标对应起来。这样不就可以知道不比他大的有多少个了吗？我们只要把比他小的位置元素个数求和，就是不比他大的。例如：A={3,5,7};我们开一个大小为8的数组b，把a[0] = 3 放入b[3]中，使b[3] = 0; 同理 b[5] = 1; b[7] = 2;其他我们都设置为-1，哈哈我们只需要遍历一下b数组，如果他有数据，就来出来，铁定是当前最小的。如果要知道比a[2]小的数字有多少个，值只需要求出b[0] – b[6]的有数据的和就可以了。这个0(n)的速度不是盖得。

5.       思路就是这样咯。但是要注意两个数相同的情况A = {1,2,3,3,4}，这种情况就不可以咯，所以还是有点小技巧的。

6.       处理小技巧：我们不把A的元素大小与B的下标一一对应，而是在B数组对应处记录该元素大小的个数。这不久解决了吗。哈哈。例如A = {1,2,3,3,4}我们开大小为5的数组b;记录数组A中元素值为0的个数为b[0] = 0, 记录数组A中元素个数为1的b[1] = 1,同理b[2] = 1, b[3] = 2, b[4] = 1;好了，这样我们就知道比A[4](4)小的元素个数是多少了：count = b[0] + b[1] + b[2] + b[3] = 4;他就把A[4]的元素放在第4个位置。

还是截张书上的图：

再次推荐《算法导论》这本书，在我的上次的随笔中有下载链接。哈哈。真正支持还是需要买一下纸版。呵呵。

7. 不过在编程的时候还是要注意细节的，例如我不能每次都来算一下比他小的个数。呵呵，思路就这样了。奉上源代码：

我们用的glut辅助库，他能让我们减少好多的操作，例如创建窗口，初始化设备，他都为我们建好了。

开始：

1.初始化opengl

2.设置渲染模式为：GLUT_DOUBLE | GLUT_RGBA

3.设置窗口大小，和标题，

4.创建窗口，

5.进入Opnegl里面的初始化。Opengl里面的初始化这里的初始化一定要在创建窗口以后。

6.设置渲染的函数

7.设置变化窗口大小，调整视口的函数

8.主程序循环。

这就是程序的主框架，我们只要把这些内容写入到main函数中，然后再自己实现相关的函数就可以了。是不是给我们带来了很大的方便呢。废话少说。奉上源代码：

#include <gl\glut.h>

void display(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    // 清楚颜色数据和深度数据（清屏）

    
    glBegin(GL_TRIANGLES);            //绘制一个三角型
    glColor3f(1.0,0,0);                //绘制颜色为红色
    glVertex3f (0, 0, -2.0);        //绘制三角型的一个顶点0,0,-2
    glColor3f(0,1.0,0);                //同理绘制其他两个顶点
    glVertex3f (1, 1, -2.0);
    glColor3f(0,0,1.0);    
    glVertex3f (1, 0, -2.0);
    glEnd();                    //结束绘制三角型

    glutSwapBuffers();            //交换缓冲区。显示图形
}

//初始化
void init (void) 
{
    glClearColor (1.0, 0.0, 0.0, 0.0);    //清理颜色，为黑色，（也可认为是背景颜色）
}

//当窗口大小改变时，会调用这个函数
void reshape(GLsizei w,GLsizei h)
{
    //这里小说明一下：矩阵模式是不同的，他们各自有一个矩阵。投影相关
    //只能用投影矩阵。(只是目前情况下哦，等我学多了可能就知道为什么了。)

    glViewport(0,0,w,h);        //设置视口
    glMatrixMode(GL_PROJECTION);    //设置矩阵模式为投影变换矩阵，
    glLoadIdentity();                //变为单位矩阵
    gluPerspective(60, (GLfloat)w / h, 0, 1000);    //设置投影矩阵
    glMatrixMode(GL_MODELVIEW);        //设置矩阵模式为视图矩阵(模型)
    glLoadIdentity();                //变为单位矩阵
}


int main(int argc, char** argv)
{
    glutInit(&argc, argv);        //Opnegl初始化
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA); //设置显示模式为双缓冲，RGEBA

    glutInitWindowSize (250, 250);            //窗口大小
    glutInitWindowPosition (100, 100);        //窗口位置
    glutCreateWindow ("hello");                //创建一个标题为hello的窗口
    init ();                                //初始化资源,这里一定要在创建窗口以后，不然会无效。
    glutDisplayFunc(display);                //窗口大小改变时的回调
    glutReshapeFunc(reshape);                //绘制图形时的回调
    glutMainLoop();                            //主循环。
    return 0;  
}