实验5-运算符重载、继承 ( 1 )

合集下载

C++程序设计运算符重载实验报告

C++程序设计运算符重载实验报告
cout<<"\n";
cout<<"比较c8<c7?";
cout<< (c8<c7?"ture":"false");
system("pause");
}
三、测试数据和执行结果(在给定数据下,执行操作、算法和程序的结果,可使用数据、图表、截图等给出)
程序运行如图:
四、实验结果分析及总结(对实验的结果是否达到预期进行分析,总结实验的收获和存在的问题等)
Ps:同时注意复数的显示。
程序设计如下:(基于vs2010运行)
// redown.cpp : 定义控制台应用程序的入口点。
#include"stdafx.h"
#include<iostream>
usingnamespacestd;
classComplex {
private:
doubler, i;
public:
Complex (doubleR=0,doubleI=0):r(R), i(I){ };
Complexoperator+(Complex b);//L1复数加法
Complexoperator-(Complex b);//L2复数减法
friendComplexoperator*(Complex a,Complex b);//L3复数乘法
一、实验目的和要求
(1)掌握通过运算符重载实现多态性的方法;
(2)学会运算符重载的成员函数法和友元函数法;
(3)能区分单目运算符的前置与后置。
二、实验内容与设计(主要内容,操作步骤、算法描述或程序代码)

运算符重载实验报告

运算符重载实验报告

运算符重载实验报告运算符重载实验报告引言:运算符重载是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) //重载流插入运算符

运算符重载和类模板实验报告

运算符重载和类模板实验报告
1每一个类模板的成员函数的外部定义都与一般函数模板的定义一样必须以类型形参开始此外还应加以函数返回值类型类范围函数名形参序列类名后面必须加上类型形参
洛阳理工学院实验报告
系别
计算机与信息工程系
班级
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 运算符重载的应用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  运算符重载

实验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中存在的元素的操作。

运算符重载 继承

运算符重载 继承

运算符重载继承运算符重载是面向对象编程中的一个重要概念,它允许我们对已有的运算符进行重新定义,使其可以用于自定义类型的对象。

继承则是面向对象编程中的另一个重要概念,它允许我们创建一个新的类,该类可以继承已有类的属性和方法。

在面向对象编程中,运算符重载和继承是两个不同的概念,但它们通常会一起使用,以提供更灵活和强大的功能。

让我们来了解一下运算符重载。

在面向对象编程中,运算符重载允许我们对已有的运算符进行重新定义,以适应自定义类型的对象。

例如,我们可以对两个自定义对象进行相加操作,或者对自定义对象进行比较操作。

这样,我们就可以使用常用的运算符来操作自定义类型的对象,使代码更加简洁和易读。

继承则是面向对象编程中的另一个重要概念。

通过继承,我们可以创建一个新的类,该类可以继承已有类的属性和方法。

这样,我们就可以重用已有类的代码,并且可以在新的类中添加或修改一些功能,以满足特定的需求。

继承使代码更加模块化和可维护,同时也提高了代码的复用性。

继承和运算符重载的结合使用可以为我们提供更强大和灵活的编程能力。

通过继承已有类的属性和方法,我们可以在新的类中重新定义运算符,以适应自己的需求。

这样,我们就可以使用常用的运算符来操作自定义类型的对象,使代码更加简洁和易读。

同时,我们还可以在新的类中添加或修改一些功能,以满足特定的需求。

总结一下,运算符重载和继承是面向对象编程中的两个重要概念。

运算符重载允许我们对已有的运算符进行重新定义,以适应自定义类型的对象。

继承则允许我们创建一个新的类,该类可以继承已有类的属性和方法。

通过继承和运算符重载的结合使用,我们可以提供更强大和灵活的编程能力,使代码更加简洁和易读。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验五运算符重载、继承
●实验目的
1、了解类的两种使用方式。

2、学习从现有类派生出新类的方式。

3、了解在派生类中如何使用基类的成员。

4、了解基类成员在派生类中的访问控制。

5、掌握运算符重载的方法。

●实验内容
1、从类Person中派生出一个教师类,新增的属性有专业(Specialty)、职称(Position)和主讲课程(MajorCourse,一门),并为这些属性定义相应的方法。

[实现要求]
Person类的设计如下,请将空白处补充完整。

class Person
{
string Name;
int Age;
string Sex;
public:
void Register(char *name,int age,char *sex)
{
;
Age=age;
Sex=sex;
}
string GetName() { }
string GetSex() { return Sex; }
int GetAge() { }
void ShowMe()
{
cout<<GetName()<<"\t"<<GetSex()<<"\t"<<GetAge()<<"\t";
}
};
教师类由Person类共有派生出来,主函数设计如下:
int main()
{
Teacher t;
t.ShowMe(); //创建Teacher类对象t后直接显示各成员的值,在Teacher类中应有不
//带参数的构造函数去初始化各个成员的值,使其显示运行结果的第一行t.TeacherRegister("张三",40, "f","计算机","副教授","C++");
t.ShowMe();
return 0;
}
运行结果如下:
XXX m 0 XXX XXX XXX
张三 f 40 计算机副教授C++
[思考问题]
①在Teacher类中是否要需要重新定义ShowMe成员函数?不重新定义ShowMe成员函数能否得到上述要求的运行结果?为什么?
2、从Point类中派生出一个Line类。

Line类增加一个数据成员EndPoint,计算线的长度。

[实现提示]
Point类可以按下面方式进行设计:
class Point{
int x,y;
public:
Point(int a=0,int b=0){SetPoint(a,b);}
void SetPoint(int a,int b); //设置点的坐标值
int GetX(){return x;}
int GetY(){return y;}
void Print(); //显示点的坐标值
};
Line类增加一个数据成员EndPoint为Point类对象,注意在设计Line类的构造函数时应为其基类和对象成员EndPoint提供形参。

为了检验Line类的功能,主函数按如下方式设计:
int main(){
Line line(1,1,10,10);
cout<<"Line line:";
line.Print();
cout<<"\n线line的长度:";
cout<<line.Length()<<endl;
return 0;
}
运行结果如下:
Line line:开始点:[1,1];结束点:[10,10]
线line的长度:12.7279
3、对实验4中的第3题设计的Time类进行修改,通过重载“+”、“-”运算符直接进行时间的加减运算。

[实现要求]
(1)用友元函数来实现运算符的重载
(2)加法运算符可以是两个Time对象进行相加,也可以是一个表示秒数的int型数据加
上一个Time对象,可以是Time对象加上int型数据,得到的结果都是Time类型的对象。

(3)减法运算符可以是两个Time对象进行相减,也可以是Time对象减去一个表示秒数
的int型数据,得到的结果都是Time类型的对象。

按照以上要求,主函数设计如下:
void main()
{
Time t1(2,34),t2,t3;
t2.SetTime(13,23,34);
cout<<"\nt1+t2:";
t3=t1+t2; //两个Time类对象相加
t3.print_24();
cout<<"\nt1+65:";
t3=t1+65; //Time类对象加上65秒
t3.print_24();
cout<<"\n65+t1:";
t3=65+t1; //65秒加上Time类对象
t3.print_24();
cout<<"\nt1-t2:";
t3=t1-t2; //两个Time类对象相减
t3.print_24();
cout<<"\nt1-70:";
t3=t1-70; //Time类对象减去70秒
t3.print_24();
}
运行结果如下:
t1+t2:15:57:34
t1+65:02:35:05
65+t1:02:35:05
t1-t2:10:49:34
t1-70:02:32:50
[思考问题]
①各个运算符重载函数能不能用成员函数来实现?为什么?。

相关文档
最新文档