作者：倾夜·陨灭星尘

一．什么是函数指针？

函数指针，顾名思义即指向函数的指针。

如果要问，为什么能用一个指针指向一个函数呢？我觉得要理解这个问题，以及要理解后面的函数指针和类成员函数指针，没有什么比从计算机原理的角度来理解更容易了。这里就简要回顾一下相关知识。

众所周知，计算机（图灵机）执行程序的基本流程就是：取指令->执行指令->取下一条指令->……。取指令的位置由一个寄存器PC决定。开机时，PC通常指向0（这条指令常常是一条跳转指令。在ARM架构中，一般位置0是复位中断向量。总之都是要实现一个跳转），随后，如果没有碰到跳转指令，则PC自加一个字长执行下一条指令，否则根据跳转指令（JB,JMP,CALL等）跳转到给定位置（即改写PC）执行。

常见的C语言程序中，if、while、for等带判断条件的指令是由条件跳转语句完成（ARM架构下指令为B，原理都是一样的）。以一个简单的条件跳转指令举例：

if ( a == 0 )
00CD52D5  cmp        dword ptr [a],0  ;比较
00CD52D9  jne        main+34h (0CD52E4h)  ;根据结果跳转到0CD52E4h（if语句块后）
goto、break、while语句则一般是jmp无条件跳转指令实现的。如以下程序：
while ( a!=0 )
008E52DF  cmp        dword ptr [a],0 
008E52E3  je         main+40h (08E52F0h) 
{
}
008E52E5  jmp        main+2Fh (08E52DFh) 

可以看出来，跳转指令，无论是有无条件，无论寻址方式如何，其实都只是做了一件事——改变PC的值，跳转到指定位置。这个位置是由编译器给定的值，在此过程中，不会做除了改变PC以外的任何事情。

CALL指令相对于跳转指令则不同。从设计目的的角度来说，CALL是为了实现函数调用。函数调用与一般的跳转相比，除了改变PC还需要考虑调用结束后恢复PC值返回原位置。高级语言中，都是使用堆栈来处理这问题：调用函数时，将返回的位置和传递参数压栈后跳转；调用结束时，弹出参数和返回位置随后跳回。现代处理器中，CALL指令除了跳转，还负责将返回位置压栈，相应的RET语句则集成了弹出返回位置和跳转。

CALL指令的寻址方式也有多种（跳转语句同理）。概括性地说，有三种方式：相对转移（给PC加减一定值）、绝对转移（直接给PC赋值）、间接转移（将寄存器中的地址赋值给PC）。顺便一说，在RISC处理器中，往往只有最后一种。

相对转移、绝对转移的目标地址，都是很简单地直接在指令当中给出。换句话说，跳转地址是在编译阶段就由编译器给定了。

但是，有的时候我们需要在运行时动态地改变跳转地址。而相对转移、绝对转移是无法改变跳转地址的。所以，为了达到这一目的，一般来说，是先将跳转地址addr存入一个寄存器（或内存中一个位置），而后CPU从这个寄存器中取出地址addr进行跳转。这个地址，也就是我们所说的函数指针。

我们进行的各种函数调用，本质上都是操作这一个地址，无论它是固化在指令中还是存储在寄存器中。而每一个函数名，就如同数组名一样，实际上都是一个地址。所以，理所当然地如同一般的指针变量一样，我们也可以有一个函数指针变量。

二．函数指针的使用

1.一般函数函数指针

一般的函数指针形如：

int( *pf )( char, int, float );

这是一个有三个分别为char,int,float输入参数，返回值为int的函数指针变量pf。为什么*pf需要用()呢?因为*的运算符优先级比()低，如果不用()就成了*(pf())了。

先举一个最简单的例子：

voidNormalFunc()
{
cout << "Normal Func"<< endl;
}
void( *pfunc )();
pfunc =NormalFunc;
pfunc();//输出”Normal Func”

稍复杂的如下

int NormalFunc(char c, int i, float f )
{
cout << "Normal Func"<< c << i << f << endl;
return 0;
}
int( *pfunc)(char,int ,float );
pfunc =NormalFunc;
pfunc(1,2,3);

如果觉得这样定义太麻烦，可以用typedef做一个重命名。如：

typedef int(*I_PFUNC_C_I_F )( char, int, float );//随手命名，一般情况下别这样
I_PFUNC_C_I_Fpfunc;
pfunc =NormalFunc;

总之，函数指针和函数必须有着完全相同的类型（包括参数、返回值、调用约定_stdcall和_cdecl）。

这样有什么好处呢？

【动态调用、函数查找表】

二．类成员函数函数指针

对于类的成员函数，其指针与一般函数指针有着很大的区别。主要原因是类成员函数都隐含了一个this指针，调用时，编译器对其处理方式与一般函数不同，实际的汇编代码也不一样。因此，为了避免错误，编译器是不允许将类成员函数赋值给一般函数指针的。

实际的汇编代码分析见第四节，这里我就只从使用的角度来解析：如何使用类成员函数指针？

1.  常规操作方法（推荐）

简单来说，就是在指针前加入一个域限定符，并指定成员函数对应的类实例。

class mc:public empty
{
public:mc(){//构造函数中数组初始化，必须指定域maps[0]= &mc::On_WM_PAINT;maps[1]= &mc::On_WM_DESTORY;}typedefLRESULT (_stdcall mc:: *PCFUNC)( HWND, UINT, WPARAM, LPARAM );//类成员函数指针，必须指定域LRESULT_stdcall On_WM_PAINT(HWND, UINT, WPARAM, LPARAM){cout<< "ON_WM_PAINT" << endl;return0;}LRESULT_stdcall On_WM_DESTORY( HWND, UINT, WPARAM, LPARAM ){cout<< "ON_WM_DESTORY" << endl;return0;}PCFUNCmaps[2];//类成员函数指针数组voidtest(){(this->*maps[1])(NULL, NULL, NULL, NULL );//类内部调用}
};

使用时，在类内部需要加入this指针，在类外部则一定要指定对应的类实例：

 

      mcmyclass;//声明类实例mc::PCFUNCpcfunc = myclass.maps[0];//声明一个类成员函数指针变量(myclass.*pcfunc )( NULL, NULL, NULL, NULL );//调用第0个函数输出“ON_PAINT”myclass.test();//内部调用，输出“ON_DESTORY”

     

2.  静态函数（不推荐）

以上都是对非静态函数的使用方法。对于静态函数，则要容易得多。因为静态函数实际上就是一个作用域在类内部的普通函数，没有隐含的this指针。但是相应的，静态函数只能使用内部的静态变量。因此并不推荐。

示例如下：

class mc
{
public:mc(){maps[0]= &mc::On_WM_PAINT;//不需要指定域maps[1]= &mc::On_WM_DESTORY;}typedefLRESULT (_stdcall *PCFUNC)( HWND, UINT, WPARAM, LPARAM );//可见这里不需要指定域staticint i; static LRESULT _stdcallOn_WM_PAINT(HWND, UINT, WPARAM, LPARAM)//需要static标识符{cout<< "ON_WM_PAINT" << endl;returni; //static函数只能使用static变量}staticLRESULT _stdcall On_WM_DESTORY( HWND, UINT, WPARAM, LPARAM ){cout<< "ON_WM_DESTORY" << endl;return0;}PCFUNCmaps[4];voidtest(){maps[1](NULL, NULL, NULL, NULL );//不需要指定域}      
};

使用时也不需要指定域：

mc::PCFUNCpcfunc = myclass.maps[0];myclass.test();pcfunc(NULL, NULL, NULL, NULL );

3.  友元函数（较为推荐）

可见，静态成员函数的最大限制在于其只能使用static成员变量，这使得其极其难以使用。一个好的折衷办法是使用友元函数。相应的，友元函数能够操作类中的所有成员，不过不一样的是必须显式指定类实例指针。

class mc
{
public:mc(){maps[0]= On_WM_PAINT;//同样不需要指定域maps[1]= On_WM_DESTORY;}typedefLRESULT( _stdcall *PCFUNC )(mc&,HWND, UINT, WPARAM, LPARAM );//为了能够操作成员变量，必须传递类的引用或者指针staticint i;friendLRESULT _stdcall On_WM_PAINT(mc&src,HWND, UINT, WPARAM, LPARAM ){cout<< "ON_WM_PAINT" << endl;returnsrc.a;//这样就能通过类的引用操作成员变量，private限定的也可以}friendLRESULT _stdcall On_WM_DESTORY(mc&src, HWND, UINT, WPARAM, LPARAM ){cout<< "ON_WM_DESTORY" << endl;returnsrc.a;}PCFUNCmaps[4];voidtest(){maps[1](*this,NULL, NULL, NULL, NULL );//内部调用需要使用this指针}
private:int a;
};

在其它地方使用时，也不需要指定域。

       mcmyclass;mc::PCFUNCpcfunc = myclass.maps[0];myclass.test();pcfunc(myclass, NULL, NULL, NULL, NULL );On_WM_PAINT(myclass, NULL, NULL, NULL, NULL );//是的，即使是不用函数指针，也不需要.或者->，其实友元函数就是一个普通函数而已。

如果不想在参数里面加一个引用，那么可以将这个类的指针放进一个全局变量里。如：

mc*mc_handle=nullptr;//全局变量
友元函数中：
friend LRESULT _stdcall On_WM_PAINT(mc&src, HWND, UINT, WPARAM, LPARAM )
{cout<< "ON_WM_PAINT" << endl;returnmc_handle->a;//通过全局变量操作
}

主函数中：

mc myclass;
mc_handle=&myclass;//如果不初始化的话，哼哼……
On_WM_PAINT( myclass, NULL, NULL, NULL,NULL );

【如果这个类只会有一个实例，可以使用“单件”设计模式】

【如果觉得用起来比较麻烦，还可以声明友元类而不是友元函数】

4.  C++11特性：std::function和std::bind（这么高端的操作为什么你不来试试？）

C++在<functional>中引入了function和bind，使得能够更加容易地进行动态绑定。

简单的实现如下：

class mc
{
public:mc(){fr[0] = bind( &mc::On_WM_PAINT,this,placeholders::_1,placeholders::_2, placeholders::_3, placeholders::_4 );//绑定方式}LRESULT_stdcall On_WM_PAINT(  HWND, UINT,WPARAM, LPARAM ){cout<< "ON_WM_PAINT" << endl;returna;}LRESULT_stdcall On_WM_DESTORY( HWND, UINT, WPARAM, LPARAM ){cout<< "ON_WM_DESTORY" << endl;returna;}
function<LRESULT _stdcall( HWND, UINT, WPARAM,LPARAM )>fr[4];//定义方式
};

这样，调用时只需要：

mc myclass;myclass.fr[0]( NULL, NULL, NULL, NULL );//调用就是这么简单

5.用宏定义来解放我们（让读代码的人蛋疼去吧）

如果嫌弃上面的这么一大堆东西写起来太费劲，不妨使用下面这种宏定义：

#define ON_WMESSAGE(msgname)  LRESULT _stdcall On_##msgname( HWND hwnd,UINTuMsgID,WPARAM wParam,LPARAM lParam )//宏定义
#define MAP_ON_WMESSAGE(msgname)       {msgname,On_##msgname}
ON_WMESSAGE( WM_PAINT );
ON_WMESSAGE( WM_DESTROY );
ON_WMESSAGE( WM_LBUTTONDBLCLK );
ON_WMESSAGE( WM_COMMAND );struct sWM_CB
{UINTuMsgID;LRESULT(_stdcall*WndProc )( HWND , UINT , WPARAM , LPARAM );
};
struct sWM_CB WM_CB_Maps[] = { MAP_ON_WMESSAGE(WM_PAINT ),MAP_ON_WMESSAGE(WM_DESTROY ),MAP_ON_WMESSAGE(WM_LBUTTONDBLCLK ),MAP_ON_WMESSAGE(WM_COMMAND ), };

以上宏定义中的##实际上是就是将宏定义参数中的字符直接连接的意思。所以，在这里，ON_WMESSAGE( WM_PAINT )等效语句实际上是：

LRESULT_stdcall On_WM_PAINT( HWND hwnd,UINT uMsgID,WPARAM wParam,LPARAM lParam )

MAP_ON_WMESSAGE( WM_PAINT )实际上是：

{ WM_PAINT, On_WM_PAINT }

结合上以上的function,bind等，实际上构成了C++除了面向对象、面向过程、泛型模板之外的第四种编程——lamada元编程。如果去仔细探究windows.h源码，会发现这种编程方式到处都是。

三．还有这种操作的函数指针（原创）

实际上，对于计算机（特指冯诺依曼架构）而言，不管是int、char，还是什么指针、指令，其实都是一样的一个数，它们对CPU都没什么区别，让他们有区别的是我们对它的处理方式。

函数指针也是一样的，理论上，我们可以对函数指针赋任何值。但是编译器会阻止我们，不允许我们胡乱赋值。可是，别忘了，C/C++语言之所以能够称为接近底层的高级语言，其中一个原因就是它有着一个极其强大、危险，同时也是魅力十足的特性，就是“强制类型转换”。

所以，请看以下操作。

我们先写上一个函数，在主函数中调用：

void myfunc()
{}

然后，加入断点运行，并Alt+8打开反汇编：

这里，我们可以看到全部机器码源代码。

把这些源代码给写在一个数组里

const int inst[] = { 0x81ec8b55,0x0000c0ec,0x57565300,0xFF40BD8D,0x30B9FFFF,0xb8000000,0xcccccccc,
0x5e5fabf3,0x5de58b5b,0xc3c3c3c3};

然后，我们定义一个函数指针

void(*pfunc)();

可是，这时候直接令pfunc=(void(*)())inst是不行的。我们可以迂回一下：

inta = (int)inst;
pfunc= (void(*)())a;

好的，让我们执行吧！

pfunc();

设置一个断点，按下F11，我们成功地跳了进去：

看出来了吗？这和源程序一摸一样！

是不是很神奇！C++程序员，几乎无所不能！

……

不过，需要浇一盆冷水的是，如果你跑一跑：

我们什么地方错了？

实际上，我们的原理是没有问题的，我保证，如果你把这个代码拿到8086、8051、STM32上，它是绝对能够运行的（没错，我以前在STM32上实现了）。关键原因在于，在80286以后，INTEL加入了内存分区的权限。只有高权限的情况下，才能在系统其它区域运行程序或者修改代码区程序。其原因显而易见——除了操作系统和底层驱动，其它应用程序都不应该得到修改系统代码的能力。想要修改安全区域代码的程序，不是初学者误用，就是恶意程序。

事实上，我稍稍改了一下地址，我的可怜的杀毒软件就把我的程序杀掉了/(ㄒoㄒ)/~~

但是，这种技术的应用是非常广泛的。手机操作系统更新、动态链接库、动态程序安全加密（SMC）……都用到了这种技术。毕竟说到底，任何程序都是数字的集合而已。

 

四．进阶部分：

可能你会问，平常写程序都是直接写成如func()这样的形式啊，并没有感觉在操作一个指针。实际上，这是因为编译器已经帮我们实现了这一功能，并不需要我们操心。在VS的DEBUG模式，_cdecl调用约定下，一个简单的函数调用如下：

步骤1，使用CALL指令压栈跳转：

func();

00974F8D E8 92C4 FF FF       call        func (0971424h)

步骤二，对应地址实际上是存储了一个跳转指令，执行跳转：

func:

00971424 E9 E737 00 00       jmp         func (0974C10h) 

步骤三，随后跳转到的才是实际的函数部分，函数首先将当前寄存器状态压栈保护起来，执行程序，最后恢复现场并RET返回。

void func( void)

{

00974C10 55                   push        ebp 

00974C11 8BEC                mov         ebp,esp 

00974C13 81 ECC0 00 00 00    sub         esp,0C0h 

00974C19 53                   push        ebx 

00974C1A 56                   push       esi 

00974C1B 57                   push        edi 

00974C1C 8D BD40 FF FF FF    lea         edi,[ebp-0C0h] 

00974C22 B9 3000 00 00       mov         ecx,30h 

00974C27 B8 CCCC CC CC       mov         eax,0CCCCCCCCh 

00974C2C F3AB                rep stos    dword ptr es:[edi] 

i++;

00974C2E A0 80F6 97 00       mov         al,byte ptr ds:[0097F680h] 

00974C33 0401                add         al,1 

00974C35 A2 80F6 97 00       mov         byte ptr ds:[0097F680h],al 

}

00974C3A 5F                   pop         edi 

00974C3B 5E                   pop         esi 

00974C3C 5B                   pop         ebx 

00974C3D 8BE5                mov         esp,ebp 

00974C3F 5D                   pop         ebp 

00974C40 C3                   ret 

可以看出来，实际上相当繁琐。这主要是因为DEBUG模式下编译器没有进行优化。在RELEASE模式下：没有步骤二，直接跳转到函数体（我猜测DEBUG模式下多加入的步骤2是为了使用跳转表存储所有的函数，方便调试）；不会将所有寄存器压栈，只会将函数中用到的压栈；对于短函数，会直接内联嵌入，不会进行函数调用。

如果是函数指针，则步骤1的跳转将变为：

pfunc();

01195EFF 8BF4                mov         esi,esp 

01195F01 FF 1520 03 1A 01    call        dword ptr ds:[11A0320h] 

可以看出，实际上就是根据内存中地址进行了间接地址调用。DEBUG模式下，还会有以下两句：

01195F07 3BF4                cmp         esi,esp 

01195F09 E8 2BB4 FF FF       call        __RTC_CheckEsp (01191339h) 

这是检查堆栈是否发生溢出用的，如果函数调用的压栈、出栈中发生错误使得前后堆栈位置不一致，则会调用__RTC_CheckEsp函数进行错误处理。

而这一过程中有个问题，那就是我放入这个函数指针变量的数字，怎么保证它是一个函数呢？比如，要是我让pfunc=0x12345678，那会出现什么结果呢？

很遗憾，事实上是，CPU根本无法保证它是一个函数。对于CPU来说，数据、指令都是一样的。对一个数字0x12345678来说，究竟是把它看作一个整数，还是4个char，还是一个float的一半，还是一个函数的地址，完全取决于编译器和你。换句话说，一个数字究竟发挥什么作用，不是取决于其本身，而是取决于它的身份。这个身份有个名字——数据类型。

嗯，这句话如果推广的话，能说出很多看起来有哲理的话来呢。不过打住吧，我不想再打更多无关的字了（没看我连函数指针的用法都懒得写了吗？快进入让人激动的部分吧）

对于C++这样的静态语言来说，当程序编译完成，编译器就无法对程序做出任何改变了。所以，为了阻止你搞破坏，它就只能在编译时阻止你。换句话说，就是必须做到“类型匹配”。所以，C++要求所有的变量都需要声明才能使用，这个过程实际上就是一个“给定身份的过程”。对于特定的指针，也就是特定的“身份”，编译器会有不同的一套处理方式。比如，对于int型指针来说，pi++实际上是pi+=4。而对于char型指针来说，pi++则是pi+=1。

如：

charstr[4]=”abc”;

int *pi=str;

这是不行的，编译器会识别出类型匹配错误，不允许通过编译。

对于函数指针，如：

void func(int)

{

//…

}

void(*pfunc)(int,int);

pfunc=func;

pfunc();

也是不行的。对于func来说，在函数调用时会压栈1次传递1个参数，而pfunc，则会压栈2次。如果编译器让以上程序通过编译，则函数会压栈2次传递参数，返回时却只会弹出1次。而在栈参数下的值，是程序应该返回的位置，即调用时存储的CALL语句的下一条指令。如果少弹出一次，则会将第一个参数作为返回位置，换句话说，程序就“跑飞”了。这是非常严重的错误。因此，编译器不会允许这样的赋值。

编译器花了这么大的力气，看起来好像能够堵住所有漏洞了。可是，C/C++语言之所以能够称为接近底层的高级语言，其中一个原因就是它有着一个极其强大、危险，同时也是魅力十足的特性，就是“强制类型转换”。

类型转换非常常见。最常见的是每一本教材都会讲的“隐式类型转换”。如：

int a=

【/d1reportAllClassLayout】

【Union联合体】

【地址保护（80286加入）】

【NULL和nullptr】

【空类大小为1】