实验5 运算符重载
运算符重载实验报告
运算符重载实验报告运算符重载实验报告引言：运算符重载是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。
实验五 运算符重载 完成
output<<"("<<a.x<<","<<a.y<<")";
return output;
}
int main() //主函数
{
Point a,b;
a.Input();
a.Display();
b.Input();
b.Display();
a=a+b;
cout<<"Overload'+'----a=a+b:"<<a<<endl;
Point operator+(Point &b);
Point operator-(Point &b);
friend int operator==(Point &a,Point &b);
friend int operator!=(Point &a,Point &b);
friend Point operator++(Point &a);
{
Point c;
c.x=a.x;
c.y=a.y;
a.x--;
a.y--;
return c;
}
istream & operator>>(istream & input,Point & a) //重载流插入运算符
{
input>>a.x>>a.y;
return input;
}
ostream & operator<<(ostream & output,Point & a) //重载流插入运算符
运算符重载和类模板实验报告
洛阳理工学院实验报告
系别
计算机与信息工程系
班级
B110
学号
B11050
姓名
课程名称
C++面向对象程序设计
实验日期
2013.11.5
实验名称
运算符重载和类模板
template<typename T>
T max(T a,T b,T c)
{
if(b>a) a=b;
if(c>a) a=c;
return a;
}
int main()
{
int i1=1,i2=2,i3=3,i;
double d1=3.2,d2=6.3,d3=4.8,d;
long l1=35463,l2=21345,l3=12345,l;
成绩
实验目的：
1、掌握C++中运算符重载的机制和运算符重载的方式；
2、掌握类型转换的方式、内存的动态分配；
3、掌握类模板的定义，掌握类模板的实例化。
实验条件：
装有Microsoft Visual C++6.0软件的计算机
实验内容：类名∷operator单目运算符( )）
};
int main()
{Compare <int> cmp1(3,7);
cout<<cmp1.max()<<endl;
cout<<cmp1.min()<<endl;
Compare <float> cmp2(3.1f,7.2f);
实验5 运算符重载的应用
实验5 运算符重载的应用实验5 运算符重载的应用5.1实验目的1.掌握用成员函数重载运算符的方法2.掌握用友元函数重载运算符的方法5.2实验内容与步骤1.机实验题一定义一个复数类，通过重载运算符：*，/，直接实现二个复数之间的乘除运算。
编写一个完整的程序，测试重载运算符的正确性。
要求乘法“*”用友元函数实现重载，除法“/”用成员函数实现重载。
⑴分析两复数相乘的计算公式为：(a+b i)*(c+d i)=(ac–bd )+(ad+bc) i两复数相除的计算公式为：(a+b i)/(c+d i)=(ac+bd)/(c*c+d*d)+(bc-ad)/(c*c+d*d) i复数类及运算符重载函数可定义为：class Complex{float Real, Image;public:Complex(float r=0,float i=0) { Real=r;Image=i;}void Show(){cout <<"Real="<<Real<<'\t'<<"Image="<<Image<<'\n';}friend Complex operator *(Complex &, Complex &);Complex operator /(Complex &); //重载运算符+ };Complex operator *( Complex &c1,Complex &c2){Complex t;t.Real=c1.Real * c2.Real - c1.Image * c2.Image;t.Image = c1.Image*c2.Real +c1.Real* c2.Image;return t;}Complex Complex::operator /(Complex &c){C++面向对象程序设计实验指导Complex t;t.Real =(Real *c.Real+ Image * c.Image)/(c.Real*c.Real+ c.Image * c.Image);t.Image = (Image *c.Real - Real * c.Image)/(c.Real*c.Real+ c.Image * c.Image);return t;}⑵上机要求增加重载复数的加法和减法运算符的功能，实现两个复数的加法，一个复数与一个实数的加法；两个复数的减法，一个复数与一个实数的减法。
运算符重载实验模板
高级程序设计语言C++实验报告学号：姓名：日期：实验运算符重载1.实验目的1）进一步了解运算符重载的概念和使用方法。
2）掌握几种常用的运算符重载的方法。
3）了解转换构造函数的使用方法。
4）了解在Visual C++6.0环境下进行运算符重载要注意的问题。
2.实验内容和步骤1）定义一个复数类Complex，重载运算符“+”和“-”，使之能用于复数的加和减，分别求两个复数的和和差。
要求“+”运算符重载函数作为友元函数，“-”运算符重载作为成员函数。
源程序：运行结果2）定义一个复数类Complex，重载运算符“+”使之能够完成复数的加法运算，参加运算的两个运算量可以都是类对象，也可以其中一个是整数，顺序任意（即c1+i，和i+c1都能实现，这里c1是复数类对象，i是整数）。
编程序，分别求两个复数之和、整数和复数之和，满足交换律。
源程序：运行结果3）编写程序，处理一个复数与一个double数相加的运算，结果存放在一个double型的变量d1中，输出d1的值，再以复数形式输出此值。
定义Complex（复数）类，在成员函数中包含重载类型转换运算符：operator double( ) {return real;}源程序：运行结果4) 定义一个Teacher（教师）类和一个Student（学生）类，二者有一部分数据成员是相同的，例如num（号码），name（姓名），sex（性别）。
编写程序，将一个Student对象（学生）转换为Teacher（教师）类，只将以上3个相同的数据成员移植过去。
可以设想为：一位学生大学毕业留校担任老师，他原有的部分数据仍然是有用的，应当保留。
源程序：运行结果3.实验中遇到的问题及解决方法。
实验5 运算符重载
实验5 运算符重载1、实验目的和要求：掌握运算符重载的语法要点，学会运算符重载的编程方法。
2、实验内容（1）先读程序，写出程序的输出结果，再运行程序验证程序的输出。
用友元重载方式重新编写程序。
#include <iostream>using namespace std;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();}（2）定义一个有理数类，重载比较运算符.写一个完整的程序，进行数据成员的设置和输出。
class rational{private:long denom,den;//denom为分子,den为分母public:rational(int num=0, int denom=1;int operator<(rational r) const;int operator<=(rational r) const;int operator= =(rational r) const;int operator!=(rational r) const;//这里增加赋值和读出函数}(3) 设计集合类（Set），用运算符重载实现并（+），差（—），交（×）等操作，并重载=和-= ，实现Set S1，S2；… s1 = s2; 和S1-=S2；集合S1中去掉S2中存在的元素的操作。
[C++]运算符重载实验报告
![[C++]运算符重载实验报告](https://img.taocdn.com/s3/m/29d7be84bb68a98271fefabf.png)
+operator+(const COMPLEX &other): COMPLEX+operator-(const COMPLEX &other) : COMPLEX+operator-(): COMPLEX+operator=(const COMPLEX &other) : COMPLEX运行结果2. 程序的类结构图为：Tx,y:int+T(int a,int b)+&operator<<(ostream &os,T &a):friend ostream运行结果3. 程序的类结构图为：Shape+Area():virtual double const+PrintShapeName():virtual void const +Print():virtual void constPointx,y:int+Point(int=0,int=0)+SetPoint(int a,int b):void+GetX():int const+GetY():int const+PointShapeName():virtual void const +Print():virtual void constCircleradius:double+Circle(int x=0,int y=0,double r=0.0) +SetRadius(double r):void+GetRadius():double const+Area():virtual double const+Print():virtual void const+PrintShapeName():virtual void const 运行结果{cout<<'['<<x_size<<","<<y_size<<']'<<", "<<'['<<i_size<<","<<j_size<<']'; }int main(){Circle1 circle(0.0,0.0,3.0);circle.area();circle.perimeter();circle.print();cout<<"\n";Square1 square(0.0,0.0,3.0,3.0);square.area();square.perimeter();square.print();cout<<"\n";cout<<"圆的面积为："<<circle.area()<<endl;cout<<"圆的周长为："<<circle.perimeter()<<endl;cout<<"圆的圆心坐标和半径为：";circle.print();cout<<"\n\n";cout<<"正方形的面积为："<<square.area()<<endl;cout<<"正方形的周长为："<<square.perimeter()<<endl;cout<<"正方形的中心坐标和一个顶点坐标分别为：";square.print();cout<<"\n";return 0;}运行结果【实例编程】运行结果。
运算符重载类型转换与类实验报告范文
运算符重载类型转换与类实验报告范文实验题目运算符重载类型转换与类模板日期
班级
组别
姓名
类型
【实验目的】
1．掌握运算符重载的定义及实现。
2．熟练掌握运算符重载为类成员函数和重载为一般普通函数的区别。
3．掌握类型转换的方法。
【实验原理】
将运算符“+=”重载为适用于两个复数的复合赋值运算。
【实验器材】
微型计算机、ViualC++6.0集成软件平台
【实验步骤】
1．编辑源程序.2．对源程序进行编译并调试程序.3．连接并运行程序；4．检查输出结果是否正确。
程序设计如下：
#includeclaData{public:Data(doubler=0,doublei=0){real=r;imag =i;}Dataoperator+=(Data某);voidprint();private:
doublereal;doubleimag;};DataData::operator+=(Data某){real=某.real+real;imag=某.imag+imag;return某
thi;}voidData::print(){cout<
【实验结论】
讲的很好，很有指导意义。
运算符重载实验报告
一、实验目的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++实验5运算符重载
C++实验5运算符重载
实验5 运算符重载
一、实验目的
1.理解运算符重载概念；
2.学会使用运算符重载；
3.练习类和对象的使用。
二、实验内容
设计一个日期类Date，包括年、月、日等私有数据成员。
要求实现日期的基本运算，如某日期加上天数、某日期减去天数、两日期相差的天数等。
三、实验要求
在Date类中设计如下重载运算符函数：
Date operator+(int days)：返回某日期加上天数得到的日期
Date operator-(int days)：返回某日期减去天数得到的日期int operator-(Date&b)：返回两日期相差的天数
在实现这些重载运算符函数时调用以下私有成员函数：
leap(int)：判断指定的年份是否为闰年
dton(Date &)：将指定日期转换成从0年O月O日起的天数
ntod(int)：将指定的0年O月O日起的天数转换成对应的日期
提示：可定义一个二维数组，存放闰年和非闰年每个月的天数，用于后面的计算，int day_tab[2][12]={{31，28，31，30，3l，30，3l，3l，30，31，30，31)，
{31，29，31，30，31，30，31，31，30，31，30，31}}；
// day_tab二维数组存放各月天数，第一行对应非闰年，第二行对应闰年。
c运算符重载和多态性实验报告
实验5 运算符重载和多态性一、实验目的1．掌握用成员函数重载运算符的方法2．掌握用友元函数重载运算符的方法3．理解并掌握利用虚函数实现动态多态性和编写通用程序的方法4．掌握纯虚函数和抽象类的使用二、实验内容1．复数类加减法乘除运算 (用成员函数定义运算符重载)。
复数类的定义：class complex //复数类声明{ public: //外部接口complex(double r=0.0,double i=0.0) //构造函数{real=r,imag=i;}complex operator +(complex c2); //运算符"+"重载成员函数complex operator - (complex c2); //运算符"-"重载成员函数complex operator *(complex ); //运算符"*"重载成员函数complex operator /(complex); //运算符"/"重载成员函数complex operator =(complex c2); //运算符"="重载成员函数void display(); //输出复数private: //私有数据成员double real; //复数实部double imag; //复数虚部};实验代码：#include <iostream>using namespace std;class Complex{public:Complex(){real=0;imag=0;}Complex(double r,double i){real=r;imag=i;}Complex operator+(Complex &c2); Complex operator-(Complex &c2); Complex operator*(Complex &c2); Complex operator/(Complex &c2); void display();private:double real; double imag;};Complex Complex::operator+(Complex &c2) {Complex c;c.real=real+c2.real;c.imag=imag+c2.imag; return c;}Complex Complex::operator-(Complex &c2) {Complex c;c.real=real-c2.real;c.imag=imag-c2.imag;return c;}Complex Complex::operator*(Complex &c2) {Complex c;c.real=real*c2.real-imag*c2.imag;c.imag=imag*c2.real+real*c2.imag; return c;}Complex Complex::operator/(Complex &c2){Complex c;c.real=(real*c2.real+imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag );c.imag=(imag*c2.real-real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);return c;}void Complex::display(){cout<<"("<<real<<","<<imag<<"i)"<<endl;}int main(){Complex c1(4,6),c2(3，7),c3;cout<<"c1=";c1.display();cout<<"c2=";c2.display();int i,j=1;while(j){cout<<"\n";cout<<"\t\t"<<"1.复数之和\n"; cout<<"\t\t"<<"2.复数之差\n"; cout<<"\t\t"<<"3.复数之积\n"; cout<<"\t\t"<<"4.复数之商\n"; cout<<"\t\t"<<"0.退出\n"; cout<<"请选择（0－－4）"; cin>>i;switch(i){case 1: c3=c1+c2;cout<<"c1+c2=";c3.display(); break;case 2: c3=c1-c2;cout<<"c1-c2=";c3.display();break;case 3: c3=c1*c2;cout<<"c1*c2=";c3.display();break;case 4: c3=c1/c2;cout<<"c1/c2=";c3.display();break;case 0: j=0;break;}}}测试结果：2．复数类比较运算 (用友元函数定义运算重载)。
运算符重载的方法
运算符重载的方法
运算符重载是指在类中重新定义某个运算符，使其能够用于类的实例。
重载运算符可以方便地对类对象进行加、减、乘、除等基本运算，也可以定义自定义运算符，以实现类特定的功能。
运算符重载的方法如下：
1.编写运算符重载函数：将要重载的运算符的符号作为函数名，如“+”、“-”、“*”、“/”等，对于自定义运算符可以自己命名。
2.指定参数个数和类型：重载函数需要参数，这些参数有不同的类型，可以是类的成员变量或其他类型的变量。
3.重载运算符要求：
（1）操作数至少有一个是类的实例，重载函数可以定义为类的成员函数或全局函数。
（2）运算符重载不能改变原有操作数的类型或个数。
（3）运算符重载函数可以返回任何类型的值，甚至可以是类的实例。
4.使用运算符：一旦重载运算符函数定义好之后，就可以像使用普通的运算符一样使用它。
需要注意的是，运算符重载不是万能的，对于某些运算符，如“&&”、“”等，是不能够重载的。
此外，在使用运算符重载时应该避免过于复杂的实现方式，以防止代码难以理解和维护。
实验五 运算符重载
实验六运算符重载（2学时）一、实验目的1．掌握运算符重载的规则。
2．掌握用成员函数、友元函数重载运算符的特点。
3．掌握几种常用的运算符重载的方法。
二、实验内容1．阅读下面的程序，写出程序运行的结果。
（1）#include<iostream.h>class ABC{int a,b,c;public:ABC(int x,int y,int z):a(x),b(y),c(z){}friend ostream &operator<<(ostream &out,ABC& f);};ostream &operator<<(ostream &out,ABC& f){out<<"a="<<f.a<<endl<<"b="<<f.b<<endl<<"c="<<f.c<<endl;return out;}int main(){ABC obj(10,20,30);cout<<obj;return 0;}(2) 写出运行结果。
将成员函数重载形式改为友元函数重载形式，友元函数重载形式改为成员函数重载形式#include<iostream.h>class Number{int n;public:Number(int x):n(x){}Number& operator++(){ ++n; return *this; }Number& operator++(int){ n++; return *this;}friend Number &operator--(Number &o);friend Number &operator--(Number o,int);void display(){cout<<"This Number is: "<<n<<endl;}};Number &operator--(Number &o){--o.n; return o; }Number &operator--(Number o,int){o.n--; return o; }int main(){Number N1(10);++ ++ ++N1;N1.display();N1++;N1.display();--N1;N1.display();N1-- -- --;N1.display();return 0;}2．设计并实现一个日期类Date，要求：（1）可以建立具有指定日期（年、月、日）的Date对象，默认日期是2009.1.1。
运算符重载—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的值为:";
运算符重载——精选推荐
运算符重载运算符重载学习运算符重载，让运算符能做⼀些原来做不了的事情，⽅便它的使⽤⼀、运算符重载的概念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）不能返回局部变量的引⽤。
实验5 运算符重载
intSet operator+(intSet &set);
intSet operator *(intSet &set);
void operator = (intSet &set);
friend ostream &operator<<(ostream &,intSet&);
element[i] = set.element[i];
ElementNum = set.ElementNum;
}
//输出整数集合中的元素
ostream & operator<<(ostream &os,intSet &s)
{
for(int i=0;i<=s.ElementNum;i++)
os<<"element["<<i<<"]"<<s.element[i]<<endl;
实验5运算符重载
1、实验目的：
掌握运算符重载的概念及使用方法，掌握特殊运算符的重载要求和方法。
2、实验内容：
定义整数集合类intSet,实现如下功能：
（1）定义类的构造函数，并根据需要可以定义多个构造函数。
（2）Clear函数：清空整数集合
（3）IsEmpty():整数集合是否空集；
（4）IsMemberOf():判断某个整数是否在整数集合内
using namespace std;
class intSet
{
public:
运算符重载实验报告
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
两个类对象之间的加法运算，可以表示它们之间的某种关联或 合并。
运算符重载详解
运算符重载详解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)。
实验5 运算符重载
1．实验目的
通过本次实验
（1）理解运算符重载函数的概念；
（2）掌握运算符重载函数的定义与使用方法；
2．实验要求
（1）编写实验程序
（2）在运行环境中，输入源程序
（3）编译运行源程序
（4）输入测试数据进行程序测试；
（5）写出运行结果。
3．实验内容
（1）定义一个复数类，重载“-=”运算符，使这个运算符能直接完成复数的“-=”运算。
分别用成员函数与友元函数编写运算符重载函数。
在主函数中定义复数对象c1(10,20)、c2(15,30)，进行c2-=c1的复数运算，并输出c1、c2的复数值。
（2）定义一个数组类Array，其私有数据成员为整型一维数组a[10]。
通过构造函数给a[10]赋初值。
用Show函数显示a[10]的元素值。
用成员函数重载运算符“+”，直接实现两个一维数组对应元素相加的运算。
在主函数中定义数组a、b分别为：
int a[10]={1,2,3,4,5,6,7,8,9,10}; int b[10]={4,5,6,7,8,9,10,11,12,13};
用Array定义三个数组对象arr1(a)、arr2(b)、arr3，执行arr3=arr1+arr2运算，输出arr3的数组元素值。
（3）定义一个人民币类Money，类中数据成员为元、角、分。
用成员函数与友元函数重载“――”运算符，实现人民币对象的减1运算。
在主函数中定义人民币对象m1=10元8角5分及对象m2、m3。
对m1作前置“――”并赋给m2。
对m1作后置“――”并赋给m3。
显示m1、m2、m3的结果。
（4）定义描述字符串的类String，编写字符串运算符“+=”的重载函数，使运算符“+=”用于两个字符串联接操作，即用str1+=str2实现字符串函数strcat(str1,str2)的操作功能。
要求分别用成员函数与友元函数编写运算符重载函数。
在主函数中定义字符串对象s1("software and ")与s2("hardware")，进行s1+=s2的字符串联接，并输出s1、s2的值。