c++效率,函数指针

约定不等于承诺〃 2022-09-18 09:53 80阅读 0赞

# c++效率,函数指针 #

<table style="TABLE-LAYOUT: fixed; WORD-BREAK: break-all"> 
 <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 ) 　{ 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语句高。假如多个函数中均要作如此处理，函数指针数组更能体现出它的优势。 
 <div> 
 
 </div> 
 <hr></td> 
 </tr> 
 <tr> 
 <td> <a href="http://blog.csdn.net/csumck/archive/2004/10/28/157157.aspx" rel="nofollow">关于C++中函数指针的使用</a> 关于C++中函数指针的使用(包含对typedef用法的讨论) （一）简单的函数指针的应用。//形式1：返回类型(*函数名)(参数表) char (*pFun)(int); char glFun(int a){ return;} void main() { &nbsp;&nbsp;&nbsp;&nbsp;pFun = glFun; &nbsp;&nbsp;&nbsp;&nbsp;(*pFun)(2); } &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更直观更方便。 //形式2：typedef 返回类型(*新类型)(参数表)typedef char (*PTRFUN)(int); PTRFUN pFun; char glFun(int a){ return;} void main() { &nbsp;&nbsp;&nbsp;&nbsp;pFun = glFun; &nbsp;&nbsp;&nbsp;&nbsp;(*pFun)(2); } &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++类中使用函数指针。 //形式3：typedef 返回类型(类名::*新类型)(参数表) class CA { public: &nbsp;&nbsp;&nbsp;&nbsp;char lcFun(int a){ return; } }; CA ca; typedef char (CA::*PTRFUN)(int); PTRFUN pFun; void main() { &nbsp;&nbsp;&nbsp;&nbsp;pFun = CA::lcFun; &nbsp;&nbsp;&nbsp;&nbsp;ca.(*pFun)(2); } &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;在这里，指针的定义与使用都加上了“类限制”或“对象”，用来指明指针指向的函数是那个类的这里的类对象也可以是使用new得到的。比如： CA *pca = new CA; pca-&gt;(*pFun)(2); delete pca; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;而且这个类对象指针可以是类内部成员变量，你甚至可以使用this指针。比如： &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;类CA有成员变量PTRFUN m_pfun; void CA::lcFun2() { &nbsp;&nbsp; (this-&gt;*m_pFun)(2); } &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;一句话，使用类成员函数指针必须有“-&gt;*”或“.*”的调用。 
 <hr> </td> 
 </tr> 
 <tr> 
 <td> &nbsp; &nbsp; 
 <table> 
 <tbody> 
 <tr> 
 <td style="WORD-BREAK: break-all" 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; 
 <table> 
 <tbody> 
 <tr> 
 <td align="center">C++的效率浅析</td> 
 </tr> 
 <tr> 
 <td align="center">&nbsp;</td> 
 </tr> 
 <tr> 
 <td> &nbsp; 
 <hr> &nbsp; 自从七十年代C语言诞生以来，一直以其灵活性、高效率和可移植性为软件开发人员所钟爱，成为系统软件开发的首选工具。而C++作为C语言的继承和发展，不仅保留了C语言的高度灵活、高效率和易于理解等诸多优点，还包含了几乎所有面向对象的特征，成为新一代软件系统构建的利器。 　　相对来说，C语言是一种简洁的语言，所涉及的概念和元素比较少，主要是：宏(macro)、指针(pointer)、结构(struct)、函数(function)和数组(array)，比较容易掌握和理解。而C++不仅包含了上面所提到的元素，还提供了私有成员(private members)、公有成员(public members)、函数重载(function overloading)、缺省参数(default parameters)、构造函数、析构函数、对象的引用(references)、操作符重载(operator overloading)、友元(friends)、模板(templates)、异常处理(exceptions)等诸多的要素，给程序员提供了更大的设计空间，同时也增加了软件设计的难度。 　　C语言之所以能被广泛的应用，其高效率是一个不可忽略的原因，C语言的效率能达到汇编语言的80%以上，对于一种高级语言来说，C语言的高效率就不言而喻了。那么，C++相对于C来说，其效率如何呢？实际上，C++的设计者stroustrup要求C++效率必须至少维持在与C相差5%以内，所以，经过精心设计和实现的C++同样有很高的效率，但并非所有C++程序具有当然的高效率，由于C++的特殊性，一些不好的设计和实现习惯依然会对系统的效率造成较大的影响。同时，也由于有一部分程序员对C++的一些底层实现机制不够了解，就不能从原理上理解如何提高软件系统的效率。 　　本文主要讨论两个方面的问题：第一，对比C++的函数调用和C函数调用，解析C++的函数调用机制；第二，例举一些C++程序员不太注意的技术细节，解释如何提高C++的效率。为方便起见，本文的讨论以下面所描述的单一继承为例(多重继承有其特殊性，另作讨论)。 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre>
 class X {
 &nbsp;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(); //静态函数 &nbsp;private: &nbsp;&nbsp;int &nbsp;m_iMember; }; class XX: public X {
 &nbsp;public: &nbsp;&nbsp;XX(); &nbsp;&nbsp;virtual ~XX(); &nbsp;&nbsp;virtual void VirtualFunc(); &nbsp;private: &nbsp;&nbsp;String&nbsp;&nbsp;m_strName; &nbsp;&nbsp;int&nbsp;&nbsp; &nbsp;m_iMember2; };</pre> </td> 
 </tr> 
 </tbody> 
 </table> 　　C++的的函数分为四种：内联函数(inline member function)、静态成员函数(static member function)、虚函数(virtual member function)和普通成员函数。 　　内联函数类似于C语言中的宏定义函数调用，C++编译器将内联函数的函数体扩展在函数调用的位置，使内联函数看起来象函数，却不需要承受函数调用的开销，对于一些函数体比较简单的内联函数来说，可以大大提高内联函数的调用效率。但内联函数并非没有代价，如果内联函数体比较大，内联函数的扩展将大大增加目标文件和可运行文件的大小；另外，inline关键字对编译器只是一种提示，并非一个强制指令，也就是说，编译器可能会忽略某些inline关键字，如果被忽略，内联函数将被当作普通的函数调用，编译器一般会忽略一些复杂的内联函数，如函数体中有复杂语句，包括循环语句、递归调用等。所以，内联函数的函数体定义要简单，否则在效率上会得不偿失。 　　静态函数的调用，如下面的几种方式： 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre>
 X obj; X* ptr = &amp;obj; obj.StaticFunc(); ptr-&gt;StaticFunc(); X::StaticFunc();</pre> </td> 
 </tr> 
 </tbody> 
 </table> 　　将被编译器转化为一般的C函数调用形式，如同这样： 
 <table> 
 <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函数调用有完全相同的效率，并没有额外的开销。 　　普通成员函数的调用，如下列方式： 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre>
 X obj; X* ptr = &amp;obj; obj.NormalFunc(); ptr-&gt;NormalFunc();</pre> </td> 
 </tr> 
 </tbody> 
 </table> 　　将被被编译器转化为如下的C函数调用形式，如同这样。 
 <table> 
 <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参数将调用对象的地址传送进函数。 　　虚函数的调用稍微复杂一些，为了支持多态性，实现运行时刻绑定，编译器需要在每个对象上增加一个字段也就是vptr以指向类的虚函数表vtbl，如类X的对象模型如下图所示(本文中对此不多做解释，若想进一步了解，可以参考其它材料)。 <img style="CURSOR: pointer" alt="" src="http://tech.ccidnet.com/pub/attachment/2003/5/183143.gif"> 　　虚函数的多态性只能通过对象指针或对象的引用调用来实现，如下的调用： 
 <table> 
 <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++编译器转换为如下的形式。 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre>
 ( *ptr-&gt;vptr[2] )(ptr); ( *ptr-&gt;vptr[2] )(&amp;ref);</pre> </td> 
 </tr> 
 </tbody> 
 </table> 　　其中的2表示VirtualFunc在类虚函数表的第2个槽位。可以看出，虚函数的调用相当于一个C的函数指针调用，其效率也并未降低。 　　由以上的四个例子可以看出，C++的函数调用效率依然很高。但C++还是有其特殊性，为了保证面向对象语义的正确性，C++编译器会在程序员所编写的程序基础上，做大量的扩展，如果程序员不了解编译器背后所做的这些工作，就可能写出效率不高的程序。对于一些继承层次很深的派生类或在成员变量中包含了很多其它类对象(如XX中的m_strName变量)的类来说，对象的创建和销毁的开销是相当大的，比如XX类的缺省构造函数，即使程序员没有定义任何语句，编译器依然会给其构造函数扩充以下代码来保证对象语义的正确性： 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre>
 XX::XX() {
 &nbsp;// 编译器扩充代码所要做的工作 &nbsp; 1、&nbsp;调用父类X的缺省构造函数 2、&nbsp;设定vptr指向XX类虚函数表 3、&nbsp;调用String类的缺省构造函数构造m_strName };</pre> </td> 
 </tr> 
 </tbody> 
 </table> 　　所以为了提高效率，减少不必要的临时对象的产生、拖延暂时不必要的对象定义、用初始化代替赋值、使用构造函数初始化列表代替在构造函数中赋值等方法都能有效提高程序的运行效率。以下举例说明： 　　1、 减少临时对象的生成。如以传送对象引用的方式代替传值方式来定义函数的参数，如下例所示，传值方式将导致一个XX临时对象的产生 
 <table> 
 <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的定义可以大大提高函数的效率。 
 <table> 
 <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变量的缺省构造函数调用开销。 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre>
 效率不高的做法&nbsp;&nbsp;&nbsp;高效率做法 void Function( const XX&amp; xx )&nbsp;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的构造函数。 
 <table> 
 <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>