实验5-运算符重载、继承 ( 1 )
C++程序设计运算符重载实验报告
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) //重载流插入运算符
运算符重载和类模板实验报告
洛阳理工学院实验报告
系别
计算机与信息工程系
班级
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中存在的元素的操作。
运算符重载 继承
运算符重载继承运算符重载是面向对象编程中的一个重要概念,它允许我们对已有的运算符进行重新定义,使其可以用于自定义类型的对象。
继承则是面向对象编程中的另一个重要概念,它允许我们创建一个新的类,该类可以继承已有类的属性和方法。
在面向对象编程中,运算符重载和继承是两个不同的概念,但它们通常会一起使用,以提供更灵活和强大的功能。
让我们来了解一下运算符重载。
在面向对象编程中,运算符重载允许我们对已有的运算符进行重新定义,以适应自定义类型的对象。
例如,我们可以对两个自定义对象进行相加操作,或者对自定义对象进行比较操作。
这样,我们就可以使用常用的运算符来操作自定义类型的对象,使代码更加简洁和易读。
继承则是面向对象编程中的另一个重要概念。
通过继承,我们可以创建一个新的类,该类可以继承已有类的属性和方法。
这样,我们就可以重用已有类的代码,并且可以在新的类中添加或修改一些功能,以满足特定的需求。
继承使代码更加模块化和可维护,同时也提高了代码的复用性。
继承和运算符重载的结合使用可以为我们提供更强大和灵活的编程能力。
通过继承已有类的属性和方法,我们可以在新的类中重新定义运算符,以适应自己的需求。
这样,我们就可以使用常用的运算符来操作自定义类型的对象,使代码更加简洁和易读。
同时,我们还可以在新的类中添加或修改一些功能,以满足特定的需求。
总结一下,运算符重载和继承是面向对象编程中的两个重要概念。
运算符重载允许我们对已有的运算符进行重新定义,以适应自定义类型的对象。
继承则允许我们创建一个新的类,该类可以继承已有类的属性和方法。
通过继承和运算符重载的结合使用,我们可以提供更强大和灵活的编程能力,使代码更加简洁和易读。
运算符重载实验报告
一、实验目的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二维数组存放各月天数,第一行对应非闰年,第二行对应闰年。
实验五 运算符重载
实验六运算符重载(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。
运算符重载
运算符重载为类的友元函数
类中的声明: 类中的声明: friend 函数类型 operator 运算符(参数表); 运算符(参数表); 运算符重载函数的定义形式: 运算符重载函数的定义形式: 运算符(参数表) 函数类型 operator 运算符(参数表) { 函数体; 函数体; } 附加例) (附加例)用友元函数实现复数的加法运算符的重 载。
数据类型转换 标准数据类型转换
隐式转换: 自动转成double型) 隐式转换:7.5+2 (将2自动转成 将 自动转成 型 显式转换: 转成整型) 显式转换:int(89.5) (将89.5转成整型 将 转成型
涉及到类类型的转换
对于用户自己声明的类型, 对于用户自己声明的类型,编译系统并不知道怎样进行转 换。解决这个问题的关键是让编译系统知道怎样去进行转 换,需要定义专门的处理函数。 需要定义专门的处理函数。 将一个其他类型的数据转换成一个类类型: 将一个其他类型的数据转换成一个类类型:转换构造函数 将一个类的对象转换成另一类型的数据: 将一个类的对象转换成另一类型的数据:类型转换函数
运算符重载的格式
运算符重载为类的成员函数 运算符重载为类的友元函数
运算符重载的规则
①
② ③ ④ ⑤
.”、 *” ::”、 ?:”和 sizeof”等几个运 除“. 、“*”、“:: 、“?: 和“sizeof 等几个运 算符不能重载外, 算符不能重载外,C++中几乎所有的运算符都可以 中几乎所有的运算符都可以 重载。 重载。 运算符被重载后,其优先级和结合性不会改变。 运算符被重载后,其优先级和结合性不会改变。 不能改变运算符操作对象的个数。 不能改变运算符操作对象的个数。 运算符的意义应不变。 运算符的意义应不变。 用于类对象的运算符一般必须重载,但有两个例外, 用于类对象的运算符一般必须重载,但有两个例外, 运算符“ 和 不必用户重载。 运算符“=”和“&”不必用户重载。 不必用户重载
五、运算符重载_面向对象程序设计
面向对象程序设计
2-16
友元运算符函数
单目运算符
对于要改变操作数的运算符(++、--),参数 必须是引用或指针 不改变操作数的运算符(-),可以不用
双目运算符
有两个操作数,因此参数也应该设两个
以友元重载运算符,进行复数类运算fcomplex.cpp
面向对象程序设计
2-16
成员运算符函数
类内声明形式
面向对象程序设计
2-16
友元运算符函数
类内声明
friend 返回类型 operator 运算符(参数表)
类外定义形式
返回类型 operator 运算符(参数表) {……} 类外函数,不属于任何类对象,没有this指针 重载双目运算符,参数表需两个参数 重载单目运算符,参数表需一个参数 不能用友元重载的运算符:= ()[ ] ->
Type指返回类型,@为++或--运算符 参数int只是为了区分前置或后置,通常被传递为0
面向对象程序设计
2-16
特殊运算符重载
++和--
class CPoint { int x,y; public: CPoint(int a=0,int b=0){x=a; y=b;} CPoint operator ++(); CPoint operator ++(int); friend CPoint operator --(CPoint &); friend CPoint operator --(CPoint &, int); void print() {cout<<"x,y:"<<x<<" "<<y<<endl;} };
运算符重载——精选推荐
运算符重载运算符重载学习运算符重载,让运算符能做⼀些原来做不了的事情,⽅便它的使⽤⼀、运算符重载的概念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:
运算符重载-- 实验报告
南昌航空大学实验报告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;}五、程序调试经调试无误后,运行的结果为:六、实验总结通过这次的试验,我明显的感觉到自己对这方面的知识掌握的还不够熟练,不能顺利地、流畅地运用这方面的知识,因为我没有在规定的时间内完成程序的设计,课后还是要多复习。
运算符重载实验报告
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日
运算符重载详解
运算符重载详解1.运算符重载定义:C++中预定义的运算符的操作对象只能是基本数据类型。
但实际上,对于许多⽤户⾃定义类型(例如类),也需要类似的运算操作。
这时就必须在C++中重新定义这些运算符,赋予已有运算符新的功能,使它能够⽤于特定类型执⾏特定的操作。
运算符重载的实质是函数重载,它提供了C++的可扩展性,也是C++最吸引⼈的特性之⼀。
运算符重载是通过创建运算符函数实现的,运算符函数定义了重载的运算符将要进⾏的操作。
运算符函数的定义与其他函数的定义类似,惟⼀的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。
运算符函数定义的⼀般格式如下:<返回类型说明符> operator <运算符符号>(<参数表>){<函数体>} 2.运算符重载时要遵循以下规则:(1) 除了类属关系运算符"."、成员指针运算符".*"、作⽤域运算符"::"、sizeof运算符和三⽬运算符"?:"以外,C++中的所有运算符都可以重载。
(2) 重载运算符限制在C++语⾔中已有的运算符范围内的允许重载的运算符之中,不能创建新的运算符。
(3) 运算符重载实质上是函数重载,因此编译程序对运算符重载的选择,遵循函数重载的选择原则。
(4) 重载之后的运算符不能改变运算符的优先级和结合性,也不能改变运算符操作数的个数及语法结构。
(5) 运算符重载不能改变该运算符⽤于内部类型对象的含义。
它只能和⽤户⾃定义类型的对象⼀起使⽤,或者⽤于⽤户⾃定义类型的对象和内部类型的对象混合使⽤时。
(6) 运算符重载是针对新类型数据的实际需要对原有运算符进⾏的适当的改造,重载的功能应当与原有功能相类似,避免没有⽬的地使⽤重载运算符。
(7)重载运算符的函数不能有默认的参数,否则就改变了运算符的参数个数,与前⾯第3点相⽭盾了;(8)重载的运算符只能是⽤户⾃定义类型,否则就不是重载⽽是改变了现有的C++标准数据类型的运算符的规则了,会引会天下⼤乱的;(9)⽤户⾃定义类的运算符⼀般都必须重载后⽅可使⽤,但两个例外,运算符“=”和“&”不必⽤户重载;(10)运算符重载可以通过成员函数的形式,也可是通过友元函数,⾮成员⾮友元的普通函数。
运算符重载与继承
1) 写一个MyString 类,使得下面程序的输出结果是:1. abcd-efgh-abcd-2. abcd-3.4. abcd-efgh-5. efgh-6. c7. abcd-8. ijAl-9. ijAl-mnop10. qrst-abcd-11. abcd-qrst-abcd- uvw xyzaboutbigmetakeabcdqrst-abcd-程序:#include <string.h>#include <stdlib.h>#include <string>#include <iostream>using namespace std;int CompareString( const void * e1, const void * e2) {MyString * s1 = (MyString * ) e1;MyString * s2 = (MyString * ) e2;if( * s1 < *s2 )return -1;else if( *s1 == *s2)return 0;else if( *s1 > *s2 )return 1;}main(){MyString s1("abcd-"),s2,s3("efgh-"),s4(s1);MyString SArray[4] = {"big","me","about","take"}; cout << "1. " << s1 << s2 << s3<< s4<< endl;s4 = s3;s3 = s1 + s3;cout << "2. " << s1 << endl;cout << "3. " << s2 << endl;cout << "4. " << s3 << endl;cout << "5. " << s4 << endl;cout << "6. " << s1[2] << endl;s2 = s1;s1 = "ijkl-";s1[2] = 'A' ;cout << "7. " << s2 << endl;cout << "8. " << s1 << endl;s1 += "mnop";cout << "9. " << s1 << endl;s4 = "qrst-" + s2;cout << "10. " << s4 << endl;s1 = s2 + s4 + " uvw " + "xyz";cout << "11. " << s1 << endl;qsort(SArray,4,sizeof(MyString),CompareString);for( int i = 0;i < 4;i ++ )cout << SArray[i] << endl;//输出s1的下标为0的字符开始长度为4的子串cout << s1(0,4) << endl;//输出s1的下标为5的字符开始长度为10的子串cout << s1(5,10) << endl;}不允许使用C++的string类,完全自己实现 交上去的程序文件名为 mystring1.cpp提示:如果将程序中所有 "MyString" 用 "string" 替换,那么除了最后两条红色的语句编译无法通过外,其他语句都没有问题,而且输出和前面给的结果吻合。
C++运算符重载继承
class 派生类名:继承方式 基类名 { 派生类新定义成员; };
单继承的定义格式如下:
其中,“派生类名”是新定义的一个类的名字, 它是从“基类名”中派生的,并且按指定的“继承方式” 派生。继承方式有Public、Private和Protected3种。
以下语句先定义了基类A的对象指针p和派生类B的 对象b,并通过p指向b:
A *p; B b; p=&b
派生类对象可以由基类指针所指向,这是从派生类 到基类的映射,在类层次图中是上升的,所以称之为 向上映射。
派生类指针强制指向基类对象
直接用派生类指针指向基类的对象,这种方式会导致语法错误。 但可以将派生类指针强制转换为基类指针,然后就可以调用基类的 成员了。这种强制转换使用静态转型运算符,其使用格式如下:
派生类对象 作为基类对 象处理
基类指针指向派 生类对象
派生类对象作为基类对象处理
由于派生类具有所有基类的成员,所以把派生类的对象赋给 基类对象是合理的,不过要求这种继承方式必须是public方式。 但是,反过来赋值会使基类中不具有派生类的成员(因为派生类 的成员通常比基类的成员多),所以这是不允许的。
(1)作为类的构造机制,继承通过扩充、组合现有 的类来构造新的类。扩充是指形成现有类的特例—— 派生类;组合是指抽取出若干现有类的共性形成新的 抽象层次——基类。 (2)作为类型的构造机制。如果类B继承类A,则所 有要求对象A类型的地方也可以接受B类型的对象。
继承反映了事物之间的联系、事物的共性 与个性之间的关系。
私有继承
protected private
派生类继承成员的调整
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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
[思考问题]
①各个运算符重载函数能不能用成员函数来实现?为什么?。