经验分享从c到c++

      C++技术固然是很时髦的，许多C用户都想在尽可能短的时间内为自己贴上C++的标签。介绍C++的书很多，但只有那些已经侥幸入门的用户才偶尔去翻翻，仍有不少在C++门口徘徊的流浪汉。

　　本文只针对C用户，最好是一位很不错的老用户（譬如他在遇到最简单的问题时都尝试着使用指针），通过一些C和更好的C++（本文用的是Borland C++3.1版本）例程介绍有关C++的一些知识，让读者朋友们“浅入深出”，轻轻松松C to C++！

　　一、标签！标签！

　　快快为你的程序贴上C++的标签，让你看起来很像个合格的C++用户……

　　1.注释（comment）

　　C++的注释允许采取两种形式。第一种是传统C采用的/*和*/，另一种新采用的则是//，它表示从//至行尾皆为注释部分。读者朋友完全可以通过//使你的代码带上C++的气息，如test0l：

　　//test01.cpp 
　　#include <iostream.h> 
　　//I'm a C++user! 
　　//…and C is out of date. 
　　void main()  
　　{  
　　cout<<"Hello world!\n"; //prints a string 
　　}  
　　Hello-world！ 

　　如果你尝试着在test0l. exe中找到这些高级的注释，很简单，它们不会在那里的。

　　2. cincout

　　你可能从test0l中嗅出什么味儿来了，在C++中，其次的贵族是cout，而不是很老土的printf （ ）。左移操作符‘<<’的含义被重写，称作“输出操作符”或“插入操作符”。你可以使用‘<<’将一大堆的数据像糖葫芦一样串起来，然后再用cout输出：

　　cout << "ASCII code of "<< 'a' << " is:" <<97;   
　　ASCII code of a is:97  

　　如何来输出一个地址的值呢?在C中可以通过格式控制符”%p”来实现，如:

　　printf ("%p，&i); 

　　类似地，C++也是这样:

　　cout << & i; 

　　但对字符串就不同啦!因为:

　　char * String="Waterloo Bridge";  
　　cout << String; //prints ‘Waterloo Bridge'

　　只会输出String的内容。但方法还是有的，如采取强制类型转换:

　　cout<<(void *)String; 

　　cin采取的操作符是’>>’，称作“输入操作符”或“提取操作符”。在头文件iostream.h中有cin cout的原型定义，cin语句的书写格式与cout的完全一样:

　　cin>>i; //ok 
　　cin>>&i; //error. Illegal structure operation

　　看到了?别再傻傻地送一个scanf()常用的’&’地址符给它。

　　C++另外提供了一个操纵算子endl，它的功能和’\n’完全一样，如test0l中的cout语句可改版为:

　　cout << ”Hello world!”< 

　　3.即时声明
　　
　　这是笔者杜撰的一个术语，它的原文为declarations mixed with statements，意即允许变量的声明与语句的混合使用。传统C程序提倡用户将声明和语句分开，如下形式:

　　int i=100;  
　　float f; //declarations  
　　i++;  
　　f=1.0/i; //statements 

　　而C抛弃这点可读性，允许用户采取更自由的书写形式：

　　int i=100;  
　　i++;  
　　float f =1. 0/i;  

　　即时声明常见于for循环语句中：

　　for(int i = 0; i < 16; i++)  
　　for(int j = 0; j < 16; j++)  
　　putpixel(j i Color[i][j]);  

　　这种形式允许在语句段中任点声明新的变量并不失时机地使用它（而不必在所有的声明结束之后）。

　　特别地，C++强化了数据类型的类概念，对于以上出现的“int i=1 j=2；”完全可以写成：int i（1） j （2）；再如：

　　char * Stringl("Youth Studio.”);  
　　char String2[]("Computer Fan.“);  

　　这不属于“即时声明”的范畴，但这些特性足以让你的代码与先前愚昧的C产品区别开来。

　　4.作用域（scope）及其存取操作符（scope qualifier operator）

　　即时声明使C语言的作用域的概念尤显重要，例如以下语句包含着一条错误，因为ch变量在if块外失去了作用域。

　　if(ok)  
　　char ch='!';  
　　else
　　ch='?'; //error. access outside condition 

　　作用域对应于某一变量的生存周期，它通常表现为以下五种: 
　　块作用域：开始于声明点，结束于块尾，块是由{}括起的一段区域 
　　函数作用域：函数作用域只有语句标号，标号名可以和goto语句一起在函数体任何地方 
　　函数原型作用域：在函数原型中的参量说明表中声明的标识符具有函数原型作用域 
　　文件作用域：在所有块和类的外部声明的标识符(全局变量)具有文件作用域 
　　类作用域：类的成员具有类作用域

　　具有不同作用域的变量可以同名，如test02:

　　//test02.cpp 
　　#include <iostream.h> 
　　int i=0;  
　　void main()  
　　{  
　　cout << i << ' '; //global 'int i' visible 
　　{  
　　float i(0.01); //global 'int i' overrided 
　　cout<< i << ' ';  
　　}  
　　cout<<i<<endl; //global 'int i' visible again 
　　}  
　　//输出结果 0 0.01 0 

　　编译器并未给出错误信息。

　　作用域与可见性并不是同一概念，具有作用域不一定具有可见性，而具有可见性一定具有作用域。

　　在test02中，float i的使用使全局int i失去可见性，这种情形被称作隐藏（override）。但这并不意味着int i失去了作用域，在main（）函数运行过程中，int i始终存在。

　　有一种办法来引用这丢了名份的全局i，即使用C++提供的作用域存取操作符：：，它表示引用的变量具有文件作用域，如下例程：

　　//test03.cpp 
　　#include <iostream.h> 
　　enum {boy girl};  
　　char i = boy;  
　　void main()  
　　{  
　　{  
　　float i(0.01);  
　　cout << "i=" << i << endl;  
　　::i=girl; //modify global 'i' 
　　}  
　　cout << "I am a " << (i ? "girl." : "boy.");  
　　}  
　　输出结果：  
　　i=0.01  
　　I am a girl. 

　　在上例中，通过：：操作符，第8行语句偷偷地改写了i所属的性别。更妙的是，：：之前还可以加上某些类的名称，它表示引用的变量是该类的成员。

　　5. new delete

　　许多C用户肯定不会忘记alloc（）和free（）函数族，它们曾经为动态内存分配与释放的操作做出了很大的贡献，如：

　　char *cp = malloc(sizeof(char));  
　　int *ip=calloc(sizeof(int) 10);  
　　free(ip);  
　　free(cp);  

　　C++允许用户使用这些函数，但它同时也提供了两个类似的操作符new和delete，它们分别用来分配和释放内存，形式如下：

　　p = new TYPE；  
　　delete p； 

　　因此以上的cp操作可改版为：

　　char*cp=newchar；  
　　delete cp； 

　　new delete操作符同样亦可作用于C中的结构变量，如：

　　struct COMPLEX*cp = newstruct COMPLEX；  
　　delete cp； 

　　当不能成功地分配所需要的内存时，new将返回NULL.对于字符型变量可以如下初始化：

　　char ch（'A'）； //char ch='A'

　　对应地，new可以同时对变量的值进行初始化，如：

　　char p=newchar （'A‘）； //cp='A' new

　　不需要用户再使用sizeof运算符来提供尺寸，它能自动识别操作数的类型及尺寸大小，这虽然比malloc）函数聪明不了多少，但起码使用起来会比它方便得多。当然，正如calloc（）函数，new也可以用于数组，形式如下：

　　p = new TYPE[Size] ； 

　　对应的内存释放形式：

　　delete [] p； 

　　同理首例中ip操作可以改版为：

　　int * ip=newint[10]；  
　　delete [] ip； 

　　用new分配多维数组的形式为：

　　p = new TYPE [c0] [c1]…… [cN]； 

　　从来没有太快活的事情，例如以下使用非法：

　　int***ip2=（int***）newint[m] [n][k]； 
　　//error. Constant expression required int***ip 1=（int***）new int[m][2][81； //ok 

　　C++最多只允许数组第一维的尺寸（即c0）是个变量，而其它的都应该为确定的编译时期常量。使用new分配数组时，也不能再提供初始值：

　　char*String =newchar[ 20] （"Scent of a Woman"）；   
　　//error： Array allocated using 'new' may not have an initializer 

　　6.引用（reference）

　　（1）函数参数引用以下例程中的Swap（）函数对数据交换毫无用处：

　　//test04. cpp 
　　#include <iostream.h> 
　　void Swap(int va int vb)  
　　{  
　　int temp=va;  
　　va=vb;  
　　vb=temp;  
　　cout << "&va=" << &va << "&vb=" << &vb << endl;  
　　}  
　　void main()  
　　{  
　　int a(1) b(2);  
　　cout << "&a=" << &a << "&b=" << &b << endl;  
　　Swap(a b);  
　　cout << "a=" << a << " b=" << b << endl;  
　　} 

　　输出结果：

　　&a=0x0012FF7C&b=0x0012FF78
　　&va=0x0012FF24&vb=0x0012FF28
　　a=1
　　b=2c

　　语言对参数的调用采取拷贝传值方式，在实际函数体内，使用的只是与实参等值的另一份拷贝，而并非实参本身（它们所占的地址不同），这就是Swap（）忙了半天却什么好处都没捞到的原因，它改变的只是地址0x0012FF24和0x0012FF28处的值。当然，可采取似乎更先进的指针来改写以上的Swap （）函数：

　　//test05. cpp 
　　#include <iostream.h> 
　　void Swap(int * vap int * vbp)  
　　{  
　　int temp = *vap;  
　　*vap = *vbp;  
　　*vbp = temp;  
　　cout << "vap=" << vap << "vbp=" <<vbp << endl;  
　　cout << "&vap=" << &vap << "&vbp=" << &vbp << endl;  
　　}  
　　void main()  
　　{  
　　int a(1) b(2);  
　　int * ap = &a * bp = &b;  
　　cout << "ap=" << ap << "bp=" << bp << endl;  
　　cout << "&ap=" << &ap << "&bp=" << &bp << endl;  
　　Swap(ap bp);  
　　cout << "a=" << a << "b=" << b <<endl;  
　　}  
　　ap=0x0012FF7Cbp=0x0012FF78  
　　&ap=0x0012FF74&bp=0x0012FF70  
　　vap=0x0012FF7Cvbp=0x0012FF78  
　　&vap=0x0012FF1C&vbp=0x0012FF20  
　　a=2b=1 

　　在上例中，参数的调用仍采取的是拷贝传值方式，Swap（）拷贝一份实参的值（其中的内容即a b的地址），但这并不表明vapvbp与实参apbp占据同一内存单元。

　　对实际数据操作时，传统的拷贝方式并不值得欢迎，C++为此提出了引用方式，它允许函数使用实参本身（其它一些高级语言，如BASIC FORTRAN即采取这种方式）。以下是相应的程序：

　　//test06. cpp 
　　#include <iostream.h> 
　　void Swap(int & va int & vb)  
　　{  
　　int temp=va;  
　　va=vb;  
　　vb=temp;  
　　cout << "&va=" << &va << "&vb=" << &vb << endl;  
　　}  
　　void main()  
　　{  
　　int a(1) b(2);  
　　cout << "&a=" << &a << "&b=" << &b << endl;  
　　Swap(a b);  
　　cout << "a=" << a << "b=" << b << endl;  
　　} 

　　输出结果：

　　&a=0x0012FF7C&b=0x0012FF78  
　　&va=0x0012FF7C&vb=0x0012FF78  
　　a=2b=1 

　　很明显，a b与vavb的地址完全重合。对int&的写法别把眼睛瞪得太大，你顶多只能撇撇嘴，然后不动声色地说：“就这么回事！加上&就表明引用方式呗！”

　　（2）简单变量引用简单变量引用可以为同一变量取不同的名字，以下是个例子：

　　int Rat；int & Mouse=Rat； 

　　这样定义之后，Rat就是Mouse（用中文说就是：老鼠就是老鼠），这两个名字指向同一内存单元，如：

　　Mouse=Mickey； //Rat=Mickey

　　一种更浅显的理解是把引用看成伪装的指针，例如，Mouse很可能被编译器解释成：*（& Rat），这种理解可能是正确的。

　　由于引用严格来说不是对象（？！），在使用时应该注意到以下几点：

　　①引用在声明时必须进行初始化；

　　②不能声明引用的引用；

　　③不能声明引用数组成指向引用的指针（但可以声明对指针的引用）；

　　④为引用提供的初始值必须是一个变量。

　　当初始值是一个常量或是一个使用const修饰的变量，或者引用类型与变量类型不一致时，编译器则为之建立一个临时变量，然后对该临时变量进行引用。例如：

　　int & refl = 50; //int temp=50 &refl=temp 
　　float a=100.0;  
　　int & ref2 = a; / / int temp=a&ref2=temp  

　　（3）函数返回引用函数可以返回一个引用。观察程序test07：

　　//test07.cpp 
　　#include <iostream.h> 
　　char &Value (char*a int index)  
　　{  
　　return a[index];  
　　}  
　　void main()  
　　{  
　　char String[20] = "a monkey!";  
　　Value(String 2) = 'd';  
　　cout << String << endl;  
　　}  
　　输出结果：a donkey! 

　　这个程序利用函数返回引用写出了诸如Value （String 2） ='d‘这样令人费解的语句。在这种情况下，函数允许用在赋值运算符的左边。

　　函数返回引用也常常应用于操作符重载函数。

　　7.缺省参数（default value）

　　从事过DOS环境下图形设计的朋友（至少我在这个陷阱里曾经摸了两年时间）肯定熟悉initgraph（）函数，它的原型为：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也许你会为它再定做一个函数：

　　void InitGraph(int Driver int Mode)  
　　{  
　　initgraph(& Driver &Mode ““);  
　　}  

　　一段时间下来，你肯定有了你最钟情的调用方式，例如你就喜欢使用640 * 480 * 16这种工作模式。

　　既然如此，你完全可以将函数InitGraph （ ）声明成具有缺省的图形模式参数，如下：

　　void InitGraph（int Driver = VGA int Mode = VGAHI）； 

　　这样，每次你只需简单地使用语句

　　InitGraph （）； 

　　即可进入你所喜爱的那种模式。当然，当你使用

　　InitGraph （CGA CGAHI ）； 

　　机器也会毫不犹豫地切入到指定的CGAHI模式，而与正常的函数没有两样。

　　这就是缺省参数的用法！为了提供更丰富的功能，一些函数要求用户提供更多的参数（注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册），而实际上，这些参数中的某几项常常是被固定引用的，因此，就可以将它们设定为缺省参数，例如以下函数：

　　void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）； 

　　将可能在（（x y）处以Color颜色、Mode模式画一个点，缺省情况下，颜色为黑色，写点模式为覆盖方式。

　　以下对函数的调用合法：

　　Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT） 
　　PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT） 
　　PutPixel（100 100 RED XOR_PUT）； 

　　而以下调用形式并不合法：

　　Putpixel（）；  
　　Putpixel （100） ；  
　　Putpixel（100 100 XOR_PUT）； 

　　前两种形式缺少参数，因为x、y值并没有缺省值；第三种形式则天真地以为编译器会将其处理成：

　　PutPixel （100 100 BLACK XOR_PUT）； 

　　并且不会产生任何二义性问题，不幸的是，C++并不赞成这样做。

　　作为一条经验，缺省参数序列中最容易改变其调用值的应尽量写在前面，最可能使用其缺省值的（即最稳定的）置于后端。如果将以上函数原型声明成如下形式：

　　void Putpixel（int Color = BLACK char Mode = COPY_PUT int x=100 int y=100）； 

二、挑战#define

　　#define是C提供的一条很有用的指令，但在C++中，很有可能杜绝宏指令的使用。

　　1 .const宏指令允许用户指定某一标识符的值作为一个常量，

　　如：#define PI 3. 1415926

　　它也可以用来定义字符串：#define HZK16 "HZK16F"以下使用可以通过：

　　cout << "PI is“<<PI;  
　　cout << "Filename: "<< HZK16;  

　　但宏毕竟不是一个合法的对象，虽然它伪装得很完美。C++为用户提供了常量修饰符const，可以指定某个对象的值为常量。它阻止用户对其进行赋值或其它副作用，

　　类似于上例：

　　constfloat PI=3.1415926;  
　　char*const HZK16="HZK16F";  
　　PI = 3. 14; //error 
　　HZK16="HZK16K"; //error: Cannot modify a const object 

　　但对于指针的处理似乎有些复杂，例如以下使用却又合法:

　　HZK16[5]=’r’; //ok HZK16 ="HZK16K"

　　清楚地了解const修饰的范围很有必要，如下是声明形式与相应含义:

　　char*const cpl="I love you!“; //const修饰’*’，cp1是一个指向字符的指针常量 
　　constchar*cp2="I hate you!“; //const修饰’char' cp2是一个指向字符常量的指针 
　　constchar*const cp3="Get the hell out of here!“; // const分别修饰’char’和’*’，

　　cp3是一个指向字符常量的指针常量，因此，以下使用仍合法:

　　strcpy(cpl "Oh no...“);  
　　cp2++; 

　　因为cpl只管盯住某一处的地址不放，而阻止其中的内容不被改写则不是它的责任，cp2则恰恰相反，它不允许你修改其中的内容，却可以被你指来指去(这个下场可能更惨)。只有使用两个修饰符(如cp3)才可能是最保险的办法。

　　指向const的指针不能被赋给指向非const的指针:

　　float*p=&PI;  
　　//error: Cannot convert 'const float*’ to 'float*’ 
　　*p=3.14; 

　　这条限制保证了常量的正当含义。但注意由显式转换所引起的常量间接修改是可能的:

　　//test08.cpp 
　　#include <iostream.h> 
　　void main()  
　　{  
　　char * Spy;  
　　constchar * const String = "Yahoo!";  
　　Spy = (char*)String;  
　　Spy[5] = '?';  
　　cout << String;  
　　}  
　　输出结果：Yahoo! 

　　2.内联函数（in line function）

　　宏在某些场合能得到类似于函数的功能，如下是一个常见的例子：#define ADD （a b） （（a）+（b））

　　cout<<“1+2=”<它将实现数据求和功能而输出：但我们至少有一打理由拒绝使用它，以下是最明显的：

　　①宏缺少类型安全检测，如：

　　ADD （'A' 0. 0l）； 

　　这样的调用将被解释为合法，而事实上，很少的用户期望能写出这样的语句；

　　②宏不会为参数引入临时拷贝，如：

　　#define DOUBLE (x)((x)+(x)) 
　　int i(1);  
　　cout<<DOUBLE(i++); //prints '3' 

　　③宏不具有地址，例如可能在一个计算器程序中有：

　　case' +'： Operator = & ADD； 

　　并不能得到合理解释。

　　采取函数？然而，使用函数并不是最划算的支出，它浪费了宝贵的执行时间。使用过汇编语言的读者可能知道，一般函数执行真正的函数体前后，要做一些现场保护工作，当函数体积很小时，这种冗余的工作量将会远远大于函数本身。

　　为此，C++提供了关键字inline，当用户希望编译器将某函数的代码直接插入到调用点时，可将其设置成inline函数，即在函数定义时加上关键字inline，如：

　　//test09.cpp 
　　#include <iostream.h> 
　　inlineint Add (int a int b)  
　　{  
　　return a + b;  
　　}  
　　void main O)  
　　{  
　　cout<<"1+2=“<<Add(1 2);  
　　}  

　　主函数将被编译器解释为：

　　count<<"1+2=“<<{1+2 }； 

　　其行为完全类似于前例的ADD （a b）宏。经验表明，将使用频繁而且体积很小的函数声明为inline是明智的。

　　3.函数重载（overload）

　　在实际数据求和操作时，如上节内容中提供的Add（）函数是远远不够的，你不得不再添加一些其它代码，如：

　　double AddDouble(double a double b)  
　　{  
　　return a + b;  
　　}  
　　float AddFloat (float a float b )  
　　{  
　　return a + b;  
　　}  

　　特别地，在C++中你可以玩弄名字的技巧，将以上的AddDouble AddFloat皆取名为Add，如：

　　double Add(double a double b)  
　　{  
　　return a + b;  
　　} 

　　尽管放心，编译器会安全地为不同的调用形式找到相应的函数原型。如：

　　double a b;  
　　Add(f 2); //int Add(int int) 
　　Add (a b); //double Add (doubledouble) 

　　这样，不同的函数拥有相同的函数名，即函数重载。函数重载以及后面的模板、虚函数机制形成了“一个接口，多种功能”的特性，即多态性（polymorphism），它是面向对象（OO）的技术之一。

　　在使用重载机制时，C++提出了许多防止二义性的限制，如：

　　void fun(int a);  
　　int fun(int a);  
　　void fun(int& a);  
　　void fun (int a int b=0);  

　　很可能引起C ++编译器的恐慌，它在遇到诸如fun（100）的调用时会十分不满。用户有义务保证任一调用形式不产生二义性。以下是一种常见的使用重载机制的例程：

　　//test10.cpp 
　　#include <graphics.h> 
　　#include <iostream.h> 
　　void Pixel(int x int y int color)  
　　{  
　　putpixel(x y color);  
　　}  
　　int Pixel(int x int y)  
　　{  
　　return getpixel(x y);  
　　}  
　　void main()  
　　{  
　　int Driver=VGA Mode=VGAHI;  
　　initgraph(&Driver &Mode "");  
　　Pixel(100 100 4);  
　　int Color = Pixel(100 100);  
　　closegraph();  
　　cout << "Color of point(100 100):" << Color;  
　　}  

　　可以想象C++将以上不同的Pixel（）函数分别编码为Pixel_iii和Pixel_ii，它的形式包含了各入口参数的数据类型。注意，编码未包含返回值的信息，因而依赖于返回值类型的差异的函数重载是不稳定的。因此，连接器（linker）可以毫不费力地找到相应的模块。但这对于新旧C版本产生的模块连接恐怕添加了麻烦，因为传统的C函数库中并没有对函数名再作手脚的坏习惯，C++不得不提供关键字extern来保证这种连接的安全性，如下形式（注意‘C’可要大写）：

　　extern"C"
　　{  
　　void Pixel(int x int y int Color);  
　　};  

　　将告诉编译器只需要在函数库中找相应的Pixel模块，而不必自作聪明。而

　　extern"C"
　　{ //' #include’一定要另起一行 
　　#include "function. h" 
　　};  

　　则声明包含在头文件function. h中所有函数模块皆采取C连接。

4.函数模数（function template）

前面讨论的重载机制用来实现求和操作并不受欢迎，这仿佛还不是C++的风格，例如用户需要求两个其它类型（如字符型）对象的和：Add （'a' ‘b’）；它必须再为之准备一个版本，尽管其名字和代码还是那副样子：

char Add (char a char b)
{
return a + b;
}

这样无聊的工作会让灰心的用户开始怀念起古老的“宏”。然而，更先进的东西一一模板，却可以很方便地解决以上问题：

template <class TYPE>
TYPE Add (TYPE a TYPE b)
{
return a + b;
};

作为模板参数表示了数据类型。在实际的调用中，编译程序根据实际使用的数据类型产生相应的函数。如：

int i=Add(1 2); //int Add(int int)
float f=Add(1.0 2.0); //float Add(float float)

将得到编译器正确的解释。但以下的使用：

int i=Add('A' 0. 0l);
//error: Could not find a match for 'Add(char double)'

所当然地会遭到编译器的拒绝。

以上建立起来的Add）函数模板可以覆盖前面所有的Add（）函数，但再来看看以下语句：

struct COMPLEX {float r; float i;};
typedef struct COMPLEX complex;
complex c1 c2;
complex c=Add(cl c2);

同理，编译器根据Add （）模板定制成：

c=（c1 +c2 }；

这样的结果是没有定义的，计算机很容易对两个复数的加法不知所措而大发牢骚：

Error： Illegal structure operation

既然计算机不喜欢这个作品，没关系，我们为它再做一个函数就是了：

complex Add(complex c1 complex c2)
{
complex c;
c. r=c1. r+c2. r;
c. i=c1. i+ c2. i;
return c;
}

这个函数用以正确地作复数求和。奇怪得很，函数名居然还可以取为Add，而不用担心任何冲突。对这种情形也有很好的说法，C++称之为“函数模板重置”。

在调用形式上，函数模板很类似于宏，但它同时具有类型检查。更普遍的，模板也可以应用于类中。

至此，对抗#define之战已快接近尾声，然而这似乎永远不得结束。宏就是宏，它总有它的优点，譬如它可节省对象空间，你无法阻止有些C++用户仍喜爱它。

5.操作符重载（operator overload）

我还要声明的是，前面定义的Add（）函数，特别是为complex定做的那个，仍然是值得鄙弃的。它们虽然都能正常工作，但仍不是C++常用的风格。既然是求和，我们会更倾向于表达方式“complex c = c1 +c2；”而不是“complex c =Add（cl c2）；”。

操作符‘+’的使用要比Add （ ）函数的调用让人舒服得多。C++中你完全可以摒弃所谓的“模板重置”，而直接对操作符‘+’进行重载：

complex operator+(complex c1 complex c2)
{
complex c;
c.r=cl.r+c2. r;
c. i=cl.i+c2. i;
}

这样当出现。c1+ c2的形式时，表达式就会被赋予正当的含义。以下分述一些常见操作符的重载：

（1）单目操作符的重载：

设@为一个单目运算符，则@x和x@都被解释成operator @（x）。

瞧，这不就是函数调用的形式了吗？其中operator是C++的关键字。例如语句y=——x；将被译作y = operator——（x）；下面是一个求复数相反数的例子：

//test11. cpp
#include <iostream.h>
#include "complex.h"
complex operator - (complex c)
{
c.r = -c.r;
c.i = -c.i;
return c;
}
void main()
{
complex c={1.0 2.0};
c= -c;
cout<<"c=(" <<c.r<<''<< c.i <<"i)\n";
}

假设complex的结构声明包含在complex. h头文件中，testl l将产生如下输出:

c=(-1-2i)
'++'和'--'亦可进行重载:
complex operator++(complex& c);
complex operator-一(complex& c);
complex c;
c++;
--c;

‘++’和’--’是一对怪东西，它们既可以作前缀，又可以作后缀。不过，以下形式的定义只适用于‘++’和’--’的后缀用法:

complex operator++(complex&c int);
complex operator--(complex&c int);
complex c;
c++;//ok
++c; //error. Illegal structure operation
c++(0); //error: Call of nonfunction

注意:其中操作int参数仅作为标志使用，而无其它含义。

(2)双目操作符的重载

设@为一个双目操作符，x@ y被解释成:operator@(x y)

例如语句:

z=x+y;

被译为

z=operator+(x y);

毋需多言，前面的complex operator + (complex c1 complex c2)就是个很好的例子。

(3)new delete的重载

new delete也可以被重载(别看它们那样神秘)，它们通常采取的声明形式如下:

void*operator new (size_t size);
void operator delete (void*p);

其中size t是一个与实现有关的unsigned int类型。以下是它们的使用:

int*ip=new int;
delete ip;

当使用new分配一个TYPE类型的对象空间时，sizeof (TYPE)将作为第一参数引起new (size_t)函数的调用，如上new语句将被译作:

ip=operator new (sizeof(int));

以下是重载的例子:

//test12.cpp
#include <alloc.h>
#include <iostream.h>
#include "complex.h"
static void * operator new (size_t size)
{
cout << size << " byte(s) allocated! \n";
return malloc(size);
}
static void operator delete (void *p)
{
free(p);
cout<<"memory block returned! \n";
}
void main()
{
int *ip = new int(10);
complex *cp = new complex;
float * fp = new float[10];
delete [] fp;
delete cp;
delete ip;
}

输出结果：

4 byte(s) allocated!
8 byte(s) allocated!
40 byte(s) allocated!
memory block returned!
memory block returned!
memory block returned!

在这例子中，malloc（）与free（）被重新拾起，替代了new delete的功能。同时，new （） delete（）函数声明为static类型，以防止它们的重载对其它文件产生副作用。在未重载new、delete之前，系统会使用缺省的那一份new delete版本。

操作符重载是一张最令你自豪的Ace，但必须记住它仍具有以下限制：①操作符重载要求操作对象至少有一个是类对象（类只是结构的一个广义概念）。我曾经做过以下的尝试：

//error: 'operator+(char*char*)’ must he a member function or have a parameter of class type
char*operator+(char*s1 char* s2)
{
return strcat(sl s2);
}

但后来编译器证明了这种对基本数据类型的多情是愚蠢的。

②不可以构造新操作符，也不能改变操作符操作参数的数目，不能改变操作符的优先级。

③操作符的含义应尽量忠实于操作符的原义，这不是一条严格的规则，但是一条很好的忠告。譬如，当你将complex的‘！’操作定义成机器重新启动的代码，虽然C++没有理由阻拦你，但这样不好。

转载：http://www.educity.cn/develop/1387825.html