实验四流运算符的重载及文件的使用
实验4+运算符重载和类模板
系别
计算机与信息工程系
班级
B110507
学号
姓名
课程名称
C++面向对象程序设计
实验日期
实验名称
运算符重载和类模板
成绩
实验内容和步骤：
1．分析教程“函数模板”中的例子，自行设计一个简单的类模板。
2．分析教程“运算符重载”中的例子，自行设计一个简单的重载运算符。
3．指出下面程序中的错误，改正并运行。
cout<<"c1*c2=";
c3.display();
return 0;}
3.所给程序的分析如下：
（1）错误一：类的结尾处少了一个分号“；”；
（2）错误二：main函数没有定义类型，应该定义为void或者为int在最后再加一句“return0；”；
（3）错误三：因为定义的对象数组没有参数，所以应该在添加一个无参的构造函数。
（4）运行结果：
5
6
实验总结：
通过本次试验，我对C++的多态性有了进一步的了解，在C++程序中，不同功能的函数可以用同一个函数名，可以用一个函数名调用不同内容的函数。
Complex operator*(Complex&c2);
void display();
private:
double real;
double imag;};
Complex Complex::operator*(Complex&c2)
{Complex c;
c.real=real*c2.real-imag*c2.imag;
{ a=x;b=y;}
numtype max()
编程技术中的运算符重载和函数重载
编程技术中的运算符重载和函数重载编程技术中的运算符重载和函数重载是两个非常重要的概念。
它们可以让程序员更加灵活地使用已有的运算符和函数，从而提高编程效率和代码可读性。
本文将分别介绍运算符重载和函数重载的概念、用法和应用场景。
一、运算符重载运算符是编程语言中的一种特殊符号，用于表示不同的数学和逻辑运算。
在传统的编程语言中，每个运算符都有固定的语义和操作对象。
但是，在某些情况下，我们可能希望对已有的运算符进行自定义的操作。
这就是运算符重载的概念。
运算符重载可以让程序员重新定义运算符的操作行为。
通过重载运算符，我们可以使得运算符对用户自定义的类型也能够进行操作。
例如，我们可以定义一个名为"Vector"的类，然后重载"+"运算符，使得两个"Vector"对象可以相加。
这样，我们就可以像操作普通的整数或浮点数一样，对"Vector"对象进行加法运算。
运算符重载的语法和用法因编程语言而异。
在C++中，运算符重载通过定义特殊的成员函数来实现。
例如，重载"+"运算符的成员函数的定义如下：```cppclass Vector {public:Vector operator+(const Vector& other) {Vector result;// 实现向量相加的逻辑return result;}};```通过重载运算符，我们可以使得代码更加简洁和易读。
例如，我们可以使用如下方式对两个"Vector"对象进行相加：```cppVector v1, v2;Vector sum = v1 + v2;```二、函数重载函数重载是指在同一个作用域中，可以定义多个同名函数，但是这些函数的参数列表必须不同。
函数重载可以让程序员使用相同的函数名来实现不同的功能，从而提高代码的可读性和复用性。
函数重载的用法非常灵活。
运算符重载
运算符重载“千里送鹅毛，礼轻情意重”。
在现代社会中，常有人以千里为单位，送贵重的礼物给对方；也有些人以“钱”为单位来回报他人……其实，这两种做法是不合理的。
因为它混淆了两个概念：一是礼物本身，二是礼物所包含的情感。
如果把“千里”换成金钱、或者权势地位呢？还能成立么？答案显然是否定的。
那就是——运算符重载！运算符重载和运算顺序无关吗？当然不是！你可以说这是误导，但是事实上却并非如此。
因为运算符重载后，结果仍旧是原来的数值，只要求出新的运算符即可得到正确的结果。
而且，运算符重载使用起来更加简便快捷，节省时间。
例如：求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。
运算符重载实验报告
运算符重载实验报告运算符重载实验报告引言：运算符重载是C++语言中的一项重要特性，它允许用户自定义运算符的行为。
通过运算符重载，可以使得程序更加直观、简洁，并提高代码的可读性和可维护性。
本实验旨在探索运算符重载的用法和效果。
一、实验目的本实验旨在通过实际操作，深入了解运算符重载的机制和使用方法，以及运算符重载对程序设计的影响。
二、实验环境本实验使用C++编程语言，并在Visual Studio开发环境下进行实验。
三、实验过程1. 了解运算符重载的基本概念运算符重载是指通过定义函数，改变运算符的行为。
在C++中，可以通过重载运算符函数来实现运算符的重载。
运算符重载函数的命名规则为"operator 运算符"，例如"operator+"表示重载加法运算符。
2. 实现运算符重载的实验示例为了更好地理解运算符重载的使用方法，我们以矩阵的加法为例进行实验。
首先，定义一个Matrix类，并重载"+"运算符。
```cppclass Matrix {private:int** data;int rows;int cols;public:Matrix(int rows, int cols) {this->rows = rows;this->cols = cols;data = new int*[rows];for (int i = 0; i < rows; ++i) {data[i] = new int[cols];}}Matrix operator+(const Matrix& other) {Matrix result(rows, cols);for (int i = 0; i < rows; ++i) {for (int j = 0; j < cols; ++j) {result.data[i][j] = data[i][j] + other.data[i][j]; }}return result;}};```在上述代码中，我们定义了一个Matrix类，其中包含矩阵的数据成员data、行数rows和列数cols。
实验4 c++运算符重载(1)
实验4 运算符重载（一）班级：学号：姓名：成绩：1、实验目的（1）理解运算符重载的意义和重载规则；（2）掌握运算符重载为成员函数和友元函数的方法；（3）掌握单目运算符和双目运算符的重载方法。
2、实验内容有两个矩阵a和b，均为2行3列。
（1）求两个矩阵之和。
重载运算符“+”，使之能用于矩阵相加。
如：c=a+b。
（2）如果参加运算的两个操作数中一个是整数，即矩阵+3或3+矩阵形式。
进行加法运算时也能得出和。
（3）定义自加运算符的前置（++i）和后置（i++）重载，编写相应程序验证它的正确性。
3、选作题（1）定义一个复数类Complex，重载运算符“+”，“-”，“*”，“/”，使之能用于复数的加、减、乘、除运算。
运算符重载函数作为Complex类的成员函数。
请编程，分别求两个复数的和、差、积、商。
（2）定义一个复数类Complex，重载运算符“+”，使之能用于复数的加法运算。
参加运算的两个操作数可以都是类的对象，也可以其中有一个是整数，顺序任意。
例如：c1+c2，i+c，c+i均合法（其中，c、c1、c2为复数类的对象，i为整数）。
请编程，分别求两个复数的和、整数和复数之和。
（3）设向量X=（x1,x2,x3）和Y=（y1,y2,y3），则它们之间的加减和积分别定义为：X+Y=(x1+y1,x2+y2,x3+y3)X-Y=(x1-y1,x2-y2,x3-y3)X*Y=(x1*y1+x2*y2+x3*y3)编程序对运算符“+”、“-”、“*”重载，实现向量之间的加、减、乘运算。
4、实验总结（1）编写相应程序，并调试运行。
注意在调试过程中用不同的数据进行测试。
（有效和无效数据）（2）编写实验报告。
运算符重载
第4章运算符重载4.1 什么是运算符重载所谓重载，就是重新赋予新的含义。
函数重载就是对一个已有的函数赋予新的含义，使之实现新功能。
运算符也可以重载。
实际上，我们已经在不知不觉之中使用了运算符重载。
如：+可以对int、float、double的数据进行加法运算。
现在要讨论的问题是：用户能否根据自己的需要对C++已提供的运算符进行重载，赋予它们新的含义，使之一名多用。
譬如，能否用“+”号进行两个复数、两个点的相加。
在C++中不能在程序中直接用运算符“+”对复数进行相加运算。
用户必须自己设法实现复数相加。
例如用户可以通过定义一个专门的函数来实现复数相加。
见下例。
//例4.1 通过函数来实现复数相加。
#include <iostream>using namespace std;class Complex{public:Complex(){real=0;imag=0;} //构造函数Complex(double r,double i){real=r;imag=i;} //构造函数重载Complex complex_add(Complex &c2); //声明复数相加的函数void display(); //声明输出函数private:double real, imag;};Complex Complex::complex_add(Complex &c2){ Complex c;c.real=real+c2.real;c.imag=imag+c2.imag;return c;//以上可简写为：return Complex(real+c2.real,imag+c2.imag);}void Complex::display(){ cout<<"("<<real<<","<<imag<<"i)"<<endl;}int main(){ Complex c1(3,4),c2(5,-10),c3;c3=plex_add(c2);cout<<"c1="; c1.display();cout<<"c2="; c2.display();cout<<"c1+c2="; c3.display();return 0;}结果无疑是正确的，但调用方式不直观、太烦琐，使人感到很不方便。
tutorial4----运算符的重载
实验四运算符重载一、实验编号10003809172j二、实验学时2学时三、实验目的1、熟练掌握运算符重载的方法。
2、熟练运用运算符重载解决实际问题。
四、实验内容1、定义复数Complex类，包含私有成员double real,imag，重载运算符+和-2、定义Date类，并重载运算符++五、实验原理1、运算符重载（1）成员函数方式运算结果类型operator 运算符(形式参数){ 函数体}（2）友元函数方式friend 结果类型operator 运算符(对象参数，参数){ 函数体}双目（返回类型类名∷operator 双目运算符（类名&引用））2、运算符重载规则（1）不可以重载非C++的运算符；（2）运算符重载可以采用成员函数方式或友元方式；（3）被重载的运算符必须保持预定义的的优先级与结合性；（4）应尽量使重载的运算符语义自然、好理解；（5）注意各运算符之间的联系。
六、参考答案1、定义Complex类，包含私有成员double real,imag；并重载运算符+和-1.#include <iostream.h>2.class Complex3.{4.private:5.double real,imag;6.public:plex(double x0=0,double y0=0);plex operator-(const Complex &b);//以成员函数形式重载运算符‘-’9.friend Complex operator+(const Complex &a,const Complex &b);//以友元函数形式重载运算符'+'10.void Display()11.{12.If(real!=0&&imag!=0)13.cout<<real<<'+'<<imag<<'i'<<endl;14.Else if(real!=0&&imag==0)15.Cout<<real<<endl;16.Else if(real==0&&imag!=0)17.Cout<<imag<<"i"<<endl;18.Else19.Cout<<"0"<<endl;20.}21.};plex ::Complex (double x0,double y0)23.{24.real=x0;25.imag=y0;26.}plex Complex ::operator-(const Complex &b)28.{29.return Complex (real-b.real,imag-b.imag);30.}plex operator+(const Complex &a,const Complex &b)32.{33.return Complex (a.real+b.real,a.imag+b.imag);34.}35.void main()36.{37.Double x1,y1,x2,y2;38.cout<<"input x1,y1 of v1,x2,y2 of v2:";39.cin>>x1>>y1>>x2>>y2;plex v1(x1,y1),v2(x2,y2),v;41.42.v=v1+v2;43.cout<<"v1 is:";44.v1.Display();45.cout<<"v2 is:";46.v2.Display();47.cout<<"v1+v2 is:";48.v.Display();49.50.v=v1-v2;51.cout<<"v1-v2 is:";52.v.Display();53.}2、定义Date类，并重载运算符++1.#include <iostream.h>2.class Date{3.private:4.int year;5.int month;6.int day;7.public:8.void SetDate(int x,int y,int z);9.Date operator++();//以成员函数形式重载前置++10.Date operator++(int);//以成员函数形式重载后置++11.void ShowDate(void);12.};13.void Date::SetDate(int x,int y,int z)14.{15.year=x; month=y; day=z;16.}17.Date Date::operator++()//重载前置++18.{19.day=day+1;20.if((month==1||month==3||month==5||month==7||month==8||month==10||month==12)&&day==32)21.{22.day=1;23.month=month+1;24.if(month==13)25.{26.month=1;27.year=year+1;28.}29.}30.else if((month==4||month==6||month==9||month==11)&&day==31)31.{32.day=1;33.month=month+1;34.}35.else if(month==2)36.{37.if ((year%4==0&&year%100!=0)||(year%400==0))//闰年38.{39.if (day==30)40.{41.day=1;42.month=month+1;43.}44.}45.else if (day==29)46.{47.day=1;48.month=month+1;49.}50.}51.return *this;52.}53.Date Date::operator++(int)//重载后置++54.{55.Date temp(*this);56.day=day+1;57.if((month==1||month==3||month==5||month==7||month==8||month==10||month==12)&&day==32)58.{59.day=1;60.month=month+1;61.if(month==13)62.{63.month=1;64.year=year+1;65.}66.}67.else if((month==4||month==6||month==9||month==11)&&day==31)68.{69.day=1;70.month=month+1;71.}72.else if(month==2)73.{74.if ((year%4==0&&year%100!=0)||(year%400==0))//闰年75.{76.if (day==30)77.{78.day=1;79.month=month+1;80.}81.}82.else if (day==29)83.{84.day=1;85.month=month+1;86.}87.}88.return temp;89.}90.void Date::ShowDate(void)91.{92.cout<<year<<"/"<<month<<"/"<<day<<endl;93.}94.void main()95.{96.Date day1;97.int x,y,z;98.cout<<"input current date:";99.cin>>x>>y>>z;100.while(1)//判断输入是否有效101.{102.if ( ((y==1||y==3||y==5||y==7||y==8||y==10||y==12)&&(z<=31)&&(z>=1)) || 103.((y==4||y==6||y==9||y==11)&&(z<=30)) ||104.(((x%4==0&&x%100!=0)||(x%400==0))&&(y==2)&&(z<=29)&&(z>=1)) || 105.(!((x%4==0&&x%100!=0)||(x%400==0))&&(y==2)&&(z<=28)&&(z>=1)) 106.)107.break;108.else109.{110.cout<<"input error!,input current date again:";111.cin>>x>>y>>z;112.}113.}114.day1.SetDate(x,y,z);115.cout<<"the current day is:";116.day1.ShowDate();117.118.day1++;119.cout<<"after day1++ day1 is:";120.day1.ShowDate();121.++day1;122.cout<<"after ++day1 day1 is:";123.day1.ShowDate();124.Date day2=day1++;125.cout<<"after day2=day1++ day1 is:";126.day1.ShowDate();127.cout<<"day2 is:";128.day2.ShowDate();129.day2=++day1;130.cout<<"after day2=++day1 day1 is:";131.day1.ShowDate();132.cout<<"day2 is:";133.day2.ShowDate();134.}。
运算符重载实验报告
一、实验目的1. 理解运算符重载的概念和原理。
2. 掌握C++中运算符重载的方法和规则。
3. 通过实例，实现自定义类型对运算符的重载。
4. 分析运算符重载在实际编程中的应用和优势。
二、实验环境1. 编程语言：C++2. 开发环境：Visual Studio 20193. 操作系统：Windows 10三、实验内容1. 运算符重载的概念和原理2. 运算符重载的方法和规则3. 自定义类型运算符重载实例4. 运算符重载的实际应用四、实验步骤1. 概念和原理运算符重载是指为已有的运算符赋予新的功能，使其能够应用于自定义类型的数据。
在C++中，运算符重载可以通过成员函数或友元函数实现。
2. 方法和规则- 成员函数重载：在自定义类型中定义一个成员函数，该函数的名称与要重载的运算符相同。
- 友元函数重载：在自定义类型外部定义一个友元函数，该函数的名称与要重载的运算符相同，并在函数声明中添加类名和作用域解析运算符。
运算符重载规则：- 运算符重载的函数必须返回与操作数相同的类型。
- 运算符重载的函数不能改变原有运算符的操作数个数。
- 运算符重载的函数不能改变原有运算符的优先级。
- 运算符重载的函数不能改变原有运算符的结合性。
3. 自定义类型运算符重载实例假设我们有一个自定义类型`Point`，表示二维平面上的一个点，其坐标为`(x, y)`。
```cppclass Point {public:int x, y;Point(int x, int y) : x(x), y(y) {}// 成员函数重载加法运算符Point operator+(const Point& p) const {return Point(x + p.x, y + p.y);}// 友元函数重载加法运算符friend Point operator-(const Point& p1, const Point& p2);};// 实现友元函数重载减法运算符Point operator-(const Point& p1, const Point& p2) {return Point(p1.x - p2.x, p1.y - p2.y);}```4. 运算符重载的实际应用运算符重载在实际编程中具有以下优势：- 提高代码可读性：使用自定义类型时，可以像操作基本数据类型一样使用运算符，提高代码的可读性。
C++程序设计运算符重载实验报告
二、实验内容与设计（主要内容，操作步骤、算法描述或程序代码）
本次实验主要实现以下内容：
【项目内容】
定义一个复数类Complex，重载运算符“+”，“-”，“*”，“/”“++”“--”“>”“<”，使之能用于复数的加、减、乘、除、自增、自减、比较大小。运算符重载函数作为Complex类的成员函数。编程序，分别求两个复数之和、差、积、商、自增、自减、比较大小。 提示：注意复数的乘、除法计算。
//重载*
Complexoperator*(Complex a,Complex b){
Complex t;
t.r=a.r*b.r-a.i*b.i;
t.i=b.r*b.i+b.i*b.r;
returnt;
}
//重载/
Complexoperator/(Complex a,Complex b) {
Complex t;
专业：计算机科学与技术年级班级：13计科
学生姓名：侯瑄学号：222013321210092
实验教师：陈睿
计算机与信息科学学院软件学院
实验项目名称
C++程序设计运算符重载
实验时间
2015.10.25
实验类型
□验证性□设计性□综合性
一、实验目的和要求
（1）掌握通过运算符重载实现多态性的方法；
（2）学会运算符重载的成员函数法和友元函数法；
cout<<r;
if(i>0) cout<<"+";
if(i!=0) cout<<i<<"i"<<endl;
实验四 函数和运算符重载
实验四函数重载和运算符重载(2学时)一、实验目的1．掌握函数的定义和调用方法。
2．练习重载函数的使用，注意与缺省参数的区别。
3．练习函数模板的使用。
4.练习运算符重载。
5．练习使用系统函数。
6．学习使用VC++的debug调试功能，使用step into追踪到函数内部。
二、实验任务1．定义一个简单的菜单类，运行时显示主菜单，可通过选择进入子菜单（可模仿ATM柜员机的模式，菜单内容可自行设定，相关功能函数可不用实现）：主菜单：取现的子菜单1.转账 1.5002.余额查询 2.10003.取现 3.1500Q(退出) 4.返回主菜单请选择(A/S/F/Q)?选择相应的选项后悔执行相应模块并回到主菜单，选择Q则退出。
2．编写重载函数Maxl可分别求取两个整数，三个整数，两个双精度数，三个双精度数的最大值。
3．使用重载函数模板重新实现上小题中的函数Maxl。
4．使用系统函数pow(X，y)计算X y的值，注意包含头文件math.h。
5．用递归的方法编写函数求Fibonacci级数，观察递归调用的过程。
6.写一个点point的类,并重载+实现两个点的坐标相加，和-实现求两点间的距离， >>、<<输入输出点的信息，（1）和（2）分别取点的x和y轴坐标。
三、实验步骤1．考虑抽取菜单的数据和相关操作。
2．分别编写四个同名函数maxl，实现函数重载，在main()函数中测试函数功能。
程序名：lab3_2．cpp。
3．使用函数模板实现求任意类型数的最大值，针对不同的参数个数，编写两个同名函数模板maxl，其参数个数不同，实现函数重载，在main()函数中测试函数功能。
程序名：lab3_3．cpp。
4．在main()函数中提示输入两个整数x、y，使用cin语句得到x、y的值，调用pow(x，y)函数计算x的Y次幂的结果，再显示出来。
程序名．1ab3_4.cpp。
5．编写递归函数int fib(int n)，在主程序中输入n的值，调用fib函数计算Fibonacci级数。
运算符重载的方法
运算符重载的方法
运算符重载是指在类中重新定义某个运算符，使其能够用于类的实例。
重载运算符可以方便地对类对象进行加、减、乘、除等基本运算，也可以定义自定义运算符，以实现类特定的功能。
运算符重载的方法如下：
1.编写运算符重载函数：将要重载的运算符的符号作为函数名，如“+”、“-”、“*”、“/”等，对于自定义运算符可以自己命名。
2.指定参数个数和类型：重载函数需要参数，这些参数有不同的类型，可以是类的成员变量或其他类型的变量。
3.重载运算符要求：
（1）操作数至少有一个是类的实例，重载函数可以定义为类的成员函数或全局函数。
（2）运算符重载不能改变原有操作数的类型或个数。
（3）运算符重载函数可以返回任何类型的值，甚至可以是类的实例。
4.使用运算符：一旦重载运算符函数定义好之后，就可以像使用普通的运算符一样使用它。
需要注意的是，运算符重载不是万能的，对于某些运算符，如“&&”、“”等，是不能够重载的。
此外，在使用运算符重载时应该避免过于复杂的实现方式，以防止代码难以理解和维护。
运算符重载实验报告参考模板
《面向对象程序设计》课程设计报告专业软件工程班级姓名学号指导教师起止时间2011.2~2011.4课程设计课题之一：运算符重载一、任务描述1．掌握运算符重载的定义；2.掌握重载运算符的方法。
二、问题分析1、设计基础：,设计一个可进行复数运算的演示程序2、分析设计课题的要求，要求编程实现以下功能：实现复数的加减法三、数据结构设计1，定义类，设计构造函数和显示函数print();2，重载运算符“+”、“-”为类FS的成员函数。
3，实例化FS类的2个对象,并利用重载的运算符对其进行计算四、功能设计#include<iostream.h>class complex//复数类声明{private:double real;double image;public:complex(double r=0.0,double i=0.0)//构造函数{real=r;image=i;complex operator+(complex c2);//+重载为成员函数complex operator-(complex c2);//-重载为成员函数void display();};complex complex::operator +(complex c2)//重载的实现{complex c;c.real=c2.real+real;c.image=c2.image+image;return complex(c.real,c.image);}complex complex::operator -(complex c2)//重载的实现{complex c;c.real=real-c2.real;c.image=image-c2.image;return complex(c.real,c.image);}void complex::display(){cout<<"("<<real<<","<<image<<")"<<endl;void main(){complex c1(5,4),c2(2,10),c3;cout<<"c1=";c1.display();cout<<"c2=";c2.display();c3=c1+c2;//使用重载运算符完成复数加法cout<<"c3=c1+c2=";c3.display();c3=c1-c2;//使用重载运算符完成复数减法cout<<"c3=c1-c2=";c3.display();}五、程序运行结果六、体会与收获通过这次实验我进一步了解运算符重载的概念和使用方法，掌握几种常用的运算符重载的方法，学会了使用重载运算符进行复数的加减法。
实验四-运算符重载-实验报告
实验报告实验目的：掌握运算符重载的语法要点，学会运算符重载的编程方法。
实验内容：（1）先读程序，预测程序的输出结果，再运行程序验证程序的输出。
用友元重载方式重新编写次程序。
#include <iostream.h>class V ector{ public:V ector(){}V ector(int i,int j) {x=i;y=j;}friend V ector operator+=(V ector v1,V ector v2){ v1.x+=v2.x;v1.y+=v2.y;return v1;}V ector operator-=(V ector v){ V ector temp;temp.x=x-v.x;temp.y=y-v.y;return temp;}void display(){ cout<<"("<<x<<","<<y<<")"<<endl;}private:int x,y;};void main(){V ector v1(1,2),v2(3,4),v3,v4;v3=v1+=v2;v4=v1-=v2;cout<<"v1=";v1.display();cout<<"v2=";v2.display();cout<<"v3=";v3.display();cout<<"v4=";v4.display();}运行结果：v1=(1,2)v2=(3,4)v4=(-2,-2)Press any key to continue用友元重载方式重新编写次程序：#include <iostream>using namespace std;class V ector{public:V ector(int i = 0,int j = 0){x=i;y=j;}friend V ector operator+=(V ector &v1,V ector &v2) {v1.x+=v2.x;v1.y+=v2.y;return v1;}friend V ector operator-=(V ector &v1,V ector &v2){v1.x=v1.x-v2.x;v1.y=v1.y-v2.y;return V ector( v1.x, v1.y);}void display(){cout<<"("<<x<<","<<y<<")"<<endl;}private:int x,y;};void main(){V ector v1(1,2),v2(3,4),v3,v4;v3 = v1+=v2;v4 = v1-=v2;cout<<"v1="; v1.display();//1,2cout<<"v2="; v2.display();//3,4cout<<"v3="; v3.display();//4,6cout<<"v4="; v4.display();//1,2}运行结果：v2=(3,4)v3=(4,6)v4=(-2,-2)Press any key to continue（2）定义一个有理数类，重载比较运算符.写一个完整的程序，进行数据成员的设置和输出。
运算符重载—C++课程实验报告
using namespace std; class AB
{
public:
AB(int xx, int yy); void ShowAB(); AB& operator ++(); AB operator ++(int);
AB& operator --();
AB operator --(int);
通过这次实验我基本掌握了通过运算符重载实现多态性的方法学会了运算符重载的成员函数法和友元函数法基本能够区分单目运算符的前置与后置
C++
学生姓
名
xxx
班级
学号
xxxxxxxxx
实验项
目
实验四运算符重载
指导教师
杜之波
实验目
的和要
求
一、实验目的
（1）掌握通过运算符重载实现多态性的方法；
（2）学会运算符重载的成员函数法和友元函数法；
运算后，
A的值为："
什+AA).ShowAB();
coutvv"
B
的值为：";
(++BB).ShowAB();
cout<v"B=A--运算后，A的值为：";
(--AA).ShowAB();
coutvv"B的值为：";
(BB--).ShowAB();
cout<<"B=--A运算后，A的值为：";
(--AA).ShowAB();
{
AB AA(0,0);
AB BB(0,0);
cout<v"A的值为:";
运算符重载-- 实验报告
南昌航空大学实验报告2011年12月1号课程名称：面向对象程序设计B 实验名称：运算符重载班级：姓名：同组人：无指导教师评定: 签名：一、实验目的理解运算符重载（非成员形式和成员形式）、学习重载几类运算符（++，=，！=，+，-，==等）。
二、实验内容应用VC++6.0的构建一个复数类Complex，试对下列几个运算符进行重载：++，=，！=，+，-，==，其中要求要有成员重载形式和友元重载形式，而且，++运算符要求实现先加和后加两种形式。
三、概要设计函数原型：class complex{private:double real;double image;public:complex(double r=0,double i=0);complex &operator+(complex &c);complex operator-(complex &c);complex operator*(complex &c);friend complex operator/(complex &c1,complex &c2);friend bool operator==(complex &c1,complex &c2);friend bool operator!=(complex &c1,complex &c2);complex operator++();complex operator++(int);void show();｝；四、详细设计重载运算符 + 的函数：complex &complex::operator+(complex &c){complex temp;temp.real=real+c.real;temp.image=image+c.image;return temp;}重载运算符 - 的函数：complex complex::operator-(complex &c){complex temp;temp.real=real-c.real;temp.image=image-c.image;return temp;}重载运算符 * 的函数：complex complex::operator*(complex &c){complex temp;temp.real=real*c.real;temp.image=image*c.image;return temp;}重载运算符 / 的函数：complex operator/(complex &c1,complex &c2){complex temp;double t;t=1/(c2.real*c2.real+c1.image*c1.image);temp.real=(c1.real*c2.real+c1.image*c2.image)*t;temp.image=(c2.real*c1.image-c1.real*c2.image)*t;return temp;}重载运算符 == 的函数：bool operator==(complex &c1,complex &c2){if(c1.real==c2.real&&c1.image==c2.image)return true;elsereturn false;重载运算符 != 的函数：bool operator!=(complex &c1,complex &c2){if(c1.real!=c2.real||c1.image!=c2.image) return true;elsereturn false;}重载运算符 ++ 的函数：complex complex::operator++(){++real;++image;return *this;}complex complex::operator++(int){real++;image++;return *this;}五、程序调试经调试无误后，运行的结果为：六、实验总结通过这次的试验，我明显的感觉到自己对这方面的知识掌握的还不够熟练，不能顺利地、流畅地运用这方面的知识，因为我没有在规定的时间内完成程序的设计，课后还是要多复习。
C++程序设计04737 第4章 运算符重载
//成员函数
myComplex &operator=(double);
//成员函数 };
myComplex::myComplex(){ real=0;imag=0;}
myComplex::myComplex(double r,double i)
{real=r;imag=i;}
myComplex myComplex::addCom(myComplex c1) {return myComplex(this->real+c1.real,this->imag+c1.imag); } void myComplex::outCom(){cout<<"("<<real<<","<<imag<<")";} void myComplex::outCom(string s) {cout<<s<<"=("<<real<<","<<imag<<")"<<endl;} void myComplex::changeReal(double r) {this->real=r;} myComplex operator+(const myComplex &c1,const myComplex &c2) //c1+c2 {return myComplex(c1.real+c2.real,c1.imag+c2.imag);}//返回一个临时对象 myComplex operator+(const myComplex &c1,double r) //c1+r {return myComplex(c1.real+r,c1.imag);} //返回一个临时对象 myComplex operator+(double r,const myComplex &c1) //r+c1 {return myComplex(r+c1.real,c1.imag);} //返回一个临时对象 myComplex operator-(const myComplex &c1,const myComplex &c2)//c1-c2 {return myComplex(c1.real-c2.real,c1.imag-c2.imag);}//返回一个临时对象 myComplex operator-(const myComplex &c1,double r) //c1-r {return myComplex(c1.real-r,c1.imag);//返回一个临时对象} myComplex operator-(double r,const myComplex &c1) //r-c1 {return myComplex(r-c1.real,-c1.imag); //返回一个临时对象} myComplex &myComplex::operator=(const myComplex &c1) {this->real=c1.real;this->imag=c1.imag;return *this; } myComplex &myComplex::operator=(double r) {this->real=r;this->imag=0;return *this;}
运算符重载实验报告
RMB::RMB(unsigned int d, unsigned int c)
{
yuan = d;
jf = c;
while ( jf >=100 ){ //以使构造时，确保角分值小于100
yuan ++;
jf -= 100;
}
}
RMB operator+(RMB& s1, RMB& s2) // 此处改为RMB& operator+(RMB& s1, RMB& s2)
private:
unsigned int yuan; //元
unsigned int jf; //角分
};
RMB RMB::interest(double rate)
{
return RMB((yuan + jf / 100.0) * rate);
}
RMB RMB::add(RMB d)
{
return RMB(yuan + d.yuan + jf / 100.0 + d.jf / 100.0);
expense2(x,yrate).display();
}
3.实验结果：
（二）实验题目二：
（2） 将以下程序中重载运算符定义函数的返回类型更改（值返回更改为引用返回，引用
返回更改为值返回），观察程序运行结果，说明原因。
#include<iostream.h>
class RMB{
public:
RMB(unsigned int d, unsigned int c);
学 号：
指导教师：
2013年11月18日
运算符重载解读
02
在重载运算符时，应明确指定 运算符的参数类型和返回类型 ，避免与其他操作符混淆。
03
在重载运算符时，应尽量使用 有意义的操作符名称，以提高 代码的可读性。
考虑性能和效率
01
02
03
运算符重载时，应考虑 性能和效率，避免对原 有代码造成不必要的性
能损失。
在重载运算符时，应尽 量减少额外的计算和内 存开销，以提高代码的
一元运算符重载
一元运算符重载是指对一元运算符进行重载，使其能够应用于一个操作数。例如，在C中，我们可以 重载一元减号运算符(-)来返回一个数的相反数。
常见的一元运算符有：+、-、~、!等。
二元运算符重载
二元运算符重载是指对二元运算符进行重载，使其能够应用于两个操作数。例如，在C中，我们可以重载加号运算符(+)来定 义两个自定义类型的相加行为。
01
提高代码可读性
运算符重载可以使代码更易读， 因为运算符的使用可以使代码更 简洁、更直观。
02
03
方便函数调用
运算符重载可以使得函数调用更 加方便，因为运算符的使用可以 减少函数调用的开销。
04
缺点分析
易造成混淆
运算符重载可能会使得代码难以理解，因为 运算符的行为可能会被改变，导致读者难以
理解代码的含义。
常见的二元运算符有：+、-、*、/、%等。
三元运算符重载
三元运算符重载是指对三元运算符进行重载，使其能够应用于三个操作数。例如，在C中，我们可以重载条件运 算符(?)来定义一个自定义类型的条件判断行为。
常见的三元运算符有：?:。
03
运算符重载的常见场景
类与类之间的运算
01
两个类对象之间的加法运算，可以表示它们之间的某种关联或 合并。