C++铁道第2版-7

1、,第7章 运算符重载 7.1 运算符重载概述 7.2 运算符函数重载为类的友元函数 和成员函数 7.3 几个常用运算符的重载 7.4 重载插入运算符和提取运算符 7.5 类型转换,本章主要内容,7.1 运算符重载概述 用于完成“+”、 “-”、 “*”、 “”等操作的函数为运算符函数。 C+规定运算符函数名为： operator+ operator- operator* operator 等 统称为： operator ( -要重载的运算符),运算符函数名,两个或者两个以上的运算符函数共用一个运算符函数名为运算符函数重载。 C+系统已经预先编好了将两个基本数据类型相加的的运算符函数，可以直接使

2、用它们。 1.求两个整数相加,例如: int i=2+3; 2.求两个双精度数相加,例如: double d=2.222+3.333 ;,运算符函数重载,调用预先编好的将两个整型数相加的的运算符函数,调用预先编好的将两个双精度数相加的的运算符函数,C+系统预先编好的运算符函数不能完成将两个对象的相加工作。 例如:有一个复数类complex： class complex public： double real，imag； complex(double r=0，double i=0) real=r； imag=i； ；,实现两个对象相加的运算符函数,若要把类complex的两个对象com1和com

3、2加在一起： int main() complex com1(1.1，2.2)，com2(3.3，4.4); complex total； total = com1 + com2； /错误 / return 0； ,C+系统预先编好的运算符函数不能将两个对象的相加,解决办法：用户自己编写一个实现两个对象相加的运算符函数,例如: int main() complex com1(1.1，2.2)，com2(3.3，4.4); complex total； total = com1+com2； / return 0；,就能将类complex的两个对象com1和com2相加,complex opera

4、tor+(complex co1,complex co2) ,将类complex的两个对象相加的运算符函数operator+( )： complex operator+(complexco1,complex co2) complex temp； temp.real=co1.real+co2.real； temp.imag=co1.imag+co2.imag； return temp； ,调用语句：total=operator+(com1，com2)； 或： total=com1+com2；,就能将类complex的两个对象com1和com2相加,例7.1-1 将两个complex类对象相加的完

5、整程序。 #include using namespace std; class complex public: double real, imag; complex(double r=0,double i=0)real=r;imag=i; ; complex operator+(complex co1,complex co2) complex temp; temp.real=co1.real+co2.real; temp.imag=co1.imag+co2.imag; return temp; ,运算符函数 operator+(),main( ) complex com1(1.1,2.2),

6、com2(3.3,4.4),total1,total2; total1=operator+(com1,com2); coutreal1=total1.real; cout imag1= total1.imag endl; total2=com1+com2; coutreal2=total2.real; cout imag2=total2.imag endl; return 0; ,调用运算符函数operator+()的第1种方式,调用运算符函数 operator+()的第2种方式,运行结果如下： real1=4.4 imag1=6.6 real2=4.4 imag2=6.6,#include

7、class complex public: double real, imag; complex(double r=0,double i=0)real=r;imag=i; ; complex operator+(complex co1,complex co2) complex temp; temp.real=co1.real+co2.real; temp.imag=co1.imag+co2.imag; return temp; ,运算符函数 operator+(),例7.1-1 是一个类外定义的运算符函数,只能访问公有数据成员，而不能访问类的私有数据成员。,公有的数据成员,例7.1-1存在的问

8、题,但是，实际上类中的数据成员常常是私有成员或保护成员,解决办法: (1) 定义为它将要操作的类的成员函数(简称为成员运算符重载函数); (2) 定义为它将要操作的类的友元函数(简称为友元运算符重载函数)。,7.2 运算符函数重载为类的友元函数和成员函数 7.2.1 友元运算符重载函数 7.2.2 成员运算符重载函数 7.2.3 运算符重载应该注意的几个问题,本节主要内容,7.2.1 友元运算符重载函数 在C+中，可以把运算符函数定义成某个类的友元函数，称为 友元运算符重载函数 。 1. 友元运算符重载函数定义的语法形式 (1)在类的内部,定义友元运算符重载函数的格式如下:,friend 函数

9、类型 operator运算符(形参表) 函数体 ,(2) 友元运算符重载函数也可以在类中声明友元函数的原型,在类外定义。 在类中,声明友元运算符重载函数原型的格式如下: 在类外,定义友元运算符重载函数的格式如下:,class X friend 函数类型 operator运算符(形参表); ;,函数类型 operator运算符(形参表) 函数体 ,例如：两个complex对象进行“+”法运算的友元运算符函数。 class complex friend complex operator+(complex co1,complex co2); /. . . ; complex operator+(co

10、mplex co1,complex co2) /. . . ,在类的内部声明原型,在类外定义友元运算符函数,友元运算符函数定义时： 若重载的是双目运算符，则参数表中有两个操作数； 若重载的是单目运算符，则参数表中只有一个操作数。,2. 双目友元运算符重载函数 双目运算符有两个操作数,通常在运算符的左右两侧, 例如: 3+5, 2412 当用友元函数重载双目运算符时,两个操作数都要传递给运算符重载函数。,#include / 例7.2-1 class complex double real, imag; public: friend complex operator+(complex co1,c

11、omplex co2); complex(double r=0,double i=0) real=r; imag=i; void print() coutreal=real imag=imagendl; complex operator+(complex co1,complex co2) complex temp; temp.real=co1.real+co2.real; temp.imag=co1.imag+co2.imag; return temp; main( ) complex com1(1.1,2.2),com2(3.3,4.4),total1,total2; total1=oper

12、ator+(com1,com2); total1.print(); total2=com1+com2; total2.print(); return 0; ,声明友元运算符函数operator+()原型,定义友元运算符函数operator+(),调用operator+()的第1种方式,调用operator+()的第2种方式,运行结果如下： real=4.4 imag=6.6 real=4.4 imag=6.6,若双目友元运算符函数operator 所需的两个操作数aa和bb在参数表提供。 一般而言，可以采用以下两种方法使用： aa bb； /隐式（习惯）调用 operator(aa，bb)；/

13、显式调用 如上例中： com1+com2 operator+(com1,com2),说明: (1) 在函数返回的时候,有时可以直接用类的构造函数来生成一个临时对象,而不对该对象进行命名。 例如: Complex operator+(Complex ,建立一个临时对象,它没有对象名,是一个无名对象。在建立临时对象过程中调用构造函数。return语句将此临时对象作为函数返回值。,(2) Visual C+6.0提供的不带后缀的.h的头文件不支持友元运算符重载函数,在Visual C+6.0中编译会出错,这时可采用带后缀的.h头文件。 这时可将程序中的 #include using namespac

14、e std; 修改成 #include 例如:例7.2-1中的： #include class complex double real, imag; public: friend complex operator+(complex co1,complex co2); complex(double r=0,double i=0) real=r; imag=i; void print() coutreal=real imag=imagendl; ;,取代原程序中的： #include using namespace std;,3. 单目友元运算符重载函数 单目运算符只有一个操作数, 例如: -a,

15、 public: AB(int x=0,int y=0) a=x; b=y; friend AB operator -(AB obj); void show(); ; AB operator -(AB obj) obj.a=-obj.a; obj.b=-obj.b; return obj; void AB:show( ) couta=a b=bendl; ,声明友元运算符函数 operator-()原型,定义友元运算符函数operator-(),main( ) nclass ob1(10,20),ob2; ob1.show( ); ob2=operator-(ob1); / 或ob2=-ob1

16、; ob2.show( ); return 0; ,隐式调用,main( ) AB ob1(10,20),ob2; ob1.show( ); ob2=operator-(ob1); / 或ob2=-ob1; ob2.show( ); return 0; ,显式调用,隐式调用,#include / 例7.3-1 class AB int a,b; public: AB(int x=0,int y=0) a=x; b=y; friend AB operator -(AB obj); void show(); ; AB operator -(AB obj) obj.a=-obj.a; obj.b=-

17、obj.b; return obj; void AB:show( ) couta=a b=bendl; ,main( ) nclass ob1(10,20),ob2; ob1.show( ); ob2=operator-(ob1); / 或ob2=-ob1; ob2.show( ); return 0; ,隐式调用,main( ) AB ob1(10,20),ob2; ob1.show( ); ob2=operator-(ob1); / 或ob2=-ob1; ob2.show( ); return 0; ,显式调用,隐式调用,运行结果： a=10 b=20 a=-10 b=-20,#inclu

18、de / 例7.4-1 class coord int x,y; public: coord(int i=0,int j=0); void print(); friend coord operator+(coord op); ; coord:coord(int i,int j) x=i; y=j; void coord:print( ) cout x: x , y: yendl; coord operator+(coord op) +op.x; +op.y; return op; main( ) coord ob(10,20); ob.print( ); operator+(ob); ob.p

19、rint( ); +ob; ob.print( ); return 0; ,声明友元运算符函数operator+( )原型,定义友元运算符函数operator+( ),显式调用,隐式调用,运行结果如下： x=10 y=20 x=10 y=20 x=10 y=20,为什么不是? x=10 y=20 x=11 y=21 x=12 y=22,#include / 例7.4-1 class coord int x,y; public: coord(int i=0,int j=0); void print(); friend coord operator+(coord op); ; coord:coor

20、d(int i,int j) x=i; y=j; void coord:print( ) cout x: x , y: yendl; coord operator+(coord op) +op.x; +op.y; return op; main( ) coord ob(10,20); ob.print( ); operator+(ob); ob.print( ); +ob; ob.print( ); return 0; ,显式调用,隐式调用,运行结果如下： x=10 y=20 x=10 y=20 x=10 y=20,为什么不是? x=10 y=20 x=11 y=21 x=12 y=22,分析

21、原因,本例使用对象作为运算符函数的形参，是传值调用, 对象ob不随着op变化,程序运行错误的原因是： 这个函数是通过传值的方法传递参数的，函数体内对op的所有修改都无法传到函数体外。 因此，在operator +( ) 函数中，形参对象op任何改变不会影响实参对象ob的值，也就是说，实际上实参对象ob的x和y并未增加。 解决以上问题的方法是: 使用对象引用作为运算符函数的形参，即 采用传址调用。,#include /例7.4-2 class coord int x,y; public: coord(int i=0,int j=0); void print( ); friend coord op

22、erator+(coord ,解决以上问题的方法是: 使用对象引用作为运算符函数的形参，即采用传址调用。ob随op而变化,显式调用,隐式调用,运行结果如下： x:10，y:20 x:11，y:21 x:12，y:22,从上述程序可以看出，当用友元函数重载单目运算符时，参数表中有一个操作数aa 。 一般可以采用以下两种方法来调用： operator(aa)； /显式调用 aa； /隐式(习惯)调用 如上例中： operator +(ob) +ob,说明: (1) 运算符重载函数operator 可以返回任何类型,甚至可以是void类型,但通常返回类型与它所操作的类的类型相同,这样可以使重载运算符

23、用在复杂的表达式中。 例如，可以将几个复数连续进行加运算: A4 = A3 + A2 + A1 (2) 有的运算符不能定义为友元运算符重载函数,如赋值运算符=、下标运算符、函数调用运算符()等。 (3) C+编译器根据参数的个数和类型来决定调用哪个重载函数。因此,可以为同一个运算符定义几个运算符重载函数来进行不同的操作。,7.2.2 成员运算符重载函数 在C+中,可以把运算符重载函数定义成某个类的成员函数,称为成员运算符重载函数。 1. 成员运算符重载函数定义的语法形式 (1) 在类的内部,定义成员运算符重载函数的格式如下:,函数类型 operator运算符(形参表) 函数体 ,(2) 成员运

24、算符重载函数也可以在类中声明成员函数的原型,在类外定义。 在类的内部, 声明成员运算符重载函数原型的格式如下: 在类外,定义成员运算符重载函数的格式如下:,class X 函数类型 operator运算符(形参表); ;,函数类型 X:operator运算符(形参表) 函数体 ,在成员运算符重载函数的形参表中, 若运算符是单目的,则参数表为空; 若运算符是双目的,则参数表中有一个操作数。,2.双目成员运算符重载函数 例如： class complex / complex operator+(complex c)； /. ； 对双目运算符而言，成员运算符函数的参数表中仅有一个参数: 参数表中的参

25、数-右操作数 当前对象-左操作数,它是通过this指针隐含地传递给函数的。,complex complex:operator+(complex c) complex temp; temp.real=this-real + c.real; temp.imag=this-imag + c.imag; return temp; 显式调用 A3=A1.operator+(A2); 隐式调用 A3=A1+A2; 以上两个语句的执行结果是完全相同的。,隐含的,左操作数,右操作数,complex complex:operator+(complex c) complex temp; temp.real=thi

26、s-real + c.real; temp.imag=this-imag + c.imag; return temp; 显式调用 A3=A1.operator+(A2); 隐式调用 A3=A1+A2; 以上两个语句的执行结果是完全相同的。,隐含的,左操作数,右操作数,#include / 例7.5-1 class complex double real, imag; public: complex(double r=0,double i=0) real=r; imag=i; complex operator+(complex co2); void print() coutreal=real i

27、mag=imagendl; ; complex complex:operator+(complex co2) complex temp; temp.real= real+co2.real; temp.imag= imag+co2.imag; return temp; ,成员运算符函数 operator+(),main( ) complex com1(1.1,2.2),com2(3.3,4.4),total1, total2; total1=com1.operator+(com2); total1.print(); total2= com1+com2; total2.print(); retur

28、n 0; ,运行结果如下： real=4.4 imag=6.6 real=4.4 imag=6.6,左操作数,右操作数,显式调用,隐式调用,采用成员函数重载双目运算符后，一般可以用以下两种方法来调用： aa bb； /隐式(习惯)调用 aa.operator (bb)；/显式调用 如上例中： com1.operator+(com2) com1+com2,3.单目成员运算符重载函数 对单目运算符而言，成员运算符函数的参数表中没有参数，此时当前对象作为运算符的一个操作数。,#include /例7.6-1 class coord int x,y; public: coord(int i=0,int

29、 j=0); void print( ); coord operator+( ); ; coord:coord(int i,int j) x=i; y=j; void coord:print( )coutx:x,y:yendl; coord coord:operator+( ) +x; +y; return *this; ,参数表中没有参数,当前对象作为运算符的一个操作数,main( ) coord ob(10,20); ob.print( ); ob.operator +( ); ob.print( ); +ob; ob.print( ); return 0; ,显式调用,隐式调用,运行结果

30、如下： x:10，y:20 x:11，y:21 x:12，y:22,采用成员函数重载单目运算符时，一般可以采用以下两种方法来使用： aa.operator( )； /显式调用 aa； /隐式(习惯)调用 如上例中： ob.operator +( ) +ob,7.2.3 运算符重载应该注意的几个问题 (1) C+中绝大部分的运算符允许重载,不能重载的运算符只有以下几个: . 成员访问运算符 .* 成员指针访问运算符 : 作用域运算符 sizeof 长度运算符 ?: 条件运算符 (2) C+语言中只能对已有的C+运算符进行重载,不允许用户自己定义新的运算符。 (3) 在重载运算符时，运算符函数所作

31、的操作不一定要保持C+中该运算符原有的含义。 例如，可以把加运算符重载成减操作，但这样容易造成混乱。 所以保持原含义,容易被接受,也符合人们的习惯。,(4) 重载不能改变运算符的操作对象(即操作数)的个数。 (5) 重载不能改变运算符原有的优先级。 例如,C+语言规定,先乘除，后加减,因此表达式: x=y-a*b; 等价于 x=y-(a*b); (6) 重载不能改变运算符原有的结合特性。例如,在C+语言中乘、除法运算符“*”和“”都是左结合的, 因此表达式: x=a/b*c; 等价于 x=(a/b)*c; 而不等价于 x=a/(b*c);,(7) 运算符重载函数的参数至少应有一个是类对象(或类

32、对象的引用)。也就是说,运算符重载函数的参数不能全部是C+标淮类型, 例如以下定义运算符重载函数的方法是错误的: int operate+(int x,int y) return x+y; 这项规定的目的是,防止用户修改用于标准类型数据的运算符性质。 (8) 一般而言,用于类对象的运算符必须重载,但是赋值运算符“=”例外,不必用户进行重载。因为C+系统已为每一个新声明的类重载了一个赋值运算符函数。,(9)大部分运算符既可说明为成员运算符函数，又可说明为友元运算符函数。 主要取决于实际情况和程序员的习惯。 一般而言： 对于单目运算符,建议选择成员函数; 对于运算符“=、()、-”只能作为成员函数

33、; 对于运算符“+=、-=、/=、*=、 对于其他运算符,建议重载为友元函数。 (10) 双目运算符一般可以被重载为友元运算符重载函数或成员运算符重载函数， 但有一种情况，必须使用友元函数。,#include /例 7.7-1 class AB int a,b; public: AB(int m=0,int n=0); AB operator+(int x); /声明成员运算符函数 void show( ); ; AB:AB(int x,int y) a=x; b=y; AB AB:operator+(int x) /定义成员运算符函数 AB temp; temp.a=a + x; temp.

34、b=b + x; return temp; void AB:show() couta=a b=bn; main( ) AB ob1(30,40),ob2,ob3; ob2= ob1 + 30; ob2.show( ); ob3= 50 + ob1; ob3.show( ); return 0; ,注意：x是整数,当前对象.a + 整数x 当前对象.b + 整数x,当前对象 +整数30,整数50 + 当前对象,#include /例 7.7-1 class AB int a,b; public: AB(int m=0,int n=0); AB operator+(int x); /声明成员运算符

35、函数 void show( ); ; AB:AB(int x,int y) a=x; b=y; AB AB:operator+(int x) /定义成员运算符函数 AB temp; temp.a=a + x; temp.b=b + x; return temp; void AB:show() couta=a b=bn; main( ) AB ob1(30,40),ob2,ob3; ob2= ob1 + 30; ob2.show( ); ob3= 50 + ob1; ob3.show( ); return 0; ,注意：x是整数,当前对象.a + 整数x 当前对象.b + 整数x,正确： 运行结

36、果: a=60 b=70,运行出错!,程序运行结果表明： 语句 ob2= ob1 + 30; 正确 运行结果: a=60 b=70 ob2= ob1.operator+(30); 可以正确调用成员运算符函数： AB operator+(int x) 把整数30加到了对象ob1的某些元素上去。 语句 ob3= 50 + ob1; 错误 错误的原因是运算符“+”的左操作数是一个整数50: ob3= 50.operator+(ob1) ;,整数50不能调用成员运算符函数。,左操作数是当前对象ob1,解决方法： 用两个友元运算符函数来重载运算符“+”,就能使基本数据类型出现在运算符的左、右边。 fri

37、end AB operator+(AB ob,int x); friend AB operator+(int x,AB ob);,整型变量x出现在运算符的左边,整型变量x出现在运算符的右边,#include /例7.7-2 class AB int a,b; public: AB(int x=0,int y=0); friend AB operator+(AB ob,int x); friend AB operator+(int x, AB ob); void show( ); ; AB:AB(int x,int y) a=x; b=y; AB operator +(AB ob, int x)

38、 AB temp; temp.a =ob.a + x; temp.b=ob.b + x; return temp; AB operator +(int x, AB ob) AB temp; temp.a =x + ob.a; temp.b=x + ob.b; return temp; void AB :show( ) couta=a b=bn;,编写两个友元运算符函数,对象 + 整数,整数 + 对象,main( ) AB ob1(30,40),ob2; ob2=ob1+30; ob2.show( ); ob2=50+ob1; ob2.show( ); return 0; ,整数 + 对象,对象

39、 + 整数,运行结果如下： a=60 b=70 a=80 b=90,7.3 几个常用运算符的重载 7.3.1 单目运算符“+”和“-”的重载 7.3.2 赋值运算符“=”的重载 7.3.3 下标运算符“”的重载 7.3.4 函数调用运算符“()”的重载,本节主要内容,7.3.1 单目运算符“+”和“-”的重载 1. 成员运算符函数为： ob.operator +( )； 2. 友元运算符函数为: operator +(X/ob为类X对象的引用 1. 成员运算符函数为： ob.operator +(int)； 2. 友元运算符函数为: operator+(X public: void init(

40、int I1); void print( ); over operator +( ); over operator +(int); ; void over:init(int I1) i1=I1; void over:print( ) /显示输出数据成员 couti1: i1endl; over over:operator +( ) /前缀方式定义 +i1; return *this; over over:operator+(int) /后缀方式定义 i1+; return *this; ,成员运算符重载函数的前缀方式和后缀方式,成员运算符重载函数，前缀方式,成员运算符重载函数，后缀方式,mai

41、n( ) over obj1,obj2; obj1.init(4 ); obj2.init(2); obj1.operator+( ); /或 +obj1 obj2.operator+(0); /或 obj2+ obj1.print(); obj2.print(); return 0; ,运行结果如下： i1:5 i1:3,显式调用,前缀方式,显式调用,后缀方式,#include /例7.9-1 class over int i1; public: void init(int I1); void print(); friend over operator -(over ,友元运算符重载函数的前

42、缀方式和后缀方式,友元运算符重载函数，前缀方式,友元运算符重载函数，后缀方式,main() over obj3,obj4; obj3.init(8); obj4.init(3); operator-(obj3); /或-obj3 operator-(obj4,0); /或obj4- obj3.print( ); obj4.print( ); return 0; ,运行结果如下： i1:7 i1:2,显式调用,前缀方式,显式调用,后缀方式,7.3.2 赋值运算符=的重载 若obj1 和obj2 是类X的两个对象，则对象间可以进行赋值： obj1 = obj2； 原因是： 对任一类X，如果没有用户

43、自定义的赋值运算符函数，那么系统自动地为其生成一个默认的赋值运算符函数。 例如：定义为类X中的成员到成员的赋值 X class STRING public: STRING(char*s) coutConstructor called.endl; ptr=new charstrlen(s)+1; strcpy(ptr,s); STRING() coutDestructor called.-ptrendl; delete ptr; private: char *ptr; ; int main() STRING p1(book); STRING p2(jeep); p2=p1; return 0;

44、,调用默认的赋值运算符函数,浅层复制,运行结果： Constructor called. Constructor called. Destructor called.-book Destructor called.-葺葺葺葺 VC+错误信息,执行到右花括号，先撤消对象p2，后撤消对象p1,动态空间1 动态空间2,book,jeep,ptr,p1,ptr,p2,(a)执行p2=p1之前,book,ptr,ptr,p1,p2,(b)执行p2=p1之后,jeep,ptr,?,(c) 撤销对象p2后,图5.1 例5.10的浅层复制示意图,p1,Lin,调用了默认的赋值运算符函数,程序运行后，出现了所谓

45、的“指针悬挂”现象。,2. 用深层复制解决指针悬挂问题 为了解决浅层复制出现的错误,必须显式地定义一个赋值运算符重载函数,使之不但拷贝数据成员,而且为对象p1和p2分配了各自的内存空间,这就是所谓的深层复制。,#include /例7.11 关于深层复制的例子。 using namespace std; class STRING public: STRING(char*s) coutConstructor called.endl; ptr=new charstrlen(s)+1; strcpy(ptr,s); STRING() coutDestructor called.-ptrendl; d

46、eleteptr; STRING ,声明赋值运算符重载函数,定义赋值运算符函数,int main() STRING p1(book); STRING p2(jeep); p2=p1; return 0; ,调用自定义赋值运算符函数,深层复制,执行到右花括号，先撤消对象p2，后撤消对象p1,运行结果： Constructor called. Constructor called. Destructor called.-book Destructor called.-book,动态空间1 动态空间2,book,jeep,ptr,p1,ptr,p2,(a)执行p2=p1之前,book,ptr,ptr

47、,p1,p2,(b)执行p2=p1之后,jeep,说明： 类的赋值运算符“=”只能重载为成员函数，而不能把它重载为友元函数.,book,ptr,图5.2 例5.11的深层复制示意图,p1,(c) 撤销对象p2后,可见：调用了自定义的赋值运算符函数,程序执行了所谓的深层复制,运行结果是正确的。,在C+中,在重载下标运算符“”时,认为它是一个双目运算符,例如XY可以看成： -双目运算符 X -左操作数 Y -右操作数 operator-对应的运算符函数名 - 若X为某一个类的对象，函数调用XY可被解释为: X.operator(Y) 左操作数 运算符函数名 右操作数,7.3.3 下标运算符“”的重

48、载,类似X+Y可以看成： + -双目运算符 X -左操作数 Y -右操作数 operator+-运算符函数名,类似X.operator+(Y),下标运算符重载函数形式如下: 说明: (1)下标运算符“ ” 只能使用成员函数重载。 (2)形参只能有一个,形参在此表示下标。,返回类型 类名:operator(形参) /函数体 ,#include /例7.13-1 #include class Vector4 int v4; public: Vector4(int a1,int a2,int a3,int a4) v0=a1;v1=a2;v2=a3;v3=a4; int ,下标运算符函数原型,定义下

49、标运算符函数,第1次调用下标运算符函数,v2被解释为v.operator(2),第3次调用下标运算符函数,第2次调用下标运算符函数,运行结果： 3 22,数组的边界检查,7.3.4 函数调用运算符“ ( ) ”的重载 C+中,在重载函数调用运算符“()”时认为它是一个双目运算符, 例如X(Y)可以看成: ( )-双目运算符 X-左操作数 Y-右操作数 operator()-对应的运算符函数名 若X为某一个类的对象，则调用函数X(Y)可被解释为: X.operator( )(Y) 左操作数 运算符函数名 右操作数,设X是某一个类的对象,类中定义了重载“()”的operator()函数,则表达式

50、X(5); 可被解释为: X.operator()(5); 对函数调用运算符重载只能使用成员函数,其形式如下:,返回类型 类名:operator( )(参数表) 函数体 ;,例7.14 声明一个矩阵类Matrix,在该类中重载运算符“()”,使其能返回矩阵元素的值。,#include /例7.14 class Matrix int* m; int row ，col; public: Matrix(int,int); int ,当前对象的row,形参row,矩阵元素赋初值0 1 2 3.,返回矩阵中第r行第c列的值,等价于： coutaM.operator()(2,3),运行结果： 23 24,

51、例7.15 带有多个参数的函数调用运算符“()”重载函数。 #include using namespace std; class Myclass public: Myclass(int x=0,double y=0) i=x; j=y; Myclass operator()(int k,double m); void display() couti jn; private: int i; double j; ; Myclass Myclass:operator()(int k,double m) i=k+10; j=m+10.5; return *this; int main() Mycla

52、ss obj1(10,11.5); obj1.display(); obj1(100,6.9); obj1.display(); return 0;,此语句可解释为obj1.operator()(100,6.9),声明重载运算符()函数原型,定义重载运算符()函数,程序运行结果为: 10 11.5 110 17.4,说明：“( )”是唯一的一个可带多个右操作数的运算符函数。,7.4 重载插入运算符和提取运算符 7.4.1 重载插入运算符“”,本节主要内容,7.4.1 重载插入运算符“” 在头文件iostream中,对运算符“”进行重载,能用它输出各种标准类型的数据,其原型具有形式: 例如当系统

53、执行 coutThis is a string.n; 时,就调用了插入运算符重载函数 ostream,ostream,它的功能是将字符串“This is a string.”插入到流对象cout中。于是在显示器屏幕上显示出字符串This is a string.。,类型名是指int、float、double、char*、char等C+标准类型。,C+对插入运算符“” 的功能进行了扩充, 可以实现用户自定义类型的输出。 定义插入运算符“”重载函数的一般格式如下: 函数中第一个参数是对ostream对象的引用，这意味着out必须是输出流，它可以是其他标识符，但必须与return后面的标识符相同。,

54、ostream ,两者应该一致,对ostream对象的引用,例7.16 将运算符函数重载为友元函数,用于进行复数的加法运算,并用重载的运算符“ using namespace std; class Complex 声明复数类Complex public: Complex(double r=0.0,double i=0.0); /声明构造函数 friend Complex operator +(Complex,Complex:Complex(double r,double i) /定义构造函数 real=r; imag=i; Complex operator+(Complex ,int main

55、() Complex com1(2.3,4.6),com2(3.6,2.8),com3; /定义3个复数类对象 coutcom1; /输出复数com1 coutcom2; /输出复数com2 com3=com1+com2; /复数相加 coutcom3; /输出复数相加结果com3 return 0; ,程序运行结果如下: 2.3+4.6i 3.6+2.8i 5.9+7.4i,7.4.2重载提取运算符“” 在头文件iostream中,对运算符“”进行重载,以便能用它输入各种标准类型的数据,其原型具有形式: 例如当系统执行 int x; cinx; 时,就调用了提取运算符重载函数 istream

56、 从输入流对象cin(通常为键盘) 读入一个值并赋给x。,istream,其中,类型名也是指int、float、double、char*、char等C+标准类型。,C+对提取运算符“”的功能进行了扩充, 可以通过重载运算符“”实现用户自定义类型的输入。完整的格式如下: 函数中第一个参数in是istream类对象的引用。这意味着in必须是输入流对象,它可以是其他任何正确的标识符,但必须与return后面的标识符相同。,istream ,对istream对象的引用,两者应该一致,例7.17将运算符函数重载为友元函数,用于进行复数的加法运算,并用重载运算符“”输入复数，用重载的运算符“ using

57、namespace std; class Complex public: Complex(double r,double i) real=r; imag=i; Complex() real=0; imag=0; friend Complex operator+(Complex,Complex); friend ostream ,在VC+6.0环境下运行时,第1行应改为: #include ,并将第2行删去。,Complex operator+(Complex a,Complex b) /定义重载+的运算符函数 Complex temp; temp.real=a.real+b.real; temp.imag