运算符重载实验
C++实验三运算符重载
float score;
};
Student::Student(int n,char nam[],char s,float so)
{num=n;
strcpy(name,nam);
sex=s;
score=so;
}
class Teacher
{public:
Teacher(){}
Teacher(Student&);
{
ARRAY c;
int i,j;
for(i=0;i<2;i++)
{
for(j=0;j<3;j++)
{
c.array[i][j]=a.array[i][j]+b.array[i][j];
cout<<c.array[i][j];
cout<<" ";
}
cout<<endl;
}
return c;
}
/*COMPLEXoperator-(COMPLEX a,COMPLEX b)
cout<<"student1:"<<endl;
student1.display();
teacher2=Teacher(student1);
cout<<"teacher2:"<<endl;
teacher2.display();
return 0;
}
三、实验记录及结果
1.任务1
#include <iostream>
using namespace std;
实验12 运算符重载
实验12 运算符重载（2）牛旭艳智能二班 20110807201一、实验目的1、进一步理解运算符重载，运用成员函数和友元函数等方法实现运算符的重载。
二、实验内容1、重载函数调用运算符()，将以下的二维数组的下标表示方法：chessBoard[row][column]改为常用的表示方法：chessBoard(row,column)2、重载下标运算符使之返回集合中最大的元素、次最大的元素以及第三大的元素。
3、开发多项式类Polynomial，多项式的每一项用数组表示，每项包含一个系数和一个指数。
例如：2x4的指数为4，系数为2。
请开发一个完整的Polynomial类，包括构造函数、析构函数以及"get"函数和"set"函数。
该类还要提供下述重载的运算符（分别使用成员函数和友元函数）：1）重载加法运算符+，将两个多项式相加；2）重载减法运算符-，将两个多项式相减；3）重载赋值运算符=，将一个多项式赋给另外一个多项式；4）重载乘法算符*，将两个多项式相乘；5）重载加法赋值运算符+=、减法赋值运算符-=以及乘法赋值运算符*=。
4．设计一个日期类Date,，要求：（1）包含年(year)、月(month)和日(day)私有数据成员。
（2）包含构造函数，重载关于一日期加上天数的加法运算符+、重载关于一日期减去天数的减加运算符-、重载输出运算符<<与输入运算符>>等。
提示：由于各C++编译器对于重载输入/出运算符为友元的兼容性都存在问题，最好重载输入/出运算符不声明为成员函数与友元函数，而声明一般函数，为编程更方便，可增加一些成员函数，比如：void SetYear(int y); // 设置年int SetMonth(int m); // 设置月int SetDay(int d); // 设置日int GetYear() const; // 返回年int GetMonth() const; // 返回月int GetDay() const; // 返回日static int IsLeapyear(int y); // 判断年份y是否为润年static int GetDays(int y); // 年份y的天数static int GetDays(const Date &d); // 日期d当前月份的天数static int DateToNum(const Date &d); // 返回从公元1年1月1日起的天数static Date NumToDate(int n); //由从公元1年1月1日起的天数返回日期润年条件：年份能被4整除，并且年份不能被100整除，或者年份能被400整除润年天数：366平年天数：365润年2月份天数：29平年2月份天数：285．设计一个时间类Time，要求：（1）包含时(hour)、分(minute)和秒(second)私有数据成员。
实验11 运算符重载资料
实验11 运算符重载（1）一、实验目的1、掌握运算符重载的概念；2、掌握使用friend重载运算符的方法。
二、实验内容1、用成员函数重载运算符，使对整型的运算符=、+、-、*、/ 适用于分数运算。
要求：（1）输出结果是最简分数（可以是带分数）；（2）分母为1，只输出分子。
2、用友元函数重载运算符，使对整型的运算符=、+、-、*、/ 适用于分数运算。
3、定义如下集合类的成员函数，并用数据进行测试：class Set{int *elem; //存放集合元素的指针int count; //存放集合中的元素个数public:Set();Set(int s[],int n);int find(int x) const; //判断x是否在集合中Set operator+(const Set &); //集合的并集Set operator-(const Set &); //集合的差集Set operator*(const Set &); //集合的交集void disp(); //输出集合元素};4、定义一个人民币类 RMB，包含私有数据成员元、角、分，请用友元函数重载运算符“+”和“++”，以对类对象进行运算。
三、实验程序及结果#include<iostream>using namespace std;class Complex{public:Complex(int X=0,int Y=0) //构造函数初始化{x=X;y=Y;}void gys() //求最大公约数{int t;t=x%y;while(t!=1){x=y;y=t;t=x%y;}}void print() //输出分数值{int z;if((x<y)&&(y!=1)) //分母大于分子直接输出{cout<<x<<"/"<<y<<endl;}if((x>y)&&(y!=1)) //分母小于分子输出带分数{z=x/y;cout<<z<<"("<<x%y<<"/"<<y<<")"<<endl;}}Complex operator+(Complex c); //声明运算符重载函数Complex operator-(Complex c);Complex operator*(Complex c);Complex operator/(Complex c);private:int x,y;};Complex Complex::operator+(Complex c) //定义+重载函数{Complex temp1;if(y!=c.y)temp1.y=y*c.y;temp1.x=x*c.y+c.x*y;}return temp1;}Complex Complex::operator-(Complex c) //定义-重载函数{Complex temp1;if(y!=c.y){temp1.y=y*c.y;temp1.x=x*c.y-c.x*y;}return temp1;}Complex Complex::operator*(Complex c) //定义*重载函数{Complex temp1;if(y!=c.y){temp1.y=y*c.y;temp1.x=x*c.x;}return temp1;}Complex Complex::operator/(Complex c) //定义/重载函数{Complex temp1;if(y!=c.y){temp1.y=y*c.x;temp1.x=x*c.y;}return temp1;}int main(){Complex A1(3,2),A2(5,7),A3,A4,A5,A6; //定义六个类的对象A1.print(); //输出分数A2.print();A3=A1+A2; //分数相加A3.print();A4=A1-A2; //分数相减A4.print();A5=A1*A2; //分数相乘A5.print();A6=A1/A2; //分数相除A6.print();return 0;}2.（注释同上）#include<iostream.h>//using namespace std;class Complex{public:Complex(int X=0,int Y=0){x=X;y=Y;}void gys(){int t;t=x%y;while(t!=1){x=y;y=t;t=x%y;}}void print(){int z;if((x<y)&&(y!=1)){cout<<x<<"/"<<y<<endl;}if((x>y)&&(y!=1)){z=x/y;cout<<z<<"("<<x%y<<"/"<<y<<")"<<endl;}}friend Complex operator+(Complex& a,Complex& b); friend Complex operator-(Complex& a,Complex& b); friend Complex operator*(Complex& a,Complex& b); friend Complex operator/(Complex& a,Complex& b);private:int x,y;};Complex operator+(Complex& a,Complex& b){Complex temp1;if(a.y!=b.y){temp1.y=a.y*b.y;temp1.x=a.x*b.y+b.x*a.y;}return temp1;}Complex operator-(Complex& a,Complex& b){Complex temp1;if(a.y!=b.y){temp1.y=a.y*b.y;temp1.x=a.x*b.y-b.x*a.y;}return temp1;}Complex operator*(Complex& a,Complex& b) {Complex temp1;if(a.y!=b.y){temp1.y=a.y*b.y;temp1.x=a.x*b.x;}return temp1;}Complex operator/(Complex& a,Complex& b) {Complex temp1;if(a.y!=b.y){temp1.y=a.y*b.x;temp1.x=a.x*b.y;}return temp1;}int main(){Complex A1(3,2),A2(5,7),A3,A4,A5,A6,G; A1.print();A2.print();A3=A1+A2;A3.print();A4=A1-A2;A4.print();A5=A1*A2;A5.print();A6=A1/A2;A6.print();return 0;}3.#include<iostream>using namespace std;class Set{int *elem; //存放集合元素的指针int count; //存放集合中的元素个数public:Set(){};Set(int s[],int n);int find(int x) const; //判断x是否在集合中Set operator+(const Set &a); //集合的并集Set operator-(const Set &a); //集合的差集Set operator*(const Set &a); //集合的交集void disp(); //输出集合元素};Set::Set(int s[],int n) //构造函数初始化{elem=s;count=n;}int Set::find(int x) const //判断x是否在集合中{int n;for(n=0;n<count;n++){if(x=elem[n])cout<<"x在集合中"<<endl;return 1;}return 0;}Set Set::operator +(const Set& a) //重载运算符+求两数组的并集{Set temp;int k=0,m,n,p;int *b=new int [k];for(n=0;n<a.count;n++){b[k]=a.elem[n];k++;}for(m=0;m<count;m++) //定义一个新数组，使其等于elem[],找出另一个数组中不相等的数，放进另一个数组，两个新数组连接着输出，即为他们的并集{for(n=0;n<a.count;n++){if(elem[m]==a.elem[n]){p=1;continue;}}}for(m=0;m<count;m++){if(p!=1){b[k]=elem[m];k++;}}cout<<endl;temp.count=k;temp.elem=b;return temp;}Set Set::operator -(const Set& a) //定义重载运算符-用于计算差集{Set temp;int p=0,m,n,q;int *b=new int [p];for(m=0;m<count;m++){for(n=0;n<a.count;n++) //找出两数组不相等的数，把只是属于elem的数放进新数组中，输出即为A-B{if(elem[m]==a.elem[n]){q=1;continue;}}}for(m=0;m<count;m++){if(q!=1){b[p]=elem[m];p++;}}cout<<endl;temp.count=p;temp.elem=b;return temp;}Set Set::operator *(const Set& a) //定义重载运算符*计算两数组交集{Set temp;int k=0,m,n;int *b=new int [k];for(m=0;m<count;m++) //如果两数组的值相等，把相等的值放进新数组，输出即为交集{for(n=0;n<a.count;n++){if(elem[m]==a.elem[n]){b[k]=elem[m];k++;}}}cout<<endl;temp.count=k;temp.elem=b;return temp;}void Set::disp(){for(int i=0;i<count;i++){cout<<elem[i]<<" ";}cout<<endl;}int main(){int aa[4]={1,2,3,4};int bb[5]={3,4,5,6,7};Set A,B,C,D,E;A=Set(aa,4);B=Set(bb,5);A.find(2);A.disp();B.disp();E=A*B;cout<<"两个数组的交集为："<<endl;E.disp();C=A+B;cout<<"两个数组的并集为："<<endl;C.disp();D=A-B;cout<<"两个数组的差集为："<<endl;D.disp();return 0;}4.#include<iostream.h>//using namespace std;class Complex{public:Complex(int X=0,int Y=0,int Z=0) {x=X;y=Y;z=Z;}void print(){if(z>=10){ z=z-10;y=y+1;if(y>=10){y=y-10;x=x+1;}}cout<<x<<"元"<<y<<"角"<<z<<"分"<<endl;}Complex operator+(Complex c); //声明运算符重载函数Complex operator++(); //声明自减运算符--重载成员函数（前缀）Complex operator++(int); //声明自减运算符--重载成员函数（后缀）private:int x,y,z;};Complex Complex::operator+(Complex c) //定义+重载函数{Complex temp1;temp1.x=x+c.x;temp1.y=y+c.y;temp1.z=z+c.z;return temp1;}Complex Complex::operator++() //定义++重载函数（前缀）{++x;++y;++z;return *this;}Complex Complex::operator++(int) //定义++重载函数（后缀）{Complex temp(*this);x++;y++;z++;return temp;}int main(){Complex A(7,8,9),B(4,5,6),C; //定义四个类的对象A.print(); //输出对象A的值B.print(); //输出对象B的值C=A+B; //两对象A、B相加C.print(); //输出相加后的值++A; //执行++前缀A.print(); //输出执行后的值B++; //执行++后缀B.print(); //输出执行后的值return 0;}。
运算符重载实验报告
运算符重载实验报告运算符重载实验报告引言：运算符重载是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。
实验六_运算符重载
南昌航空大学实验报告年月日课程名称：面向对象程序设计实验名称：运算符重载班级：学生姓名：学号：指导教师评定: 签名:1、实验目的·学习掌握重定义与类有关的运算符。
·把握重载运算符的时机。
·学习掌握把一个类对象转换为另一个类对象。
·学习掌握重载为成员与友元的区别及其带参数的情况。
·学习掌握值返回与引用返回的区别及应用时机。
2、实验内容(1)生成一个表示复数的类FS。
复数的实部sb和虚部xb作为其数据成员。
提供成员函数disp()显示复数（格式：-3+5i或6-2i）,重载“+”、“-”为FS类的成员函数,用来计算两个复数的和、差。
思路导航：①定义类，设计构造函数和显示函数print();②重载运算符“+”、“-”为类FS的成员函数。
③实例化FS类的2个对象,并利用重载的运算符对其进行计算。
另外，根据上述定义，试将上述的运算符重载成员函数改写成友元函数。
#include <iostream.h>class FS{double sb,xb;public:FS(double a=0,double b=0);FS &operator + (FS &);FS &operator - (FS &);void print();};FS::FS(double a,double b){sb = a;xb = b;}FS& FS::operator + (FS &b){FS p;p.sb = sb + b.sb ;p.xb = xb + b.xb ;return p;}FS& FS::operator - (FS &b){FS p;p.sb = sb - b.sb ;p.xb = xb - b.xb ;return p;}void FS::print (){if(xb > 0)cout<<sb<<"+"<<xb<<"i";elsecout<<sb<<xb<<"i";}void main(){FS a(-8,3),b(7,-4);FS c1;c1=a+b;a.print();cout<<" + ";b.print();cout<<" = ";c1.print();cout<<endl;FS c2;c2=a-b;a.print();cout<<" - ";b.print();cout<<" = ";c2.print();cout<<endl;}//-------------------------运算符重载为友元函数--------------------------- #include <iostream.h>class FS{double sb,xb;public:FS(double a=0,double b=0);friend FS operator+ (FS &,FS &);friend FS operator- (FS &,FS &);void print();};FS::FS(double a,double b){sb = a;xb = b;}FS operator+ (FS &x,FS &y){FS p;p.sb = x.sb + y.sb ;p.xb = x.xb + y.xb ;return p;}FS operator- (FS &x,FS &y){FS p;p.sb = x.sb - y.sb ;p.xb = x.xb - y.xb ;return p;}void FS::print (){if(xb > 0)cout<<sb<<"+"<<xb<<"i";elsecout<<sb<<xb<<"i";}int main(){FS a(8,3),b(7,-14);FS c1;c1=a+b;a.print();cout<<" + ";b.print();cout<<" = ";c1.print();cout<<endl;FS c2;c2=a-b;a.print();cout<<" - ";b.print();cout<<" = ";c2.print();cout<<endl;return 0;}(2)编写一个时间类，实现时间的加、减、读和输出：//class.hclass Time{public:Time(){}void SetTime();void Display();Time operator + (Time &a);Time operator - (Time &a);private:int hour,minute,second;};//function.cpp#include <iostream.h>#include "class.h"void Time::SetTime(){cout<<"小时: ";cin>>hour;cout<<"分钟: ";cin>>minute;cout<<"秒: ";cin>>second;}void Time::Display(){cout<<hour<<":"<<minute<<":"<<second<<endl;}Time Time::operator + (Time &a){Time p;p.hour = hour + a.hour ;p.minute = minute + a.minute ;p.second = second + a.second ;return p;}Time Time::operator - (Time &a){Time p;p.hour = hour - a.hour ;p.minute = minute - a.minute ;p.second = second - a.second ;return p;}//overload.cpp#include <iostream.h>#include "class.h"void main(){Time a,b,c;cout<<"请输入A的时间："<<endl;a.SetTime();cout<<"请输入B的时间："<<endl;b.SetTime();cout<<"A的时间为：";a.Display();cout<<"B的时间为：";b.Display();cout<<"c=a+b=";c=a+b;c.Display();cout<<endl<<"c=a-b=";c=a-b;c.Display();}3、实验结果。
运算符重载实验模板
高级程序设计语言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++实验21 运算符重载
实验21 运算符重载一、实验目的和要求1．理解运算符重载的作用。
2．掌握实现运算符重载的方法及几种特殊运算符的重载格式。
3．进一步锻炼针对类的编程能力。
二、实验准备☞知识点1．运算符重载定义的一般格式、基本概念。
2．运算符函数重载的两种形式。
3．通过成员函数实现运算符重载的一般格式。
4．通过友元函数实现运算符重载的一般格式。
5．”++”运算符的重载。
6．”=”赋值运算符的重载。
☞课前练习题1．重载运算”+”，实现a+b运算，则。
A．a必须为对象，b可为整数或实数B．a和b必须为对象C．b必须为对象，a可为整数或实数D．a和b均可为整数或实数2．在C++中，运算符的重载有两种实现方法，一种是通过成员函数来实现，另一种则通过_________来实现。
3．不能重载的5个运算符是：______、______、______、______、_________。
4．重载赋值运算符必须通过________函数实现。
5．用成员函数实现前置”--”运算符重载的一般格式为：_______________________________。
6．用友元函数实现后置”--”运算符重载的一般格式为：_______________________________。
☞分析1．有以下程序：#include<iostream.h>class C{private:double x;public:C( ) { x=0.0; }C(double a) { x=a; }friend C operator--(C t) //行A{t.x--;return t;}void show(){cout<<x<<endl;}};void main(){C c(5.6);(--c).show(); //行Bc.show(); //行C}请回答问题：①从行A 的形式上看，这是利用________函数实现__________运算符的重载。
运算符重载实验报告
一、实验目的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. 运算符重载的实际应用运算符重载在实际编程中具有以下优势：- 提高代码可读性：使用自定义类型时，可以像操作基本数据类型一样使用运算符，提高代码的可读性。
运算符重载实验
运算符重载的应用【实验目的】1、理解重载运算符的意义。
2、掌握用成员函数、友元函数重载运算符的特点。
3、掌握重载运算符函数的调用方法。
【实验内容】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复数类及运算符重载函数可定义为：2.根据下面描述定义完整的日期类:class Date{//成员变量void IneDay();//日期增加1天int DayCalc()const;//距基准日期的天数static const int day[];//每月的天数public:Date(int y,int m,int d);Date(int m, int d);Date();void SystmDate();//读取系统当前时间void SetDate(int yy,int mm,int dd);//设置日期void SetDate(int mm,int dd);bool IsLeapYear(int yy) const;//是否闰年bool IsEndofMonth()const ；//是否月末//重载cout<<,cout>>完成读入和输出日期工作//重载+，+=，-，-=，++，--，等运算符，完成日期的运算符操作。
//成员函数：判读一个日期是否是系统的当前日期//实现从键盘读入你的生日，如果是则显示：生日快乐，否则先生还有多少天到生日，或你的生日已经过了多少天，明年生日要再等多少天。
选作，实现：在文件中读入事先写入的亲朋好友的纪念日，系统到时自动提醒。
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．掌握几种常用的运算符重载的方法。
二、实验内容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。
运算符重载实验
实验7 运算符重载（*）一、实验目的掌握C++中运算符重载的机制和运算符重载的方式；二、实验内容及步骤1.编写一个简单复数类Scomplex，要求用友元函数重载“+”、“-”运算符，用成员函数重载“=”运算符，使之能够实现整数或浮点数和复数的加法和减法，并且进行测试。
、#include<iostream>#include<cmath>#include<iomanip>#include<cstdlib>using namespace std;class Scomplex{private:float real;float image;public:Scomplex(){real = 0; image = 0;}Scomplex(float r, float i){real = r; image = i;}void Show(){cout << fixed << setprecision(2) << "(" << real << ", " << image << ")" << endl;}friend Scomplex operator + (Scomplex comp, int iNum);friend Scomplex operator - (Scomplex comp, int iNum);friend Scomplex operator + (Scomplex comp, float fNum);friend Scomplex operator - (Scomplex comp, float fNum);Scomplex operator = (Scomplex num);};Scomplex Scomplex::operator = (Scomplex num){this->real = num.real;this->image = num.image;return *this;}Scomplex operator + (Scomplex comp, int iNum) {comp.real = comp.real + (float)iNum;return comp;}Scomplex operator + (int iNum, Scomplex comp) {comp = comp + iNum;return comp;}Scomplex operator - (Scomplex comp, int iNum) {comp.real = comp.real - (float)iNum;return comp;}Scomplex operator - (int iNum, Scomplex comp) {comp = comp - iNum;return comp;}Scomplex operator + (Scomplex comp, float fNum) {comp.real = comp.real + fNum;return comp;}Scomplex operator + (float fNum, Scomplex comp) {//comp.real = comp.real + fNum;comp = comp + fNum;return comp;}Scomplex operator - (Scomplex comp, float fNum) {comp.real = comp.real - fNum;return comp;}Scomplex operator - (float fNum, Scomplex comp){comp = comp - fNum;return comp;}int main(void){int iData = 10;float fData = 66.6;Scomplex comp(23.5, 86.5);Scomplex IntAdd, IntSub, FloatAdd, FloatSub, AssigNum;IntAdd = iData + comp;IntSub = iData - comp;FloatAdd = fData + comp;FloatSub = fData - comp;AssigNum = comp;cout << "整数加上复数： ";IntAdd.Show();cout << "整数减上复数： ";IntSub.Show();cout << "浮点数加上复数： ";FloatAdd.Show();cout << "浮点数减上复数： ";FloatSub.Show();cout << "重载赋值运算符后： ";AssigNum.Show();system("PAUSE");return 0;2.空间一点p的坐标为（x,y,z）,其中x,y,z为整数。
实验7 运算符重载设计
分析：运算符重载的方法是定义一个重载运算符的函数，使指定的运算符不仅能实现原有的功能，而且能实现在函数中指定的新功能。（运算符重载实质是函数的重载）
10.3、
分析：本例中我们首次运用了友元函数对运算符重载的函数进行处理，友元函数：（运算符的函数不是类的成员函数《可以使一个普通函数》我们把它声明为友元函数） ;除此对运算符重载的函数还有一种方式是把运算符重载的函数作为类的成员函数。
{
friend ostream& operator<<(ostream& out,Matrix& M); //重载<<运算符
friend istream& operator>>(istream& in,Matrix& M); //重载>>运算符
public:
Matrix(int r,int c);
Matrix operator+(Matrix &M);
k++;
}
return tempM;
}
void main()
{
Matrix A(3,3);
Matrix B(3,3);
Matrix C(3,3);
cout<<"输入第一个矩阵的"<<A.GetCounts()<<"个数:"<<endl;
cin>>A;
cout<<"输入第二个矩阵的"<<B.GetCounts()<<"个数:"<<endl;
}
运算符重载—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的值为:";
实验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:
实验九 运算符重载1
实验九运算符重载（一）1、实验目的理解运算符重载的概念和实质，掌握运算符重载函数的定义方法，掌握将运算符重载为类的成员函数和友元函数的方法，掌握和运用几种常用的用C++语言运算符的重载进行解决问题的方法。
2、实验内容(1) 编写程序，运用运算符重载实现点类Point的两个对象(即两点)间横、纵坐标的相加运算。
// 1234.cpp : 定义控制台应用程序的入口点。
//#include"stdafx.h"#include<iostream>using namespace std;class point{public:point(){x=0;y=0;}point(int x1,int y1){x=x1;y=y1;}point operator + (point &p2);void display();private:int x;int y;};point point ::operator + (point &p2){point p;p.x=x+p2.x;p.y=y+p2.y;return p;}void point::display(){cout<<"("<<x<<","<<y<<")"<<endl;}int main(){point p1(3,4),p2(5,-10),p3;p3=p1+p2;cout<<"p1=";p1.display();cout<<"p2=";p2.display();cout<<"p1+p2=";p3.display();return 0;}(2) 设计一个复数类Complex，重载运算符“*”，“/”，使之能用于复数的乘除。
运算符重载实验报告
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日
实验二运算符重载
实验二运算符重载班级电科2班学号Xb11640218 姓名张俊为1.实验目的：（1）学习定义和使用重载运算符。
（2）熟悉拷贝构造函数。
2.实验任务：(1)对比通过函数来实现复数相加和通过重载运算符实现复数相加的不同之处(2)定义RMB类，数据成员有yuan、jf，请为该类定义构造函数、并重载“+”、“-”、“<<”、“>>”。
选做：定义账户类，有账号、户名、余额等属性，具有存款、取款等操作，可以把RMB类对象作为成员，进行存取款操作。
(3)以下程序实际要输出0～9之间每个数的平方，请用增加拷贝构造函数的方法避免存在的问题。
#include <iostream.h>#include <stdlib.h> class Vector{public:Vector(int s=100); void Display();void Set();~Vector(); protected:int size;int* buffer;};Vector::Vector(int s) {buffer=new int[size=s]; for(int i=0; i<size; i++)buffer[i]=i*i;} void Vector::Display(){for(int j=0; j<size; j++)cout <<buffer[j] <<endl;}void Vector::Set(){for(int j=0; j<size; j++)buffer[j]=j+1;}Vector::~Vector(){ delete[]buffer; }void main(){Vector a(10);Vector b(a);a.Set();b.Display();}3.设计思路：（1）通过函数来实现复数相加时是在Complex类外定义一个Complex类的成员函数Complex_add。
2.运算符重载
实验十三运算符重载实验名称：运算符重载学时安排：2实验类别：设计性实验实验要求：1人1组一、实验目的和任务熟练掌握运算符重载的设计方法二、实验原理介绍设计性实验。
根据要求正确定义、实现运算符重载函数。
三、实验设备介绍软件需求: Visual C++ 6.0或VS2008硬件需求: 对于硬件方面的要求，建议配置是Pentium III 450以上的CPU处理器，64MB 以上的内存，200MB的自由硬盘空间、CD-ROM驱动器、能支持24位真彩色的显示卡、彩色显示器、打印机。
四、实验内容和步骤1.实验要求：重载Timer类的+、-、>、==、<运算符，并实现验证代码。
1）+运算符要求实现：两个时间相加：如4:20:30 + 8:10:40 （结果为12:40:10）某个时间加上一定的分钟数：如4:20:30 + 40（分钟）（结果为5:00:30）2）-运算符要求实现：求两个时间相减：如8:10:40 - 4:20:30 （结果为3:50:10）注：结果可为负数。
3）>、= =、< 运算符要求实现比较两个时间的大小关系。
如8:10:40 > 4:20:30 （结果为真）【选做】以下功能可选做，函数请自行定义，可参考书上关于complex类++，--运算符的实现。
1）重载--运算符实现原时间减去1秒，如 t1--;2）要求调用--运算符实现倒计时功能。
如倒计时00:05:00，逐次减1s直到00:00:00提示时间到。
2.文件Timer.h参考class Timer{private:int hour;int minute;int second;public:Timer(int h, int m, int s);void ShowTime();Timer operator+ (const Timer &obj);Timer operator + (int minutes);Timer operator - (const Timer &obj);bool operator > (const Timer &obj);bool operator < (const Timer &obj);bool operator ==(const Timer &obj); };。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
运算符重载的应用
【实验目的】
1、理解重载运算符的意义。
2、掌握用成员函数、友元函数重载运算符的特点。
3、掌握重载运算符函数的调用方法。
【实验内容】
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
复数类及运算符重载函数可定义为：
2.根据下面描述定义完整的日期类:
class Date{
//成员变量
void IneDay();//日期增加1天
int DayCalc()const;//距基准日期的天数
static const int day[];//每月的天数
public:
Date(int y,int m,int d);
Date(int m, int d);
Date();
void SystmDate();//读取系统当前时间
void SetDate(int yy,int mm,int dd);//设置日期
void SetDate(int mm,int dd);
bool IsLeapYear(int yy) const;//是否闰年
bool IsEndofMonth()const ；//是否月末
//重载cout<<,cout>>完成读入和输出日期工作
//重载+，+=，-，-=，++，--，等运算符，完成日期的运算符操作。
//成员函数：判读一个日期是否是系统的当前日期
//实现从键盘读入你的生日，如果是则显示：生日快乐，否则先生还有多少天到生日，或你的生日已经过了多少天，明年生日要再等多少天。
选作，实现：在文件中读入事先写入的亲朋好友的纪念日，系统到时自动提醒。
本题提示：
读取系统时间：
#include <iostream>
#include <ctime>
using namespace std;
tm *gm;
time_t t=time(NULL);
gm=gmtime(&t);
int year=1900+gm->tm_year;
int month=gm->tm_mon+1;
int day=gm->tm_mday;
3.定义一个向量（一维数组）类，通过重载运算符实现向量之间的加法和减法。
加法用成员函数重载，减法用友元函数重载。
⑴说明
向量用两个量来描述，一个是指向向量的指针，另一个指明向量的元素个数。
只有同元素个数的向量才能实现加法和减法。
把加法、减法定义为相应元素相加或相减。
向量类可定义为：
class Vect{
float *p;
int n;
......
};
⑵要求
增加构造函数、成员函数等，构成完整的程序，并对程序的正确性进行测试。
4为数组类重载下标运算符“[]”、“+”加运算符和“=”赋值运算符。
并编写测试程序。
5 定义一个有理数类,重载比较运算符.写一个完整的程序,进行数据成员的设置和输出.
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;
//这里增加赋值和读出函数
}
6 完成一个类，用来描述时间段，包括小时和分钟，重载各种运算符，完成时间段的加减以及赋值。
7 实数矩阵类
按已给出的函数原型为Matrix类重载+,-,* 运算符,以完成正确的矩阵加法,减法,乘法计算,并编写main()函数,用给定的数据进行测试.
#include
class Matrix
{
double *ptr;
int row,col;
public: Array
Matrix(int r,int c)
{
row=r;
col=c;
ptr=new double[row*col];
}
double operator()(int i, int j)
{
return ptr[i*col+j];
}
void set(int i, int j, double value) {
ptr[i*col+j]=value;
}
void print()
{
for(int i=0;i {
for(int j=0;j cout<<(*this)(i,j)<<" "; cout< }
}
Matrix operator+(Matrix m); Matrix operator-(Matrix m); Matrix operator*(Matrix m);
};
测试数据:
矩阵 a 3 3 3
9 -7 4
矩阵 b 11 -2 -3
1 5 1
矩阵 c 1 2
3 4
5 6
求矩阵d = a+b, e = a-b, f= a*c.。