作业━━第 5 章(4)━━运算符重载.
c 运算符的重载习题答案
1.概念填空题1.1运算符重载是对已有的运算符赋予多重含义，使同一个运算符在作用于不同类型对象时导致不同的行为。
运算符重载的实质是函数重载，是类的多态性特征。
1.2可以定义一种特殊的类型转换函数，将类的对象转换成基本数据类型的数据。
但是这种类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。
类类型转换函数既没有参数，也不显式给出返回类型。
类类型函数中必须有return 表达式的语句返回函数值。
一个类可以定义多个类类型转换函数。
1.3运算符重载时其函数名由operator运算符构成。
成员函数重载双目运算符时,左操作数是对象,右操作数是函数参数。
2.简答题2.2简述运算符重载的规则。
2.2简述重载单目运算符++、--，前置和后置时的差别。
2.3 C++中重运算符是否都可以重载?是否都可以重载成类的成员函数?是否都可以重载成类的友元函数?2.4 构造函数作为类型转换函数的条件是什么。
3．选择题3.1在下列运算符中,不能重载的是(B)A.！B. sizeofC. newD. delete3.2 不能用友员函数重载的是(A)。
A.=B.==C.<=D.++3.3下列函数中,不能重载运算符的函数是(B)。
A.成员函数B.构造函数C.普通函数D.友员函数3.4如果表达式++i*k时中的”++”和”*”都是重载的友元运算符，则采用运算符函数调用格式，该表达式还可表示为（B）。
A．operator*(i.operator++(),k) B．operator*(operator++(i),k)C．i.operator++().operator*(k) D．k.operator*(operator++(i))3.5已知在一个类体中包含如下函数原型：VOLUME operator-(VOLUME)const；下列关于这个函数的叙述中，错误的是（B ）。
A．这是运算符-的重载运算符函数B．这个函数所重载的运算符是一个一元运算符C．这是一个成员函数D．这个函数不改变数据成员的值3.6在表达式x＋y*z中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。
复习五 运算符重载(改)
6.1 运算符重载的规则
算符重载就是赋予已有的运算符多重含义 运算符重载就是赋予已有的运算符多重含义。 例如： 例如：a=3+4； ； a=”abc”+”def”; 同一个运算符“＋”，由于所操作的数据类型不 同一个运算符“ 同而具有不同的意义，这就是运算符重载。 同而具有不同的意义，这就是运算符重载。 运算符重载是C++的一项强大功能。通过重载， 运算符重载是 的一项强大功能。通过重载， 的一项强大功能 可以扩展C++运算符的功能，使它们能够操作用户 运算符的功能， 可以扩展 运算符的功能 自定义的数据类型， 自定义的数据类型，增加程序代码的直观性和可读 性
5
void main(void){ Complex c1(1,2),c2(3,4),c3,c4,; c3=c1+c2; c4=c1-c2; } c1+c2被解释为：operator+(c1,c2) 被解释为： 被解释为 c1-c2被解释为： operator-(c1,c2) 被解释为： 被解释为
6
cout<<r;
if (i>0) cout<<"+"; If (i!=0) cout<<i<<"i"<<endl; }
void main(void) { Complex c1(1,2),c2(3,4),c3,c4,; c3=c1+c2; C++会将它们转换成下面形式的调用 会将它们转换成下面形式的调用 c4=c1-c2; 语句： 语句： c1.display(); // 1+2i c3=c1.operator+(c2); c2.display(); // 3+4i c4=c1.operator –(c2); c3.display(); // 4+6i c4.display();} // -2-2i
作业━━第 5 章(4)━━运算符重载
运算符重载【学习要点】1．理解多态性的概念和实现。
①编译时多态性是通过函数重载、运算符重载实现的。
②运行时多态性是通过类的继承+虚函数实现的。
2．掌握运算符重载的作用和规则。
①在C++中可根据需要对运算符赋予多种含义，以配合用户自定义的类类型。
②运算符重载是通过定义运算符重载函数operator运算符()实现的。
3．掌握双目、单目运算符重载为成员函数的方法。
4．掌握双目、单目运算符重载为友元函数的方法。
5．掌握重载为成员函数、重载为友元函数的区别：①友元函数与成员函数不同，它不是类的成员，没有this指针。
②运算符=、（）、[ ]、—> 不能重载为友元函数，只能重载为成员函数。
③运算符插入”<<”、提取”>>”只能重载为友元函数。
6．掌握几个特殊运算符“++”、“--”、“=”、“[ ]”、“<<”、“>>”的重载。
7．掌握类型转换函数。
8．掌握自定义字符串类。
9．掌握C++标准库中的string类的使用。
------------------------------------------------------------------------------------------------------------------------------------------------【例题分析】1．下面程序中的错误有几处?#include <iostream.h>class C{int x , y ;public:C ( ) { }C ( int a , int b ) : x( a ) , y( b ) { }C operator@ ( C a ){ C temp ; temp.x=x+a.x ; temp.y=y+a.y ; return temp ; }int operator# ( C a ){ return ( x * y ) ; }friend C operator= ( C a ){ x=a.x ; y=b.y ; return *this ; }void show( ){ cout << "x=" << x <<"\ty=" << y << endl ; }};void main(){ C a( 2 , 3 ) , b( 2 , 3 ) , c ;(a+b).show() ; c=a ; c.show() ;}【答案】3【解析】①函数C operator@ (C a) ; 运算符重载是允许用户重新定义运算符的含义，但此运算符必须是C++系统预定义的，而“@”不是C++预定义的运算符，应换成“+”。
5运算符重载
C++ ⑴ 只能重载C++语言中原先已有定义的运算符。 ⑵ 不能重载下列几个运算符： · ，· *，::，?： ⑶ 不能改变运算符的操作数个数。 ⑷ 不能改变运算符原有的优先级。 ⑸ 不能改变运算符原有的结合特性。 ⑹ 不能改变运算符对预定义类型数据的操作方式。
运算符重载函数作为友元函数
“+”是双目运算符，但是只有一个参数。这种情况下，
运算符重载
什么是运算符重载
重载的概念——类似于函数重载，可以实现 一名多用。 运算符重载—— 例如：5+8； 5.3+8.1； 同样是“+”，但是可以完成对不同数据类型 的加法操作。
友元函数
在类与对象中我们介绍过，一个类中的私有 成员只能在类内进行访问。 下面来介绍一个例外——友元（friend）
类对象本身被默认为第一个参数。 例如将一个复数和一个整数相加 C=C1+i //正确 C=i+C1 //错误 而在第二种情况下，第一个操作数并非是类对象，而是 其他类型的数据时，就无法采用成员函数重载的方式， 要用友元函数。
friend Complex operator+(int i,Complex &c2)
可以将一个普通函数声明为友元函数，也可 以将其他类的成员函数声明为本类的友个复数类(Complex)，实现对两个复 数的加法。 可定义成员函数实现加法。 利用operator关键字实现运算符重载。
Complex Complex::operator+(Complex &c2) { Complex c; c.real=real+c2.real; c.imag=imag+c2.imag; return c; }
运算符重载
运算符重载“千里送鹅毛，礼轻情意重”。
在现代社会中，常有人以千里为单位，送贵重的礼物给对方；也有些人以“钱”为单位来回报他人……其实，这两种做法是不合理的。
因为它混淆了两个概念：一是礼物本身，二是礼物所包含的情感。
如果把“千里”换成金钱、或者权势地位呢？还能成立么？答案显然是否定的。
那就是——运算符重载！运算符重载和运算顺序无关吗？当然不是！你可以说这是误导，但是事实上却并非如此。
因为运算符重载后，结果仍旧是原来的数值，只要求出新的运算符即可得到正确的结果。
而且，运算符重载使用起来更加简便快捷，节省时间。
例如：求x=1/2+3/4的值。
若直接写出运算式： x=(1-3/4)/(1/2+3/4)=1/8。
则需要将 x=1/2+3/4分别进行四次乘除运算才能得到最终结果。
假设每次运算均按照运算符优先级排列，第一步： x=1/2+3/4=0，运算符优先级高于等于号（=），故运算符重载后，运算过程变为：x=1/2+3/4=1/8。
第二步： x=1/2+3/4=1/16，运算符优先级低于等于号（=），故运算符重载后，运算过程变为： x=1/2+3/4=1/32。
第三步： x=1/2+3/4=1/64，运算符优先级再度降低，故运算过程变为：x=1/2+3/4=1/128。
第四步： x=1/2+3/4=1/256，运算符优先级继续降低，故运算过程变为： x=1/2+3/4=1/512。
综上所述，运算符重载与运算顺序没有任何联系。
我们都知道，在电脑中，运算符重载是一项十分复杂的工作。
首先，必须根据问题的特点选择适宜的运算符。
其次，应该考虑运算符重载后的运算效率。
同样的问题，采取不同的运算符重载形式，往往会产生截然不同的结果。
例如：求 x=1/2+3/4的值。
若直接写出运算式： x=(1-3/4)/(1/2+3/4)=1/8。
则需要将 x=1/2+3/4分别进行四次乘除运算才能得到最终结果。
假设每次运算均按照运算符优先级排列，第一步： x=1/2+3/4=0，运算符优先级高于等于号（=），故运算符重载后，运算过程变为： x=1/2+3/4=1/8。
运算符重载语法
运算符重载语法运算符重载是一种强大的编程技术，它允许我们改变已定义的运算符的行为，使其适应我们自定义的数据类型。
通过重载运算符，我们可以使程序更加简洁、易于理解，并更加接近我们自然语言的表达方式。
本文将详细介绍运算符重载的语法，帮助读者全面理解并运用此技术。
运算符重载的语法非常简单，以下是一些基本规则：1. 重载运算符函数必须是类的成员函数或友元函数。
如果是成员函数，则形参列表至少有一个参数；如果是友元函数，则形参列表为空。
2. 重载运算符函数的返回类型通常是该运算符所针对的数据类型，以满足运算符的语义要求。
3. 不适合重载的运算符包括`sizeof`、`.`、`.*`、`::`和`?:`等。
4. 重载运算符函数可以是类中定义的普通成员函数，也可以是全局函数。
对于全局函数，建议使用友元函数来实现。
5. 一些运算符重载函数需要改变对象的状态，因此要使用成员函数来实现，以便访问对象的私有成员。
重载运算符函数的声明和实现示例如下：```cpp// 类中定义的成员函数class MyClass {public:MyClass operator+(const MyClass& other); // 加法运算符重载声明};MyClass MyClass::operator+(const MyClass& other) {// 加法运算符重载实现}// 友元函数class MyClass {public:friend MyClass operator+(const MyClass& lhs, const MyClass& rhs); // 加法运算符重载声明};MyClass operator+(const MyClass& lhs, const MyClass& rhs) {// 加法运算符重载实现}```通过运算符重载，我们可以为不同的数据类型定义不同的行为。
简述运算符重载的规则。
简述运算符重载的规则。
运算符重载是指可以为自定义的类类型或枚举类型定义新的含义和功能。
在
C++中，运算符重载遵循以下一般规则：
1. 运算符重载必须至少有一个操作数是用户自定义的类类型或枚举类型的对象，否则将无法重载。
2. 运算符重载可以作为成员函数或非成员函数来实现。
3. 对于成员函数的运算符重载，操作数的数量为运算符的操作数减去1。
例如，重载双目运算符时（如+、-、*等），成员函数需要接受一个参数，用于表示另一个操作数。
4. 对于非成员函数的运算符重载，所有操作数都作为参数传递给函数。
可以通过将重载运算符函数声明为友元函数来访问类的私有成员。
5. 对于重载一元运算符（如++、），如果是成员函数，则返回一个修改后的对象；如果是非成员函数，则返回一个新的对象。
6. 对于重载二元运算符（如+、-、*等），如果是成员函数，则一个对象被修改，另一个对象不变；如果是非成员函数，则返回一个新的对象。
7. 运算符重载不能改变原有运算符的优先顺序和结合性。
8. 运算符重载遵循函数重载的规则，即可以根据参数类型和参数数量进行重载，实现不同的功能。
需要注意的是，运算符重载应该遵循语义上的合理性并不滥用。
运算符重载的方法
运算符重载的方法
运算符重载是指在类中重新定义某个运算符，使其能够用于类的实例。
重载运算符可以方便地对类对象进行加、减、乘、除等基本运算，也可以定义自定义运算符，以实现类特定的功能。
运算符重载的方法如下：
1.编写运算符重载函数：将要重载的运算符的符号作为函数名，如“+”、“-”、“*”、“/”等，对于自定义运算符可以自己命名。
2.指定参数个数和类型：重载函数需要参数，这些参数有不同的类型，可以是类的成员变量或其他类型的变量。
3.重载运算符要求：
（1）操作数至少有一个是类的实例，重载函数可以定义为类的成员函数或全局函数。
（2）运算符重载不能改变原有操作数的类型或个数。
（3）运算符重载函数可以返回任何类型的值，甚至可以是类的实例。
4.使用运算符：一旦重载运算符函数定义好之后，就可以像使用普通的运算符一样使用它。
需要注意的是，运算符重载不是万能的，对于某些运算符，如“&&”、“”等，是不能够重载的。
此外，在使用运算符重载时应该避免过于复杂的实现方式，以防止代码难以理解和维护。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
运算符重载【学习要点】1．理解多态性的概念和实现。
①编译时多态性是通过函数重载、运算符重载实现的。
②运行时多态性是通过类的继承+虚函数实现的。
2．掌握运算符重载的作用和规则。
①在C++中可根据需要对运算符赋予多种含义，以配合用户自定义的类类型。
②运算符重载是通过定义运算符重载函数 operator运算符(实现的。
3．掌握双目、单目运算符重载为成员函数的方法。
4．掌握双目、单目运算符重载为友元函数的方法。
5．掌握重载为成员函数、重载为友元函数的区别：①友元函数与成员函数不同，它不是类的成员，没有this指针。
②运算符 =、（）、[ ]、—> 不能重载为友元函数，只能重载为成员函数。
③运算符插入”<<”、提取”>>” 只能重载为友元函数。
6．掌握几个特殊运算符“++”、“--”、“=”、“[ ]”、“<<”、“>>”的重载。
7．掌握类型转换函数。
8．掌握自定义字符串类。
9．掌握C++标准库中的string类的使用。
------------------------------------------------------------------------------------------------------------------------------------------------【例题分析】1．下面程序中的错误有几处?#includeclass C{ int x , y ;public:C ( { }C ( int a , int b : x( a , y( b { }C operator@ ( C a{ C temp ; temp.x=x+a.x ; temp.y=y+a.y ; return temp ; }int operator# ( C a{ return ( x * y ; }friend C operator= ( C a{ x=a.x ; y=b.y ; return *this ; }void show({ cout << "x=" << x <<"\ty=" << y << endl ; }};void main({ C a( 2 , 3 , b( 2 , 3 , c ;(a+b.show( ; c=a ; c.show( ;}【答案】3【解析】①函数C operator@ (C a ; 运算符重载是允许用户重新定义运算符的含义，但此运算符必须是C++系统预定义的，而“@”不是C++预定义的运算符，应换成“+”。
②函数int operator# (C a ; 符号#不允许重载，应换成“*”，另外形参C a也不需要。
③函数friend C operator = (C a ; 赋值运算符“=”只能重载为成员函数，不能重载为友元函数，故将friend删去。
其次，返回类型最好是 C & 。
2．编写程序：存放在my Vector.cpp文件中，包含内容如下：①定义向量类Vector。
私有成员数据有：存放向量在三条坐标轴上投影值的x、y、z。
公有成员函数有：可设置向量中x、y、z值的成员函数void set( float a=0, float b=0, float c=0 ；可输出向量中x、y、z值的成员函数void show( ；构造函数Vector ( float a=0 , float b=0 , float c=0 ；构造函数Vector( float v[ 3 ] ；两个赋值运算符“=”重载成员函数Vector & operator=( Vector v 、Vector & operator=( float v[ 3 ] 。
②将实现两个向量之间加、减、乘运算的三个独立函数声明为Vector类的友元函数：friend Vector operator+( Vector v1 , Vector v2 ；friend Vector operator-( Vector v1 , Vector v2 ；friend float operator*( Vector v1 , Vector v2 ；③编写main(函数去测试，完成向量间的运算。
【提示】若向量a在三条坐标轴上的投影为a x , a y , a z，则表达式a = { a x , a y , a z } 称为向量a的坐标表达式。
设有两个向量a和b，它们之间的加、减、乘的运算公式为：a +b = { ax +bx , ay +by , az+bz }a -b = { ax -bx , ay -by , az-bz }a *b = ax *bx + ay *by + az *bz将运算符“+”、“-”、“*”和“=”重载，实现向量间的加、减、乘、赋值运算。
【答案】编写程序如下：#include#includeclass Vector{ float x , y , z;public:Vector( float a=0 , float b=0 , float c=0{ x=a ; y=b ; z=c ; }Vector( float v[ 3 ]{ x=v[0] ; y=v[1] ; z=v[2] ; }void set( float a=0 , float b=0 , float c=0{ x=a ; y=b ; z=c ; }void show({ cout << x << 'i' ;cout << ( (y<0 ? '-' : '+' << fabs(y << 'j' ;cout << ( (z<0 ? '-' : '+' << fabs(z << 'k' << endl ; }Vector & operator=( Vector v ;Vector & operator=( float v[ 3 ] ;friend Vector operator+( Vector v1 , Vector v2 ;friend Vector operator-( Vector v1 , Vector v2 ;friend float operator*( Vector v1 , Vector v2 ;};Vector & Vector:: operator=( Vector v{ x=v.x ; y=v.y ; z=v.z ; return *this ; }Vector & Vector:: operator=( float v[ 3 ]{ x=v[0] ; y=v[1] ; z=v[2] ; return *this ; }Vector operator+( Vector v1 , Vector v2{ Vector temp ;temp.x=v1.x+v2.x ; temp.y=v1.y+v2.y ; temp.z=v1.z+v2.z ; return temp ; }Vector operator-( Vector v1 , Vector v2{ Vector temp ;temp.x=v1.x-v2.x ; temp.y=v1.y-v2.y ; temp.z=v1.z-v2.z ;return temp ; }float operator*( Vector v1 , Vector v2{ return ( v1.x*v2.x + v1.y*v2.y + v1.z*v2.z ; }void main({ float a[ ] = { 1 , 2 , 3 } ;Vector v1( a , v2( 4 , 5 , 6 , v3( 7 , 8 , 9 , v4 , v5 ;v4 = v1 + v2 ; v4.show( ;v5 = v3 - v1 ; v5.show( ;cout << "v1*v2=" << v1*v2 << endl ;}【解析】定义向量类，并对各运算符进行重载。
本程序采用友元函数重载“+”、“-”、“*”运算符，在此也可采用成员函数重载，从程序可读性考虑，一般认为双目运算符，重载为友元函数更好些。
但重载“=”运算符必须用成员函数。
------------------------------------------------------------------------------------------------------------------------------------------------【思考题】㈠选择题1．下面运算符中，不能重载的是______。
A．?:B．+spanC．*D．<=【答案】？？？【提示】C++中不能被重载的运算符有“::”、“?:”、“.”、“.*”、“sizeof”2．下面运算符中，不能重载的是______。
A．&&B．[ ]C．::D．new【答案】？？？3．关于运算符重载，下面描述中正确的是______。
A．运算符重载可以改变操作数的个数B．运算符重载可以改变优先级C．运算符重载可以改变结合性D．运算符重载不可以改变语法结构【答案】？？？【提示】运算符重载不能改变操作数的个数、运算符的优先级、运算符的结合性和运算的语法结构。
4．友元重载运算符obl>ob2 被C++编译器解释为______。
A．operator>( obl , ob2B．>( ob1 , ob2C．ob2.operator>( ob1D．ob1.operator>( ob2【答案】？？？【提示】友元函数重载运算符的调用形式：operator<运算符>( <参数1>，<参数2>等价于表达式：<参数1> <运算符> <参数2>5．若a+b运算需通过成员函数实现“+”运算符重载，下面描述中正确的是______。
A．a必须为该类对象，b可为其它数据类型B．a和b都必须为该类对象C．b必须为该类对象，a可为其它数据类型D．a和b均可为其它数据类型【答案】？？？【提示】成员函数实现a+b时，编译器解释为：a.operator(b，因此左操作数a必须为该类对象，否则无法实现成员函数的调用，而右操作数可以是该类的对象，也可以是其它数据类型。