【zz】几篇关于C函数指针的文章

分手后的思念是犯贱 2022-07-12 06:53 155阅读 0赞

C函数指针的使用（转载）

**     转自：[http://blog.163.com/yqli520\_2006/blog/static/502877772007112013129764/][http_blog.163.com_yqli520_2006_blog_static_502877772007112013129764]（此博客中还有关于C面向对象编程的几篇文章）**

**函数指针之所以难于用好，不在于它的语法又多难理解，而是用在合适的场合**

**函数指针的使用：**

**与*分层设计*有关。**分层设计早就不是什么新的概念，分层的好处是众所周知的，比较明显好处就是简化复杂度、隔离变化。采用分层设计，每层都只需关心自己的东西，这减小了系统的复杂度，层与层之间的交互仅限于一个很窄的接口，只要接口不变，某一层的变化不会影响其它层，这隔离了变化。

分层的一般原则是，上层可以直接调用下层的函数，下层则不能直接调用上层的函数。这句话说来简单，在现实中，下层常常要反过来调用上层的函数。比如你在拷贝文件时，在界面层调用一个拷贝文件函数。界面层是上层，拷贝文件函数是下层，上层调用下层，理所当然。但是如果你想在拷贝文件时还要更新进度条，问题就来了。一方面，只有拷贝文件函数才知道拷贝的进度，但它不能去更新界面的进度条。另外一方面，界面知道如何去更新进度条，但它又不知道拷贝的进度。怎么办？常见的做法，就是界面设置一个回调函数给拷贝文件函数，拷贝文件函数在适当的时候调用这个回调函数来通知界面更新状态。

**与*抽象*有关。**抽象是面向对象中最重要的概念之一，也是面向对象威力强大之处。面向对象只是一种思想，大家都知道，用C语言一样可以实现面向对象的编程。这可不是为了赶时髦，而是一种实用的方法。如果你对此表示怀疑，可以去看看GTK+、linux kernel等开源代码。

接口是最高级的抽象。在linux kernel里面，接口的概念无处不在，像虚拟文件系统(VFS)，它定义一个文件系统的接口，只要按照这种接口的规范，你可以自己开发一个文件系统挂上去。设备驱动程序更是如此，不同的设备驱动程序有自己一套不同的接口规范。在自己开发设备开发驱动程序时，只要遵循相应的接口规范就行了。接口在C语言中如何表示？很简单，就是一组函数指针。

**与*接口与实现分开*有关**。针对接口编程，而不是针对实现编程，此为《设计模式》的第一条设计准则。分开接口与实现的目标是要隔离变化。软件是变化的，如果不能把变化的东西隔离开来，导致牵一发而动全身，代价是巨大的。这是大家所不愿看到的。

C语言既然可以实现面向对象的编程，自然可以利用设计模式来分离接口与实现。像桥接模式、策略模式、状态模式、代理模式等等，在C语言中，无一不需要利用函数指针来实现。

**与*松耦合原则*有关**。面向过程与面向对象相比，之所以显得苍白无力，原因之一就是它不像面向对象一样，可以直观的把现实模型映射到计算机中。面向过程讲的是层层控制，而面向对象更强调的对象间的分工合作。现实世界中的对象处于层次关系的较少，处于对等关系的居多。也就是说，对象间的交互往往是双向的。这会加强对象间的耦合性。

耦合本身没有错，实际上耦合是必不可少的，没有耦合就没有协作，对象之间无法形成一个整体，什么事也做不了。关键在于耦合要恰当，在实现预定功能的前提下，耦合要尽可能的松散。这样，系统的一部分变化对其它部分的影响会很少。

函数指针是解耦对象关系的最佳利器。Signal(如boost的signal和glib中的signal)机制是一个典型的例子，一个对象自身的状态可能是在变化的（或者会触发一些事件），而其它对象关心它的变化。一旦该对象有变化发生，其它对象要执行相应的操作。

如果该对象直接去调用其它对象的函数，功能是完成了，但对象之间的耦合太紧了。如何把这种耦合降到最低呢，signal机制是很好的办法。它的原理大致如下：其它关注该对象变化的对象主动注册一个回调函数到该对象中。一旦该对象有变化发生，就调用这些回调函数通知其它对象。功能同样实现了，但它们之间的耦合度降低了。

来源： [http://www.yuanma.org/data/2006/1213/article\_1946.htm][http_www.yuanma.org_data_2006_1213_article_1946.htm]

## [C函数指针的用法][C] ##

转自：[http://www.cnblogs.com/alon/archive/2009/04/24/1442696.html][C]

函数指针通常用来实现回调，其基本用法如下：

**1、定义函数指针类型**

// 定义一个原型为int Fun( int a );的函数指针

typedef int (\*PTRFUN) ( int aPara );

**2、函数指针变量的定义**

PTRFUN pFun;    // pFun 为函数指针变量名

int (\*pFun2) ( int a );   // pFun2也是函数指针变量名

3、函数指针作为函数的参数传递

// 定义回调函数

int CallBack( int a )\{

return ++a;

// 定义回调者函数

void Caller( PTRFUN cb )

// void Caller( int (\*cb) ( int ) ) // 也可这样申明

int nPara = 1;

int nRet = cb( nPara );

// 使用回调

void Test()\{

Caller( CallBack ); // 直接使用回调函数

PTRFUN cb = CallBack; // int (\*cb) ( int ); cb = CallBack;

int nRet1 = cb( 99 ); // nRet1 = 100;

**4、函数指针的指针使用**

// 定义函数指针的指针

typedef int (\*\*PTRPTRFUN) ( int aPara );

// 函数指针的指针作为参数

void PtrCaller( PTRPTRFUN cb )

// void PtrCaller( PTRFUN\* cb )           // 指针申明

// void PtrCaller( int (\*\*cb) ( int ) ) // 原型申明

int nRet = (\*cb)(999); // nRet = 1000;

// 使用函数指针的指针

void Test()\{

PTRFUN cb = CallBack;

PtrCaller( &cb );

**5、函数指针数组的使用**

// 函数指针数组的定义

PTRFUN fArray\[10\];

// int (\*fArray\[10\]) ( int );   // 原型定义

for ( int i = 0; i < 10; i++ )\{

fArray\[i\] = CallBack;

int nRet = fArray\[i\](i);    // nRet = i+1;

**6、函数指针的大小**

// 既然叫指针，所以跟普通的指针一样在32位系统下大小都为4

int nSz1 = sizeof(PTRFUN);      // nSz1 = 4;

int nSz2 = sizeof(PTRPTRFUN);   // nSz2 = 4;

**注意：**

编译器存在多种种调用规范，如在Visual C++中，可以在函数类型前加\_cdecl，\_stdcall或者\_pascal来表示其调用规范（默认为\_cdecl）。调用规范影响编译器产生的给定函数名，参数传递的顺序（从右到左或从左到右），堆栈清理责任（调用者或者被调用者）以及参数传递机制（堆栈，CPU寄存器等）。

\------------------------------------------------------------------------------------------------

函数指针与typedef  
关于C++中函数指针的使用(包含对typedef用法的讨论)   
（一）简单的函数指针的应用。  
//形式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函数指针

转自： [http://hi.baidu.com/seraphsky/blog/item/667617cbc49c901bbf09e6f8.html][http_hi.baidu.com_seraphsky_blog_item_667617cbc49c901bbf09e6f8.html]

<table> 
 <tbody> 
 <tr> 
 <td> 
 <div> 
 <table style="width: 98%;"> 
 <tbody> 
 <tr> 
 <td> C++中函数指针数组的妙用 　　笔者在开发某软件过程中遇到这样一个问题，前级模块传给我二进制数据，输入参数为 char* buffer和 int length，buffer是数据的首地址，length表示这批数据的长度。数据的特点是：长度不定，类型不定，由第一个字节（buffer[0]）标识该数据的类型，共有256（28 ）种可能性。我的任务是必须对每一种可能出现的数据类型都要作处理，并且我的模块包含若干个函数，在每个函数里面都要作类似的处理。若按通常做法，会写出如下代码： void MyFuntion( char* buffer, int length ) { 　　　　__int8 nStreamType = buffer[0]; 　　　tch( nStreamType ) 　　　　{ 　　　　　　　case 0: 　　　　　　　　　　　function1(); 　　　　　　　　　　　break; 　　　　　　　case 1: 　　　　　　　...... 　　　　　　　case 255: 　　　　　　　　　　　function255(); 　　　　　　　　　　　break; 　　　　　} } 　　如果按照这种方法写下去，那么在我的每一个函数里面，都必须作如此多的判断，写出的代码肯定很长，并且每一次处理，都要作许多次判断之后才找到正确的处理函数，代码的执行效率也不高。针对上述问题，我想到了用函数指针数组的方法解决这个问题。 　　函数指针的概念，在潭浩强先生的C语言程序设计这本经典的教程中提及过，在大多数情况下我们使用不到，也忽略了它的存在。函数名实际上也是一种指针，指向函数的入口地址，但它又不同于普通的如int*、double*指针，看下面的例子来理解函数指针的概念： 1 int funtion( int x, int y ); 2 void main ( void )&nbsp; 　{ 3 　　　int (*fun) ( int x, int y ); 4 　　　int a = 10, b = 20; 5 　　　function( a, b ); 6 　　　fun = function; 7 　　　（*fun）( a, b ); 8 　　　　…… 　　} 　　语句1定义了一个函数function，其输入为两个整型数，返回也为一个整型数（输入参数和返回值可为其它任何数据类型）；语句3定义了一个函数指针，与int*或double*定义指针不同的是，函数指针的定义必须同时指出输入参数，表明这是一个函数指针，并且*fun也必须用一对括号括起来；语句6将函数指针赋值为funtion，前提条件是*fun和function的输入参数和返回值必须保持一致。语句5直接调用函数function（），语句7是调用函数指针，二者等效。 　　当然从上述例子看不出函数指针的优点，目的主要是想引出函数指针数组的概念。我们从上面例子可以得知，既然函数名可以通过函数指针加以保存，那们也一定能定义一个数组保存若干个函数名，这就是函数指针数组。正确使用函数指针数组的前提条件是，这若干个需要通过函数指针数组保存的函数必须有相同的输入、输出值。 这样，我工作中所面临的问题可以解决如下： 首先定义256个处理函数(及其实现)。 void funtion0( void ); …….. void funtion255(void ); 其次定义函数指针数组，并给数组赋值。 void (*fun[256])(void); fun[0] = function0; ……. fun[255] = function(); 最后，MyFunction()函数可以修改如下： void MyFuntion( char* buffer, int length ) { 　　　　__int8 nStreamType = buffer[0]; 　　　　（*fun[nStreamType]）(); } 　　只要2行代码，就完成了256条case语句要做的事，减少了编写代码时工作量，将nStreamType作为数组下标，直接调用函数指针，从代码执行效率上来说，也比case语句高。假如多个函数中均要作如此处理，函数指针数组更能体现出它的优势。 &nbsp; 
 <div> 
 [此贴子已经被作者于2004-12-29 14:16:28编辑过] 
 </div> 
 <hr> </td> 
 </tr> 
 <tr> 
 <td>--&nbsp;&nbsp; 作者：admin --&nbsp;&nbsp; 发布时间：2004-12-29 14:02:00 --&nbsp;&nbsp; <a href="http://blog.csdn.net/csumck/archive/2004/10/28/157157.aspx" rel="nofollow">关于C++中函数指针的使用</a>&nbsp; 关于C++中函数指针的使用(包含对typedef用法的讨论)&nbsp; （一）简单的函数指针的应用。//形式1：返回类型(*函数名)(参数表)&nbsp; char (*pFun)(int);&nbsp; char glFun(int a){ return;}&nbsp; void main()&nbsp; {&nbsp; &nbsp;&nbsp;&nbsp;&nbsp; pFun = glFun;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp; (*pFun)(2);&nbsp; }&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 第一行定义了一个指针变量pFun。首先我们根据前面提到的“形式1”认识到它是一个指向某种函数的指针，这种函数参数是一个int型，返回值是char类型。只有第一句我们还无法使用这个指针，因为我们还未对它进行赋值。 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 第二行定义了一个函数glFun()。该函数正好是一个以int为参数返回char的函数。我们要从指针的层次上理解函数——函数的函数名实际上就是一个指针，函数名指向该函数的代码在内存中的首地址。 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 然后就是可爱的main()函数了，它的第一句您应该看得懂了——它将函数glFun的地址赋值给变量pFun。main()函数的第二句中“*pFun”显然是取pFun所指向地址的内容，当然也就是取出了函数glFun()的内容，然后给定参数为2。 （二）使用typedef更直观更方便。&nbsp; //形式2：typedef 返回类型(*新类型)(参数表)typedef char (*PTRFUN)(int);&nbsp; PTRFUN pFun;&nbsp; char glFun(int a){ return;}&nbsp; void main()&nbsp; {&nbsp; &nbsp;&nbsp;&nbsp;&nbsp; pFun = glFun;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp; (*pFun)(2);&nbsp; }&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; typedef的功能是定义新的类型。第一句就是定义了一种PTRFUN的类型，并定义这种类型为指向某种函数的指针，这种函数以一个int为参数并返回char类型。后面就可以像使用int,char一样使用PTRFUN了。 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 第二行的代码便使用这个新类型定义了变量pFun，此时就可以像使用形式1一样使用这个变量了。 （三）在C++类中使用函数指针。&nbsp; //形式3：typedef 返回类型(类名::*新类型)(参数表)&nbsp; class CA { public:&nbsp; &nbsp;&nbsp;&nbsp;&nbsp; char lcFun(int a){ return; }&nbsp; };&nbsp; CA ca; typedef char (CA::*PTRFUN)(int);&nbsp; PTRFUN pFun;&nbsp; void main()&nbsp; {&nbsp; &nbsp;&nbsp;&nbsp;&nbsp; pFun = CA::lcFun;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp; ca.(*pFun)(2);&nbsp; }&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 在这里，指针的定义与使用都加上了“类限制”或“对象”，用来指明指针指向的函数是那个类的这里的类对象也可以是使用new得到的。比如：&nbsp; CA *pca = new CA;&nbsp; pca-&gt;(*pFun)(2);&nbsp; delete pca;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 而且这个类对象指针可以是类内部成员变量，你甚至可以使用this指针。比如： &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 类CA有成员变量PTRFUN m_pfun;&nbsp; void CA::lcFun2()&nbsp; {&nbsp; &nbsp;&nbsp; (this-&gt;*m_pFun)(2); } &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 一句话，使用类成员函数指针必须有“-&gt;*”或“.*”的调用。 
 <hr> </td> 
 </tr> 
 <tr> 
 <td>--&nbsp;&nbsp; 作者：admin --&nbsp;&nbsp; 发布时间：2004-12-29 14:07:00 --&nbsp;&nbsp; 
 <table style="width: 100%;"> 
 <tbody> 
 <tr> 
 <td colspan="2">指针函数和函数指针有什么区别</td> 
 </tr> 
 <tr> 
 <td colspan="2">副标题：</td> 
 </tr> 
 <tr> 
 <td colspan="2">作者：wuhongyi 文章来源：本站原创 点击数： 更新时间：2004-11-2</td> 
 </tr> 
 <tr> 
 <td colspan="2">&nbsp;</td> 
 </tr> 
 <tr> 
 <td colspan="2">&nbsp;</td> 
 </tr> 
 <tr> 
 <td> 1,这两个概念都是简称，指针函数是指带指针的函数，即本质是一个函数。我们知道函数都又返回类型（如果不返回值，则为无值型），只不过指针函数返回类型是某一类型的指针。其定义格式如下所示： &nbsp;&nbsp;&nbsp;&nbsp; 返回类型标识符 *返回名称（形式参数表） &nbsp;&nbsp;&nbsp;&nbsp; {&nbsp;&nbsp;&nbsp;&nbsp; 函数体&nbsp;&nbsp;&nbsp;&nbsp; } 返回类型可以是任何基本类型和复合类型。返回指针的函数的用途十分广泛。事实上，每一个函数，即使它不带有返回某种类型的指针，它本身都有一个入口地址，该地址相当于一个指针。比如函数返回一个整型值，实际上也相当于返回一个指针变量的值，不过这时的变量是函数本身而已，而整个函数相当于一个“变量”。例如下面一个返回指针函数的例子： #include&lt;stdio.h&gt; float *find(); main() { &nbsp;&nbsp;&nbsp;&nbsp; static float score[][4]={ {60,70,80,90},{56,89,34,45},{34,23,56,45}}; &nbsp;&nbsp;&nbsp;&nbsp; float *p; &nbsp;&nbsp;&nbsp;&nbsp; int i,m; &nbsp;&nbsp;&nbsp;&nbsp; printf("Enter the number to be found:"); &nbsp;&nbsp;&nbsp;&nbsp; scanf("%d",&amp;m); &nbsp;&nbsp;&nbsp;&nbsp; printf("the score of NO.%d are://n",m); &nbsp;&nbsp;&nbsp;&nbsp; p=find(score,m); &nbsp;&nbsp;&nbsp;&nbsp; for(i=0;i&lt;4;i++) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; printf("%5.2f//t",*(p+i)); } float *find(float(*pionter)[4],int n)/*定义指针函数*/ { &nbsp;&nbsp;&nbsp;&nbsp; float *pt; &nbsp;&nbsp;&nbsp;&nbsp; pt=*(pionter+n); &nbsp;&nbsp;&nbsp;&nbsp; return(pt); } 学生学号从0号算起，函数find()被定义为指针函数，起形参pointer是指针指向包含4个元素的一维数组的指针变量。pointer+1指向score的第一行。*(pointer+1)指向第一行的第0个元素。pt是一个指针变量，它指向浮点型变量。main()函数中调用find()函数，将score数组的首地址传给pointer. &nbsp;&nbsp;&nbsp;&nbsp; 2,“函数指针”是指向函数的指针变量，因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。如前所述，C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上一致的。函数指针有两个用途：调用函数和做函数的参数。函数指针的说明方法为: &nbsp;&nbsp;&nbsp;&nbsp; 数据类型标志符 （*指针变量名）（参数）；注：函数括号中的参数可有可无，视情况而定。 下面的程序说明了函数指针调用函数的方法： #include&lt;stdio.h&gt; int max(int x,int y){&nbsp;&nbsp;&nbsp;&nbsp; return(x&gt;y?x:y);&nbsp;&nbsp;&nbsp;&nbsp; } void main() { &nbsp;&nbsp;&nbsp;&nbsp; int (*ptr)(); &nbsp;&nbsp;&nbsp;&nbsp; int a,b,c; &nbsp;&nbsp;&nbsp;&nbsp; ptr=max; &nbsp;&nbsp;&nbsp;&nbsp; scanf("%d,%d",&amp;a,&amp;b); &nbsp;&nbsp;&nbsp;&nbsp; c=(*ptr)(a,b); &nbsp;&nbsp;&nbsp;&nbsp; printf("a=%d,b=%d,max=%d",a,b,c); } ptr是指向函数的指针变量，所以可把函数max()赋给ptr作为ptr的值，即把max()的入口地址赋给ptr,以后就可以用ptr来调用该函数，实际上ptr和max都指向同一个入口地址，不同就是ptr是一个指针变量，不像函数名称那样是死的，它可以指向任何函数，就看你像怎么做了。在程序中把哪个函数的地址赋给它，它就指向哪个函数。而后用指针变量调用它，因此可以先后指向不同的函数，不过注意，指向函数的指针变量没有++和--运算，用时要小心。 </td> 
 </tr> 
 </tbody> 
 </table> 
 <hr> </td> 
 </tr> 
 <tr> 
 <td>--&nbsp;&nbsp; 作者：admin --&nbsp;&nbsp; 发布时间：2004-12-29 14:25:00 --&nbsp;&nbsp; 
 <table style="width: 99%;"> 
 <tbody> 
 <tr> 
 <td align="middle">C++的效率浅析</td> 
 </tr> 
 <tr> 
 <td align="middle">&nbsp;</td> 
 </tr> 
 <tr> 
 <td>&lt;!-- ads --&gt;&nbsp; 
 <table> 
 <tbody> 
 <tr> 
 <td>&nbsp;</td> 
 </tr> 
 </tbody> 
 </table> &lt;!-- ads --&gt; &nbsp; 
 <hr> &nbsp; 自从七十年代C语言诞生以来，一直以其灵活性、高效率和可移植性为软件开发人员所钟爱，成为系统软件开发的首选工具。而C++作为C语言的继承和发展，不仅保留了C语言的高度灵活、高效率和易于理解等诸多优点，还包含了几乎所有面向对象的特征，成为新一代软件系统构建的利器。&nbsp; 　　相对来说，C语言是一种简洁的语言，所涉及的概念和元素比较少，主要是：宏(macro)、指针(pointer)、结构(struct)、函数(function)和数组(array)，比较容易掌握和理解。而C++不仅包含了上面所提到的元素，还提供了私有成员(private members)、公有成员(public members)、函数重载(function overloading)、缺省参数(default parameters)、构造函数、析构函数、对象的引用(references)、操作符重载(operator overloading)、友元(friends)、模板(templates)、异常处理(exceptions)等诸多的要素，给程序员提供了更大的设计空间，同时也增加了软件设计的难度。&nbsp; 　　C语言之所以能被广泛的应用，其高效率是一个不可忽略的原因，C语言的效率能达到汇编语言的80%以上，对于一种高级语言来说，C语言的高效率就不言而喻了。那么，C++相对于C来说，其效率如何呢？实际上，C++的设计者stroustrup要求C++效率必须至少维持在与C相差5%以内，所以，经过精心设计和实现的C++同样有很高的效率，但并非所有C++程序具有当然的高效率，由于C++的特殊性，一些不好的设计和实现习惯依然会对系统的效率造成较大的影响。同时，也由于有一部分程序员对C++的一些底层实现机制不够了解，就不能从原理上理解如何提高软件系统的效率。&nbsp; 　　本文主要讨论两个方面的问题：第一，对比C++的函数调用和C函数调用，解析C++的函数调用机制；第二，例举一些C++程序员不太注意的技术细节，解释如何提高C++的效率。为方便起见，本文的讨论以下面所描述的单一继承为例(多重继承有其特殊性，另作讨论)。&nbsp; 
 <table style="width: 550px;"> 
 <tbody> 
 <tr> 
 <td> <pre>class X {
 public: &nbsp;&nbsp; virtual ~X(); //析构函数 &nbsp;&nbsp; virtual void VirtualFunc(); //虚函数 &nbsp;&nbsp; inline int InlineFunc() { return m_iMember}; //内联函数 &nbsp;&nbsp; void NormalFunc(); //普通成员函数 &nbsp;&nbsp; static void StaticFunc(); //静态函数 private: &nbsp;&nbsp; int m_iMember; }; class XX: public X {
 public: &nbsp;&nbsp; XX(); &nbsp;&nbsp; virtual ~XX(); &nbsp;&nbsp; virtual void VirtualFunc(); private: &nbsp;&nbsp; String&nbsp;&nbsp; m_strName; &nbsp;&nbsp; int&nbsp;&nbsp; m_iMember2; };</pre> </td> 
 </tr> 
 </tbody> 
 </table> C++的的函数分为四种：内联函数(inline member function)、静态成员函数(static member function)、虚函数(virtual member function)和普通成员函数。&nbsp; 　　内联函数类似于C语言中的宏定义函数调用，C++编译器将内联函数的函数体扩展在函数调用的位置，使内联函数看起来象函数，却不需要承受函数调用的开销，对于一些函数体比较简单的内联函数来说，可以大大提高内联函数的调用效率。但内联函数并非没有代价，如果内联函数体比较大，内联函数的扩展将大大增加目标文件和可运行文件的大小；另外，inline关键字对编译器只是一种提示，并非一个强制指令，也就是说，编译器可能会忽略某些inline关键字，如果被忽略，内联函数将被当作普通的函数调用，编译器一般会忽略一些复杂的内联函数，如函数体中有复杂语句，包括循环语句、递归调用等。所以，内联函数的函数体定义要简单，否则在效率上会得不偿失。&nbsp; 　　静态函数的调用，如下面的几种方式：&nbsp; 
 <table style="width: 550px;"> 
 <tbody> 
 <tr> 
 <td> <pre>X obj; X* ptr = &amp;obj; obj.StaticFunc(); ptr-&gt;StaticFunc(); X::StaticFunc();</pre> </td> 
 </tr> 
 </tbody> 
 </table> 　　将被编译器转化为一般的C函数调用形式，如同这样：&nbsp; 
 <table style="width: 550px;"> 
 <tbody> 
 <tr> 
 <td> <pre>mangled_name_of_X_StaticFunc(); 　　&nbsp;&nbsp; //obj.StaticFunc(); mangled_name_of_X_StaticFunc(); 　　 // ptr-&gt;StaticFunc(); mangled_name_of_X_StaticFunc();&nbsp;&nbsp; 　　// X::StaticFunc();</pre> </td> 
 </tr> 
 </tbody> 
 </table> mangled_name_of_X_StaticFunc()是指编译器将X::StaticFunc()函数经过变形(mangled)后的内部名称(C++编译器保证每个函数将被mangled为独一无二的名称，不同的编译器有不同的算法，C++标准并没有规定统一的算法，所以mangled之后的名称也可能不同)。可以看出，静态函数的调用同普通的C函数调用有完全相同的效率，并没有额外的开销。&nbsp; 　　普通成员函数的调用，如下列方式：&nbsp; 
 <table style="width: 550px;"> 
 <tbody> 
 <tr> 
 <td> <pre>X obj; X* ptr = &amp;obj; obj.NormalFunc(); ptr-&gt;NormalFunc();</pre> </td> 
 </tr> 
 </tbody> 
 </table> 　　将被被编译器转化为如下的C函数调用形式，如同这样。&nbsp; 
 <table style="width: 550px;"> 
 <tbody> 
 <tr> 
 <td> <pre>mangled_name_of_X_NormalFunc(&amp;obj); 　　 //obj.NormalFunc(); mangled_name_of_X_NormalFunc(ptr); // ptr-&gt;NormalFunc();</pre> </td> 
 </tr> 
 </tbody> 
 </table> 可以看出普通成员函数的调用同普通的C调用没有大的区别，效率与静态函数也相同。编译器将重新改写函数的定义，增加一个const X* this参数将调用对象的地址传送进函数。&nbsp; 　　虚函数的调用稍微复杂一些，为了支持多态性，实现运行时刻绑定，编译器需要在每个对象上增加一个字段也就是vptr以指向类的虚函数表vtbl，如类X的对象模型如下图所示(本文中对此不多做解释，若想进一步了解，可以参考其它材料)。&nbsp; <img src="http://tech.ccidnet.com/pub/attachment/2003/5/183143.gif" alt="">&nbsp; 　　虚函数的多态性只能通过对象指针或对象的引用调用来实现，如下的调用：&nbsp; 
 <table style="width: 550px;"> 
 <tbody> 
 <tr> 
 <td> <pre>X obj; X* ptr = &amp;obj; X&amp; ref = obj; ptr-&gt;VirtualFunc(); ref.VirtualFunc();</pre> </td> 
 </tr> 
 </tbody> 
 </table> 　　将被C++编译器转换为如下的形式。&nbsp; 
 <table style="width: 550px;"> 
 <tbody> 
 <tr> 
 <td> <pre>( *ptr-&gt;vptr[2] )(ptr); ( *ptr-&gt;vptr[2] )(&amp;ref);</pre> </td> 
 </tr> 
 </tbody> 
 </table> 其中的2表示VirtualFunc在类虚函数表的第2个槽位。可以看出，虚函数的调用相当于一个C的函数指针调用，其效率也并未降低。&nbsp; 　　由以上的四个例子可以看出，C++的函数调用效率依然很高。但C++还是有其特殊性，为了保证面向对象语义的正确性，C++编译器会在程序员所编写的程序基础上，做大量的扩展，如果程序员不了解编译器背后所做的这些工作，就可能写出效率不高的程序。对于一些继承层次很深的派生类或在成员变量中包含了很多其它类对象(如XX中的m_strName变量)的类来说，对象的创建和销毁的开销是相当大的，比如XX类的缺省构造函数，即使程序员没有定义任何语句，编译器依然会给其构造函数扩充以下代码来保证对象语义的正确性：&nbsp; 
 <table style="width: 550px;"> 
 <tbody> 
 <tr> 
 <td> <pre>XX::XX() {
 // 编译器扩充代码所要做的工作 1、 调用父类X的缺省构造函数 2、 设定vptr指向XX类虚函数表 3、 调用String类的缺省构造函数构造m_strName };</pre> </td> 
 </tr> 
 </tbody> 
 </table> 　　所以为了提高效率，减少不必要的临时对象的产生、拖延暂时不必要的对象定义、用初始化代替赋值、使用构造函数初始化列表代替在构造函数中赋值等方法都能有效提高程序的运行效率。以下举例说明：&nbsp; 　　1、 减少临时对象的生成。如以传送对象引用的方式代替传值方式来定义函数的参数，如下例所示，传值方式将导致一个XX临时对象的产生&nbsp; 
 <table style="width: 550px;"> 
 <tbody> 
 <tr> 
 <td> <pre>效率不高的做法&nbsp;&nbsp; 　　　　高效率做法 void Function( XX xx )&nbsp;&nbsp; void Function( const XX&amp; xx ) {&nbsp;&nbsp;&nbsp;&nbsp; {
 //函数体&nbsp;&nbsp;&nbsp;&nbsp; //函数体 }&nbsp;&nbsp;&nbsp;&nbsp; }</pre> </td> 
 </tr> 
 </tbody> 
 </table> 　　2、 拖延暂时不必要的对象定义。在C中要将所有的局部变量定义在函数体头部，考虑到C++中对象创建的开销，这不是一个好习惯。如下例，如果大部分情况下bCache为"真"，则拖延xx的定义可以大大提高函数的效率。&nbsp; 
 <table style="width: 550px;"> 
 <tbody> 
 <tr> 
 <td> <pre>效率不高的做法&nbsp;&nbsp;&nbsp;&nbsp; 高效率做法 void Function( bool bCache )&nbsp;&nbsp; void Function( bool bCache ) {&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {
 //函数体&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; //函数体 XX xx;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if( bCache ) if(&nbsp;&nbsp; bCache )&nbsp;&nbsp;&nbsp;&nbsp; {// do something without xx {&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return; // do something without xx&nbsp;&nbsp;&nbsp; } &nbsp;&nbsp;&nbsp;&nbsp; return; } //对xx进行操作&nbsp;&nbsp;&nbsp;&nbsp; XX xx; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; //对xx进行操作 … return;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return; }&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }</pre> </td> 
 </tr> 
 </tbody> 
 </table> 　　3、 可能情况下，以初始化代替先定义后赋值。如下例，高效率的做法会比效率不高的做法省去了cache变量的缺省构造函数调用开销。&nbsp; 
 <table style="width: 550px;"> 
 <tbody> 
 <tr> 
 <td> <pre>效率不高的做法&nbsp;&nbsp;&nbsp; 高效率做法 void Function( const XX&amp; xx ) void Function( const XX&amp; xx ) {&nbsp;&nbsp;&nbsp;&nbsp; {
 XX cache; &nbsp;&nbsp;&nbsp; XX cache = xx; cache = xx ; }&nbsp;&nbsp;&nbsp;&nbsp; }</pre> </td> 
 </tr> 
 </tbody> 
 </table> 4、 在构造函数中使用成员变量的初始化列表代替在构造函数中赋值。如下例，在效率不高的做法中，XX的构造函数会首先调用m_strName的缺省构造函数，再产生一个临时的String object，用空串""初始化临时对象，再以临时对象赋值(assign)给m_strName，然后销毁临时对象。而高效的做法只需要调用一次m_strName的构造函数。&nbsp; 
 <table style="width: 550px;"> 
 <tbody> 
 <tr> 
 <td> <pre>效率不高的做法&nbsp;&nbsp; 高效率做法 XX::XX()&nbsp;&nbsp;&nbsp; XX::XX() : m_strName( "" ) {&nbsp;&nbsp;&nbsp; {
 m_strName = ""; &nbsp;&nbsp; … … }&nbsp;&nbsp;&nbsp; }</pre> </td> 
 </tr> 
 </tbody> 
 </table> 　　类似的例子还很多，如何写出高效的C++程序需要实践和积累，但理解C++的底层运行机制是一个不可缺少的步骤，只要平时多学习和思考，编写高效的C++程序是完全可行的。 </td> 
 </tr> 
 </tbody> 
 </table> </td> 
 </tr> 
 </tbody> 
 </table> 
 </div> </td> 
 </tr> 
 </tbody> 
</table>

[http_blog.163.com_yqli520_2006_blog_static_502877772007112013129764]: http://blog.163.com/yqli520_2006/blog/static/502877772007112013129764/
[http_www.yuanma.org_data_2006_1213_article_1946.htm]: http://www.yuanma.org/data/2006/1213/article_1946.htm
[C]: http://www.cnblogs.com/alon/archive/2009/04/24/1442696.html
[http_hi.baidu.com_seraphsky_blog_item_667617cbc49c901bbf09e6f8.html]: http://hi.baidu.com/seraphsky/blog/item/667617cbc49c901bbf09e6f8.html