作业━━第 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.使用运算符：一旦重载运算符函数定义好之后，就可以像使用普通的运算符一样使用它。
需要注意的是，运算符重载不是万能的，对于某些运算符，如“&&”、“”等，是不能够重载的。
此外，在使用运算符重载时应该避免过于复杂的实现方式，以防止代码难以理解和维护。
运算符重载
{
rpart=rp;
ipart=ip;
}
Complex add( const Complex & com )
{
Complex temp ;
temp .rpart= com .rpart+rpart;
temp .ipart= com .ip+ipart;
return temp ;
}
2020/7/2
பைடு நூலகம்};
★单目运算符重载 ：
Complex Complex:: operator {
Complex temp;
( 单) 目无参数 双目一个参数
temp.rpart=-rpart;
temp.ipart)=-ipart;
return temp;
}
Complex c=-a+b;
(a.operator-( )).operator+(b)
};
point point::operator+ (point p1)
{ point p; p.x=x+p1.x; p.y=y+p1.y; return p; }
void main()
{ point p1(10,10),p2(20,20); p1=p1+p2 ;
p1.print(); ++p1; p1.print();
}
//(╳)
运算符成员函数——调用成员函数的对象隐式成为表达式的第一个运算数 外部运算符函数——其第一个参数直接对应表达式的第一个运算数；
x1=x2+x3;
operator+(x2, x3);
2020/7/2
6 6
面向对象程序设计语言C++第05章 运算符重载
变它们的结合性，也不能改变这些运算符所需操 作数的数目。 (4)重载运算符的函数不能有默认的参数，否则就改 变了运算符所需要的操作数的数目。
16
第五章 引论
5.1.2 重载运算符规则 (5)重载的运算符必须和用户自定义类型的对象一起
面向对象程序设计语言C++
电子科技大学计算机学院
h
1
第五章 运算符重载
当在使用一种程序设计语言编写程序时，我们 不仅要设计新的数据类型，同时还要为新类型设计 运算。一般地，用户定义类型的运算都是用函数的 方式实现的。
而在一般情况下，一种类型的运算都是用运算符 表达的，这很直观，语义也简单。
但是如果直接将运算符作用在用户定义类型之 上，那么编译器将不能识别运算符的语义。因此， 在这种情况下，我们需要一种特别的机制来重新定 义作用在用户定义类型上的普通运算符的含义。这 就是运算符重载的简单概念。
3
第五章运算符重载
C++扩充了C运算符重载的功能，允许已存在的 预定义运算符在不同的上下文中做出不同的解释。
当两个字符串类进行连接的时候，我们可能用 到这样的方式：
class String {… public: String string_cat(String); … };
String str1, str2, str3; str3 = str1.string_cat(str2);
2
第五章 运算符重载
其实在C编译器里早就存在简单的运算符重载 的概念了。考虑整型和浮点型两种加法运算：
int a = 1, b;
运算符重载
24
运算符重载
思考:如果希望表达式i+c1有意义, 思考:如果希望表达式i+c1有意义,应该 i+c1有意义 如何定义重载运算符函数? 如何定义重载运算符函数?
friend Complex operator+(int &i,Complex &c); Complex operator+(int &i, Complex &c) {return Complex(i+c.real,c.imag);}
2
什么是运算符重载
代码分析: 代码分析: 例10.1 通过函数来实现复数 相加。 相加。
CCS E
3
运算符重载的方法
运算符重载的方法是定义一个重载运 算符的函数， 算符的函数，在需要执行被重载的运 算符时，系统就自动调用该函数， 算符时，系统就自动调用该函数，以 实现相应的运算。也就是说， 实现相应的运算。也就是说，运算符 重载是通过定义函数实现的。 重载是通过定义函数实现的。运算符 重载实质上是函数的重载。 重载实质上是函数的重载。
CCS E
21
运算符重载
如果将运算符重载函数作为成员函数， 如果将运算符重载函数作为成员函数， 它可以通过this this指针自由地访问本类 它可以通过this指针自由地访问本类 的数据成员， 的数据成员，因此可以少写一个函数 的参数。 的参数。但必须要求运算表达式第一 个参数(即运算符左侧的操作数) 个参数(即运算符左侧的操作数)是一 个类对象， 个类对象，而且与运算符函数的类型 相同。 相同。因为必须通过类的对象去调用 该类的成员函数，而且只有运算符重 该类的成员函数， 载函数返回值与该对象同类型， 载函数返回值与该对象同类型，运算 结果才有意义。 结果才有意义。
简述运算符重载的规则。
简述运算符重载的规则。
篇一：运算符重载是C/C++语言中一种强大的功能,允许程序员自定义函数的行为,以处理不同类型的数据。
运算符重载允许程序员在函数中重载算术、逻辑和位运算符,从而能够处理数组、结构体和指针等不同类型的数据。
以下是运算符重载的规则:1. 算术运算符重载算术运算符包括加号、减号、乘号和除号。
每个算术运算符都有一组默认的行为,可以通过运算符重载来自定义它们的行为。
例如,重载加号运算符可以使函数接受一个整数参数,并返回一个新的整数。
下面是一个简单的例子,演示了如何重载加号运算符:```c++struct MyStruct {int value;};MyStruct operator+(const MyStruct& other, int value) {return MyStruct(value + other.value);}int main() {MyStruct mystruct1 = { 10 };MyStruct mystruct2 = { 20 };int result = mystruct1 + mystruct2;std::cout << "result = " << result << std::endl;return 0;}```在上面的例子中,我们定义了一个名为`MyStruct`的结构体类型,其中包含一个整数类型。
然后,我们定义了一个重载加号运算符的函数,该函数接受一个整数类型的参数,并返回一个新的`MyStruct`对象。
在`main`函数中,我们定义了两个`MyStruct`对象`mystruct1`和`mystruct2`,并将它们相加,结果存储在`result`变量中。
2. 逻辑运算符重载逻辑运算符包括条件运算符和逻辑非运算符。
每个逻辑运算符都有一组默认的行为,可以通过运算符重载来自定义它们的行为。
运算符重载
运算符重载为类的友元函数
类中的声明： 类中的声明： friend 函数类型 operator 运算符（参数表）； 运算符（参数表）； 运算符重载函数的定义形式： 运算符重载函数的定义形式： 运算符（参数表） 函数类型 operator 运算符（参数表） { 函数体； 函数体； } 附加例） （附加例）用友元函数实现复数的加法运算符的重 载。
数据类型转换 标准数据类型转换
隐式转换： 自动转成double型) 隐式转换：7.5+2 (将2自动转成 将 自动转成 型 显式转换： 转成整型) 显式转换：int(89.5) (将89.5转成整型 将 转成型
涉及到类类型的转换
对于用户自己声明的类型， 对于用户自己声明的类型，编译系统并不知道怎样进行转 换。解决这个问题的关键是让编译系统知道怎样去进行转 换，需要定义专门的处理函数。 需要定义专门的处理函数。 将一个其他类型的数据转换成一个类类型： 将一个其他类型的数据转换成一个类类型：转换构造函数 将一个类的对象转换成另一类型的数据： 将一个类的对象转换成另一类型的数据：类型转换函数
运算符重载的格式
运算符重载为类的成员函数 运算符重载为类的友元函数
运算符重载的规则
①
② ③ ④ ⑤
.”、 *” ::”、 ?:”和 sizeof”等几个运 除“. 、“*”、“:: 、“?: 和“sizeof 等几个运 算符不能重载外， 算符不能重载外，C++中几乎所有的运算符都可以 中几乎所有的运算符都可以 重载。 重载。 运算符被重载后，其优先级和结合性不会改变。 运算符被重载后，其优先级和结合性不会改变。 不能改变运算符操作对象的个数。 不能改变运算符操作对象的个数。 运算符的意义应不变。 运算符的意义应不变。 用于类对象的运算符一般必须重载，但有两个例外， 用于类对象的运算符一般必须重载，但有两个例外， 运算符“ 和 不必用户重载。 运算符“=”和“&”不必用户重载。 不必用户重载
运算符重载——精选推荐
运算符重载运算符重载学习运算符重载，让运算符能做⼀些原来做不了的事情，⽅便它的使⽤⼀、运算符重载的概念1、什么是运算符重载1.重载：重新载⼊，就像之前学的函数重载，对⼀个已有的函数赋值⼀个新的定义，因此同⼀个函数名就可以有不同的含义。
2.运算符也是可以重载的，⽐如cout在输出⼀个变量的时候，能接受不同类型的数据并输出，他就是重载了<<运算符，这个就是运算符重载3.所以运算符重载指的是对已有的运算符重新定义新的运算规则，以适应不同的数据类型，当然重载之后之前的运算规则还是有的2、为什么要进⾏运算符重载1.运算符重载之后可以让运算符去适应不同的数据类型，对于基本数据类型，系统给出了运算符的操作规则，对于⾃定义数据类型来说，系统不知道该给出什么规则class student{int id;int age;char name[20];public:student(int id,int age,const char* name){this->id=id;this->age=age;strcpy(this->name,name);}}student stu1(1,23,"张三");student stu2(2,24,"李四");stu1+stu2;//如果是这样相加，那么应该加的是什么呢？编译器是不知道的，所以编译器就提供了运算符重载这个机制，让⽤户⾃定义运算符的运算规则⼆、运算符重载1、运算符重载类中定义1.关键字：operator，通过关键字来定义运算符重载(跟写个函数⼀样)2.定义：函数返回值类型 operator 要加载的运算符(参数列表){函数体；}这⾥把运算符的使⽤，理解为调⽤函数，只是和平时的调⽤函数有⼀点区别#include<iostream>#include<string>using namespace std;class student{int id;int age;string name;public:student(int age){this->age = age;id = 1;name = "sss ";}student(int id, int age, string name){this->id = id;this->age = age;this->name = name;}void showstudent(){cout << id << "\t" << age << "\t" << name << endl;}student operator+(student& p1)//这个函数会返回⼀个新的对象{int x=this->age + p1.age;student p(x);return p;//返回的是⼀个对象，会调⽤拷贝构造}int operator-(int x){return this->id - x;}void operator+(student&p2){cout << this->id + p2.id << endl;}};//1.操作这个运算符之后，返回值类型是什么int main(){student p1(0, 1, "yunfei");int x = p1.operator-(1);cout << x << endl;student stu1(1, 23, "张三");student stu2(2, 24, "李四");//student stu3 = stu1.operator+(stu2);//student stu3 = stu1 + stu2;stu1 + stu2;//stu3.showstudent();system("pause");return 0;}注意：因为我们这个运算符是在类中写的，所以是通过对象调⽤的，那么this指针会占⼀个参数，⽽且是第⼀个参数，也就是说我们重载⼀个运算符，是在类中，⽽这个运算符是个单⽬运算符，那么参数列表就不⽤写东西了，是双⽬运算符，那么就需要传另⼀个参数进来绝⼤部分的运算符重载都可以参照上⾯这个+号重载2、运算符重载的特点1.⼏乎所有的运算符都可以被重载，除了 . :: ()?() ) sizeof()2.运算符重载基本出现在类中和结构体中3.运算符可以理解为函数的⼀个表现3、运算符重载的注意事项1.重载运算符，这个重载的运算符还是满⾜原来的原则，但不能说重载+号，结果做的事-号的事，这样会使运算符的运⽤上增加很⼤的难度2.运算符重载的参数，类中重载调⽤对象会占⼀个参数，就是this会占⼀个参数，参数列表就是⽤来表⽰运算符的操作的3.对于运算符重载的调⽤，可以直接使⽤运算符，也可以通过对象 . 出来调⽤4.考虑返回值，不同的运算符有不同的返回值，要记得满⾜运算符原来的规则4、使⽤友元函数，实现运算符重载1.类在已经实现且部分修改的情况下下，需要进⾏运算符重载，就可以通过友元的⽅式来进⾏重载#include<iostream>#include<string>using namespace std;class person{int id;int age;string name;public:person(int id, int age, string name){this->id = id;this->age = age;this->name = name;}void showperson(){cout << id << "\t" << age << "\t" << name << endl;}friend int operator+(person&p1, person&p2);};//形参使⽤的是类对象的引⽤，在实参传对象的时候不会调⽤拷贝构造int operator+(person&p1, person&p2){return p1.id + p2.id;}//1.操作这个运算符之后，返回值类型是什么int main(){person stu1(1, 23, "张三");person stu2(2, 24, "李四");int x = operator+(stu1, stu2);//显⽰调⽤int y = stu1 + stu2;//隐式调⽤cout << x << endl << y << endl;system("pause");return 0;}容器：#include<iostream>#include<vector>using namespace std;int main(){//int 是v1这个容器存的类型vector<int> v1;for (int i = 0; i < 10; i++){//push_back()是⼀个函数，功能是尾插元素v1.push_back(i + 1);}for (int i = 0; i < 10; i++){cout << v1[i] << "\t";}system("pause");return 0;}左移右移运算符重载：#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}friend ostream& operator<<(ostream& os, person& p1);friend istream & operator>>(istream & in, person & p2);};//左移右移运算符重载，必须在类外重载，通过友元实现ostream& operator<<(ostream& os, person& p1)//左移运算符{os << p1.id << endl;return os;//返回的是⼀个cout,⽽且只能⽤引⽤}istream & operator>>(istream & in, person & p2)//右移运算符{in >> p2.id;return in;}int main(){person p1(10), p2(20);cin >> p1 >> p2;cout << p1 << endl << p2 << endl;system("pause");return 0;}前++，后++运算符重载：#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}person& operator++()//前++{this->id++;return *this;}person& operator++(int)//后++,int是⼀个占位符，⽤来区分前++和后++的{static person temp = *this;//引⽤不能返回局部变量，要⽤静态变量this->id++;return temp;}friend ostream& operator<<(ostream& os, person& p1);friend istream & operator>>(istream & in, person & p2);};//左移右移运算符重载，必须在类外重载，通过友元实现ostream& operator<<(ostream& os, person& p1)//左移运算符{os << p1.id << endl;return os;//返回的是⼀个cout,⽽且只能⽤引⽤}istream & operator>>(istream & in, person & p2)//右移运算符{in >> p2.id;return in;}int main(){person p1(10), p2(20);//cin >> p1 >> p2;//cout << p1 << endl << p2 << endl;cout << p1 ;//10cout << p1++ ;//10cout << p1 ;//11cout << ++p1 ;//12cout << p1 ;//12system("pause");return 0;}等号运算符重载：#include<iostream>using namespace std;class person{char* name;public:person(const char* name){this->name = new char[strlen(name) + 1];strcpy(this->name, name);}person& operator=(person&p1)//⽤不⽤引⽤传参，要看返回的对象会不会消失 {if (this->name != NULL){delete[]this->name;this->name = NULL;}this->name = new char[strlen() + 1];strcpy(this->name, );return *this;}void show(){cout << name << endl;}~person()//如果有申请函数，就要加上析构函数{if (name != NULL){delete[]name;name = NULL;}}};int main(){{person p1("张三"), p2("李四"), p3("王五");p1 = p2 = p3;p1.show();p2.show();p3.show();}//加上⼤括号，让对象死亡，就能调⽤析构函数system("pause");return 0;}智能指针和==号运算符重载：#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}void show(){cout << id << endl;}bool operator==(person& p){return this->id == p.id;}~person(){cout << "person的析构函数" << endl;}};class smartpointer{person* ps;//包含你要new出来的对象的类的指针public:smartpointer(person* p){ps = p;}//重载->person* operator->()//传回来的是地址，不是对象，不⽤引⽤{return ps;}//重载*person& operator*()//返回的是对象，会调⽤拷贝构造，所以⽤返回值⽤引⽤，就不会再调⽤拷贝构造了 {return *ps;//得到⼀个对象，}~smartpointer(){if (ps != NULL){delete ps;ps = NULL;}}};int main(){{smartpointer p(new person(5));p->show();(*p).show();person p1(1), p2(3);cout << (p1 == p2) << endl;}//有三个对象，所以析构函数执⾏了三次system("pause");return 0;}[]运算符重载：#include<iostream>using namespace std;class person{char* name;public:person(const char* name){this->name = new char[strlen(name) + 1];strcpy(this->name, name);}char& operator[](int index){return name[index];}~person(){if (name != NULL){delete[]name;name = NULL;}cout << "这是析构函数" << endl;}};int main(){person p("asdfg");cout << p[3] << endl;system("pause");return 0;}c++引⽤作为函数返回值：1.以引⽤返回函数值，定义函数时需要在函数名前加 &2.⽤引⽤返回⼀个函数值的最⼤好处是，在内存中不产⽣被返回值的副本3.返回值为引⽤的时候，返回的是⼀个地址，隐形指针4.当返回值不是引⽤时，编译器会专门给返回值分配出⼀块内存的引⽤作为返回值，必须遵守以下规则：（1）不能返回局部变量的引⽤。
运算符重载
万象城春节营销方案万象城春节营销方案一、背景介绍春节是中国传统的重要节日之一，也是全年销售额最高的时期之一。
随着消费水平的提高和消费观念的改变，人们在春节期间不仅满足于传统的购物需求，更加注重消费体验和品牌形象。
作为一家位于城市商圈的综合购物中心，万象城需要制定一套有吸引力、创新性的春节营销方案，提升品牌形象、增加销售额。
二、目标和定位1. 主要目标：增加春节期间销售额，提升品牌形象。
2. 定位：高端购物中心、高品质消费场所。
三、核心信息1. 品牌核心信息：高品质、多元、高端。
2. 营销信息：新年新气象，尽享购物乐趣。
四、理念和创意1. 理念：为顾客带来春节购物的新鲜元素，打造愉悦、独特的购物体验，让他们惊喜连连，享受购物乐趣。
2. 创意：结合传统与现代、东西方文化相融合，以独特的方式展现春节主题，吸引顾客的注意力。
五、活动策划1. 主题活动活动一：万象迎春晚会活动时间：春节前一天晚上活动地点：万象城中心广场活动内容：- 邀请知名主持人和明星嘉宾，举办一场充满欢乐、娱乐性的晚会。
演唱、舞蹈、小品、魔术等形式丰富多样。
- 晚会通过现场直播和社交媒体推广，吸引更多人关注和参与，增加品牌曝光。
- 晚会现场设置特色互动游戏，如抽奖、发红包等，增加顾客参与度，扩大品牌影响力。
活动二：文化体验展览活动时间：春节期间活动地点：万象城大堂及商铺内部活动内容：- 展览展示中国传统文化艺术，如中国书法、民俗文化、剪纸等。
- 安排专业讲解员，向顾客介绍传统文化背景和艺术品鉴赏技巧。
- 设置DIY手工坊，让顾客亲身参与传统艺术品制作，增加消费者的体验感。
活动三：花灯巡游活动时间：春节期间活动地点：万象城周边街区活动内容：- 邀请民间艺术团队表演传统舞蹈、武术，穿着中国传统服装，带着花灯游历街区。
- 设立观众席供顾客观看，并提供中国传统小吃、特色饮品等，让顾客在观看表演的同时，感受传统文化的美味。
2. 营销推广活动- 春节福袋：顾客在万象城购物满一定金额可以领取春节福袋，福袋内含有不同价值的现金券和特别优惠券，鼓励顾客消费，增加销售额。
简述运算符重载的规则。
简述运算符重载的规则。
运算符重载是C语言中的一种语法特性,允许程序员在函数内部重载运算符,以改变其操作类型和参数类型。
运算符重载可以用于实现一些复杂的逻辑,也可以用于提高代码的灵活性和可重用性。
运算符重载的规则如下:
1. 运算符重载只能重载算术运算符和逻辑运算符,不能重载关系运算符(如+、-、*、/等)。
2. 运算符重载的重载点必须在函数内部,不能跨越函数调用。
3. 运算符重载的参数类型必须与运算符的类型相同或相似,且参数类型之间的运算符必须兼容。
4. 运算符重载的函数必须声明在头文件中,并且必须在文件定义之前声明。
5. 运算符重载的函数可以重载多个运算符,但是不能重复重载同一个运算符。
6. 运算符重载的函数可以修改原始运算符的行为,比如将一个算术运算符重载为逻辑运算符。
7. 运算符重载的函数可以改变运算符的顺序,比如将一个逻辑运算符重载为算术运算符。
8. 运算符重载的函数可以改变运算符的优先级,比如将一个逻辑运算符重载为算术运算符或者赋值运算符。
通过运算符重载,程序员可以实现一些复杂的逻辑,比如将一个算术运算符重载为逻辑运算符,以进行条件判断和流程控制。
运算符重载还可以提高代码的
灵活性和可重用性,因为不同的函数可以分别实现不同的逻辑,而不必共享相同的代码。
除了常见的算术运算符重载和逻辑运算符重载外,C语言还支持一些其他的运算符重载,比如字符串比较运算符重载、字符串拼接运算符重载等。
程序员可以根据具体的需求和场景,灵活地使用运算符重载来实现不同的逻辑。
运算符重载——精选推荐
运算符重载什么是运算符的重载?运算符与类结合，产⽣新的含义。
为什么要引⼊运算符重载？作⽤：为了实现类的多态性(多态是指⼀个函数名有多种含义)怎么实现运算符的重载？⽅式：类的成员函数或友元函数（类外的普通函数）规则：不能重载的运算符有 . 和 .* 和 ?: 和 :: 和 sizeof友元函数和成员函数的使⽤场合：⼀般情况下，建议⼀元运算符使⽤成员函数，⼆元运算符使⽤友元函数1、运算符的操作需要修改类对象的状态，则使⽤成员函数。
如需要做左值操作数的运算符（如=，+=，++）2、运算时，有数和对象的混合运算时，必须使⽤友元3、⼆元运算符中，第⼀个操作数为⾮对象时，必须使⽤友元函数。
如输⼊输出运算符<<和>>具体规则如下：运算符建议使⽤所有⼀元运算符成员函数＝ ( ) [ ] ->必须是成员函数+= -= /= *= ^= &= != %= >>= <<= , 似乎带等号的都在这⾥了成员函数所有其它⼆元运算符, 例如: –,+,*,/友元函数<< >>必须是友元函数2. 参数和返回值当参数不会被改变，⼀般按const引⽤来传递(若是使⽤成员函数重载，函数也为const).对于返回数值的决定:1) 如果返回值可能出现在=号左边, 则只能作为左值, 返回⾮const引⽤。
2) 如果返回值只能出现在=号右边, 则只需作为右值, 返回const型引⽤或者const型值。
3) 如果返回值既可能出现在=号左边或者右边, 则其返回值须作为左值, 返回⾮const引⽤。
运算符重载举例：+和 -运算符的重载:class Point{private:int x;public:Point(int x1){ x=x1;}Point(Point& p){ x=p.x;}const Point operator+(const Point& p);//使⽤成员函数重载加号运算符friend const Point operator-(const Point& p1,const Point& p2);//使⽤友元函数重载减号运算符};const Point Point::operator+(const Point& p){return Point(x+p.x);}Point const operator-(const Point& p1,const Point& p2){return Point(p1.x-p2.x);}输出：Point a(1);Point b(2);a+b; //正确，调⽤成员函数a-b; //正确，调⽤友元函数a+1; //正确，先调⽤类型转换函数，把1变成对象，之后调⽤成员函数a-1; //正确，先调⽤类型转换函数，把1变成对象，之后调⽤友元函数1+a; //错误，调⽤成员函数时，第⼀个操作数必须是对象，因为第⼀个操作数还有调⽤成员函数的功能1-a; //正确，先类型转换后调⽤友元函数总结：1、由于+ -都是出现在=号的右边，如c=a+b，即会返回⼀个右值，可以返回const型值2、后⼏个表达式讨论的就是，数和对象混合运算符的情况，⼀般出现这种情况，常使⽤友元函数3、双⽬运算符的重载：重载运算符函数名：operator@(参数表)隐式调⽤形式：obj1+obj2显式调⽤形式：obj1.operator+(OBJ obj2)---成员函数operator+(OBJ obj1，OBJ obj2)---友元函数执⾏时，隐式调⽤形式和显式调⽤形式都会调⽤函数operator+()++和--运算符的class Point{private:int x;public:Point(int x1){ x=x1;}Point operator++();//成员函数定义⾃增const Point operator++(int x); //后缀可以返回⼀个const类型的值friend Point operator--(Point& p);//友元函数定义--friend const Point operator--(Point& p,int x);//后缀可以返回⼀个const类型的值};Point Point::operator++()//++obj{x++;return *this;}const Point Point::operator++(int x)//obj++{Point temp = *this;this->x++;return temp; // 需要返回⼀个临时对象，效率不如 ++obj ⾼}Point operator--(Point& p)//--obj{p.x--;return p;//前缀形式(--obj)重载的时候没有虚参,通过引⽤返回*this 或⾃⾝引⽤,也就是返回变化之后的数值}const Point operator--(Point& p,int x)//obj--{Point temp = p;p.x--;return temp;// 后缀形式obj--重载的时候有⼀个int类型的虚参, 返回原状态的拷贝}调⽤：Point b(2);a++;//隐式调⽤成员函数operator++(0),后缀表达式++a;//隐式调⽤成员函数operator++(),前缀表达式b--;//隐式调⽤友元函数operator--(0),后缀表达式--b;//隐式调⽤友元函数operator--(),前缀表达式cout<<a.operator ++(2);//显式调⽤成员函数operator ++(2)，后缀表达式cout<<a.operator ++();//显式调⽤成员函数operator ++()，前缀表达式cout<<operator --(b,2);//显式调⽤友元函数operator --(2)，后缀表达式cout<<operator --(b);//显式调⽤友元函数operator --()，前缀表达式 </pre>总结：1、a++函数返回：temp(临时变量)函数返回是否是const类型：返回是⼀个拷贝后的临时变量)，不能出现在等号的左边(临时变量不能做左值)，函数的结果只能做右值，则要返回⼀个const类型的值++a函数返回：*this;函数返回是否是const类型：返回原状态的本⾝，返回值可以做左值，即函数的结果可以做左值，则要返回⼀个⾮const类型的值2、前后缀仅从函数名(operator++)⽆法区分，只能有参数区分，这⾥引⼊⼀个虚参数int x，x可以是任意整数。
C++学习之运算符重载的总结
C++学习之运算符重载的总结C++学习之运算符重载的总结运算符重载是对已有的运算符赋予多重含义，使同⼀个运算符作⽤域不同类型的数据导致不同⾏为的发⽣，C++为运算符重载提供了⼀种⽅法，即运算符重载函数。
其函数名字规定为operator后紧跟重载运算符。
⽐如：operator+(),operator*()等。
(1)运算符重载函数作为类的友元函数的形式： class 类名 { friend 返回类型 operator运算符(形参表); } 类外定义格式： 返回类型 operator运算符(参数表) { 函数体 }友元函数重载双⽬运算符(有两个操作数，通常在运算符的左右两则)，参数表中的个数为两个。
若是重载单⽬运算符(只有⼀个操作数)，则参数表中只有⼀参数。
同⼀个运算符可以定义多个运算符重载函数来进⾏不同的操作。
(2)运算符重载函数作为类的成员函数的形式： class 类名 { 返回类型 operator 运算符(形参表); } 类外定义格式： 返回类型类名:: operator 运算符(形参表) { 函数体; }对于成员函数重载运算符⽽⾔，双⽬运算符的参数表中仅有⼀个参数，⽽单⽬则⽆参数。
同样的是重载，为什么和友元函数在参数的个数上会有所区别的。
原因在于友元函数，没有this指针。
对于双⽬运算符⽽⾔，运算符重载函数的形参中仅为⼀个参数，它作为运算符的右操作数(如com2对象)，⽽当前对象作为左操作数(如：上述中的com1对象)，它是通过this指针隐含传递给成员运算符重载函数的。
例如下⾯这样的定义：Complex operator+(Complex com1);//成员函数重载双⽬运算符+20Complex Complex::operator+(Complexcom1)21{22return Complex(real+com1.real,imag+com1.imag);23}对于单⽬运算符⽽⾔，当前对象作为运算符的操作数。
运算符重载解读
02
在重载运算符时，应明确指定 运算符的参数类型和返回类型 ，避免与其他操作符混淆。
03
在重载运算符时，应尽量使用 有意义的操作符名称，以提高 代码的可读性。
考虑性能和效率
01
02
03
运算符重载时，应考虑 性能和效率，避免对原 有代码造成不必要的性
能损失。
在重载运算符时，应尽 量减少额外的计算和内 存开销，以提高代码的
一元运算符重载
一元运算符重载是指对一元运算符进行重载，使其能够应用于一个操作数。例如，在C中，我们可以 重载一元减号运算符(-)来返回一个数的相反数。
常见的一元运算符有：+、-、~、!等。
二元运算符重载
二元运算符重载是指对二元运算符进行重载，使其能够应用于两个操作数。例如，在C中，我们可以重载加号运算符(+)来定 义两个自定义类型的相加行为。
01
提高代码可读性
运算符重载可以使代码更易读， 因为运算符的使用可以使代码更 简洁、更直观。
02
03
方便函数调用
运算符重载可以使得函数调用更 加方便，因为运算符的使用可以 减少函数调用的开销。
04
缺点分析
易造成混淆
运算符重载可能会使得代码难以理解，因为 运算符的行为可能会被改变，导致读者难以
理解代码的含义。
常见的二元运算符有：+、-、*、/、%等。
三元运算符重载
三元运算符重载是指对三元运算符进行重载，使其能够应用于三个操作数。例如，在C中，我们可以重载条件运 算符(?)来定义一个自定义类型的条件判断行为。
常见的三元运算符有：?:。
03
运算符重载的常见场景
类与类之间的运算
01
两个类对象之间的加法运算，可以表示它们之间的某种关联或 合并。
运算符重载详解
运算符重载详解1.运算符重载定义：C++中预定义的运算符的操作对象只能是基本数据类型。
但实际上，对于许多⽤户⾃定义类型（例如类），也需要类似的运算操作。
这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够⽤于特定类型执⾏特定的操作。
运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引⼈的特性之⼀。
运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进⾏的操作。
运算符函数的定义与其他函数的定义类似，惟⼀的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。
运算符函数定义的⼀般格式如下：<返回类型说明符> operator <运算符符号>(<参数表>){<函数体>} 2.运算符重载时要遵循以下规则：(1) 除了类属关系运算符"."、成员指针运算符".*"、作⽤域运算符"::"、sizeof运算符和三⽬运算符"?:"以外，C++中的所有运算符都可以重载。
(2) 重载运算符限制在C++语⾔中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。
(3) 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。
(4) 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。
(5) 运算符重载不能改变该运算符⽤于内部类型对象的含义。
它只能和⽤户⾃定义类型的对象⼀起使⽤，或者⽤于⽤户⾃定义类型的对象和内部类型的对象混合使⽤时。
(6) 运算符重载是针对新类型数据的实际需要对原有运算符进⾏的适当的改造，重载的功能应当与原有功能相类似，避免没有⽬的地使⽤重载运算符。
（7）重载运算符的函数不能有默认的参数，否则就改变了运算符的参数个数，与前⾯第3点相⽭盾了；（8）重载的运算符只能是⽤户⾃定义类型，否则就不是重载⽽是改变了现有的C++标准数据类型的运算符的规则了，会引会天下⼤乱的；（9）⽤户⾃定义类的运算符⼀般都必须重载后⽅可使⽤，但两个例外，运算符“=”和“&”不必⽤户重载；（10）运算符重载可以通过成员函数的形式，也可是通过友元函数，⾮成员⾮友元的普通函数。
- 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必须为该类对象，否则无法实现成员函数的调用，而右操作数可以是该类的对象，也可以是其它数据类型。