函数指针与typedef

比眉伴天荒 2022-08-13 00:39 148阅读 0赞

**（一）简单的函数指针的应用。**   
// 形式 1 ：返回类型 (\* 函数名 )( 参数表 )   
**char (\*pFun)(int);**   
**char glFun(int a)\{ return;\}   
void main()   
\{   
    pFun = glFun;   
    (\*pFun)(2);   
\}**  
         第一行定义了一个指针变量 pFun 。首先我们根据前面提到的 “ 形式 1” 认识到它是一个指向某种函数的指针，这种函数参数是一个 int 型，返回值是 char 类型。只有第一句我们还无法使用这个指针，因为我们还未对它进行赋值。   
         第二行定义了一个函数 glFun() 。该函数正好是一个以 int 为参数返回 char 的函数。我们要从指针的层次上理解函数 —— 函数的函数名实际上就是一个指针，函数名指向该函数的代码在内存中的首地址。   
         然后就是可爱的 main() 函数了，它的第一句您应该看得懂了 —— 它将函数 glFun 的地址赋值给变量 pFun 。 main() 函数的第二句中 “\*pFun” 显然是取 pFun 所指向地址的内容，当然也就是取出了函数 glFun() 的内容，然后给定参数为 2 。   
 **（二）使用typedef** **更直观更方便。**   
// 形式 2 ： typedef  返回类型 (\* 新类型 )( 参数表 )   
**typedef char (\*PTRFUN)(int);**   
**PTRFUN pFun;   
char glFun(int a)\{ return;\}   
void main()   
\{   
    pFun = glFun;   
    (\*pFun)(2);   
\}**  
        typedef 的功能是定义新的类型。第一句就是定义了一种 PTRFUN 的类型，并定义这种类型为指向某种函数的指针，这种函数以一个 int 为参数并返回 char 类型。后面就可以像使用 int,char 一样使用 PTRFUN 了。   
         第二行的代码便使用这个新类型定义了变量 pFun ，此时就可以像使用形式 1 一样使用这个变量了。   
 **（三）在C++** **类中使用函数指针。**   
// 形式 3 ： typedef  返回类型 ( 类名 ::\* 新类型 )( 参数表 )  
 **class CA**   
**\{   
 public:   
    char lcFun(int a)\{ return; \}   
\};   
CA ca;  
typedef char (CA::\*PTRFUN)(int);   
PTRFUN pFun;   
void main()   
\{   
    pFun = CA::lcFun;   
    ca.(\*pFun)(2);   
\}**   
         在这里，指针的定义与使用都加上了 “ 类限制 ” 或 “ 对象 ” ，用来指明指针指向的函数是那个类的这里的类对象也可以是使用 new 得到的。比如：   
**CA \*pca = new CA;**   
**pca->(\*pFun)(2);   
delete pca;**  
         而且这个类对象指针可以是类内部成员变量，你甚至可以使用 this 指针。比如：   
         类 CA 有成员变量 PTRFUN m\_pfun;  
**void CA::lcFun2()**   
**\{   
   (this->\*m\_pFun)(2);  
\}**  
  一句话，使用类成员函数指针必须有 “->\*” 或 “.\*” 的调用。

另外，C 的函数名，就是地址，函数名取地址，还是一样，所以p() ,(\*p)() 都可以调用函数。**pFun(2)**是标准c++的写法,**（\*pFun)(2)**这是兼容c语言的标准写法,两种同意,但注意区分,避免写的程序产生移植性问题!    
函数指针同样是可以作为参数传递给函数的，下面我们看个例子，仔细阅读你将会发现它的用处，稍加推理可以很方便我们进行一些复杂的编程工作。   
\#include <iostream>     
\#include <string>     
using namespace std;     
  
int test(int);   
int test2(int (\*ra)(int),int);   
  
void main(int argc,char\* argv\[\])       
\{     
cout<<test<<endl;   
typedef int (\*fp)(int);     
fp fpi;   
fpi=test;//fpi赋予test 函数的内存地址  
cout<<test2(fpi,1)<<endl;//这里调用test2函数的时候,这里把fpi所存储的函数地址(test的函数地址)传递了给test2的第一个形参   
cin.get();   
\}     
  
int test(int a)   
\{     
return a-1;   
\}   
  
int test2(int (\*ra)(int),int b)//这里定义了一个名字为ra的函数指针   
\{   
int c=ra(10)+b;//在调用之后,ra已经指向fpi所指向的函数地址即test函数   
return c;   
\}

利用函数指针，我们可以构成指针数组，更明确点的说法是构成指向函数的指针数组，这么说可能就容易理解的多了。

\#include <iostream>     
\#include <string>     
using namespace std;   
  
void t1()\{cout<<"test1";\}   
void t2()\{cout<<"test2";\}   
void t3()\{cout<<"test3";\}   
void main(int argc,char\* argv\[\])       
\{   
void\* a\[\]=\{t1,t2,t3\};   
cout<<"比较t1()的内存地址和数组a\[0\]所存储的地址是否一致"<<t1<<"|"<<a\[0\]<<endl;   
  
cout<<a\[0\]();//错误!指针数组是不能利用数组下标操作调用函数的   
  
typedef void (\*fp)();//自定义一个函数指针类型   
fp b\[\]=\{t1,t2,t3\}; //利用自定义类型fp把b\[\]定义趁一个指向函数的指针数组   
b\[0\]();//现在利用指向函数的指针数组进行下标操作就可以进行函数的间接调用了;   
cin.get();   
\}

仔细看上面的例子可能不用我多说大家也会知道是怎么一会事情了,最后我们做一个重点小结,只要记住这一点,对于理解利用函数指针构成数组进行函数间接调用就很容易了!

void\* a\[\]=\{t1,t2,t3\};  
cout<<"比较t1()的内存地址和数组a\[0\]所存储的地址是否一致"<<t1<<"|"<<a\[0\]<<endl;  
  
cout<<a\[0\]();//错误!指针数组是不能利用数组下标操作调用函数的

上面的这一小段中的错误行，为什么不能这么调用呢？  
  
　　前一篇教程我们已经说的很清楚了，不过在这里我们还是复习一下概念， 指针数组元素所保存的只是一个内存地址，既然只是个内存地址就不可能进行a\[0\]()这样地址带括号的操作，而函数指针不同它是一个例外，函数指针只所以 这么叫它就是因为它是指向函数指向内存的代码区的指针，它被系统授予允许与()括号操作的权利，进行间接的函数调用，既然函数指针允许这么操作，那么被定 义成函数指针的数组就一定是可以一样的操作的。

关于函数指针的重要性，有一篇文章特别进行了说明，转帖如下：

来源:  
www.csdn.net  
  
记得刚开始工作时，一位高手告诉我，说，longjmp和setjmp玩得不熟，就不要自称  
为C语言高手。当时我半信半疑，为了让自己向高手方向迈进，还是花了一点时间去学习longjmp和setjmp的用法。后来明白那不单是跳来跳去那样简  
单，而是一种高级的异常处理机制，在某些情况下确实很有用。  
为了显示自己的技巧，也在自己的程式中用过几次。渐渐发现这样的技巧带来的好处是有代价的，  
破坏了程式的结构化设计，程式变得很难读，尤其对新手来说。终于明白这种技巧但是是一种调味料，在少数情况使用几次，能够简化对问题的处理。假如把调味拿  
来当饭吃，一定会本末倒置，写出的程式会呈现营养不良之状。  
事实上，longjmp和setjmp玩得熟不熟和是不是C语言高手，不是因果关系。但是，  
假如能够套用那位高手的话，我倒想说假如函数指针玩得不熟，就不要自称为C语言高手。为什么这么说呢，函数指针有那么复杂吗？当然不是，任何一个稍有编程  
常识的人，不管他懂不懂C语言，在10分钟内，我想他一定能够明白C语言中的函数指针是怎么回事。  
原因在于，难的不是函数指针的概念和语法本身，而是在什么时候，什么地方该使用他。函数指针  
不但是语法上的问题，更重要的是他是个设计范畴。真正的高手当然不单应该懂得语法层面上的技巧，更应该懂得设计上的方法。不懂设计，能算高手吗？怀疑我  
在夸大其辞吗？那我们先看看函数指针和哪些设计方法有关：  
**和分层设计有关。**分层设计早就不是什么新的概念，分层的好处是众所周知的，比较明显好处就是简化复杂度、隔离变化。采用分层设计，每层都只需关心自己的东西，这减小了系统的复杂度，层和层之间的交互仅限于一个很窄的接口，只要接口不变，某一层的变化不会影响其他层，这隔离了变化。  
分层的一般原则是，上层能够直接调用下层的函数，下层则不能直接调用上层的函数。这句话说来  
简单，在现实中，下层常常要反过来调用上层的函数。比如您在拷贝文档时，在界面层调用一个拷贝文档函数。界面层是上层，拷贝文档函数是下层，上层调用下  
层，理所当然。但是假如您想在拷贝文档时还要更新进度条，问题就来了。一方面，只有拷贝文档函数才知道拷贝的进度，但他不能去更新界面的进度条。另外一方  
面，界面知道怎样去更新进度条，但他又不知道拷贝的进度。怎么办？常见的做法，就是界面配置一个回调函数给拷贝文档函数，拷贝文档函数在适当的时候调用这  
个回调函数来通知界面更新状态。  
**和抽象有关。**抽象是面向对象中最重要的概念之一，也是面向对象威力强大之处。面向对象只是一种思想，大家都知道，用C语言相同能够实现面向对象的编程。这可不是为了赶时髦，而是一种实用的方法。假如您对此表示怀疑，能够去看看GTK+、linux kernel等开源代码。  
接口是最高级的抽象。在linux  
kernel里面，接口的概念无处不在，像虚拟文档系统(VFS)，他定义一个文档系统的接口，只要按照这种接口的规范，您能够自己研发一个文档系统挂上  
去。设备驱动程式更是如此，不同的设备驱动程式有自己一套不同的接口规范。在自己研发设备研发驱动程式时，只要遵循相应的接口规范就行了。接口在C语言中  
怎样表示？很简单，就是一组函数指针。  
**和接口和实现分开有关**。针对接口编程，而不是针对实现编程，此为《设计模式》的第一条设计准则。分开接口和实现的目标是要隔离变化。软件是变化的，假如不能把变化的东西隔离开来，导致牵一发而动全身，代价是巨大的。这是大家所不愿看到的。  
C语言既然能够实现面向对象的编程，自然能够利用设计模式来分离接口和实现。像桥接模式、策略模式、状态模式、代理模式等等，在C语言中，无一无需利用函数指针来实现。  
**和松耦合原则有关**。面向过程和面向对  
象相比，之所以显得苍白无力，原因之一就是他不像面向对象相同，能够直观的把现实模型映射到电脑中。面向过程讲的是层层控制，而面向对象更强调的对象间  
的分工合作。现实世界中的对象处于层次关系的较少，处于对等关系的居多。也就是说，对象间的交互往往是双向的。这会加强对象间的耦合性。  
耦合本身没有错，实际上耦合是必不可少的，没有耦合就没有协作，对象之间无法形成一个整体，什么事也做不了。关键在于耦合要恰当，在实现预定功能的前提下，耦合要尽可能的松散。这样，系统的一部分变化对其他部分的影响会很少。  
函数指针是解耦对象关系的最好利器。Signal(如boost的signal和glib中的signal)机制是个典型的例子，一个对象自身的状态可能是在变化的（或会触发一些事件），而其他对象关心他的变化。一旦该对象有变化发生，其他对象要执行相应的操作。  
假如该对象直接去调用其他对象的函数，功能是完成了，但对象之间的耦合太紧了。怎样把这种耦  
合降到最低呢，signal机制是很好的办法。他的原理大致如下：其他关注该对象变化的对象主动注册一个回调函数到该对象中。一旦该对象有变化发生，就调  
用这些回调函数通知其他对象。功能同样实现了，但他们之间的耦合度降低了。  
在C语言中，要解决以上这些问题，不采用函数指针，将是很困难的。在编程中，假如您从没有想到用函数指针，很难想像您是个C语言高手。