实验十_运算符重载
C++基础系列——运算符重载
![C++基础系列——运算符重载](https://img.taocdn.com/s3/m/a8334a9b6429647d27284b73f242336c1eb9301b.png)
C++基础系列——运算符重载1. 运算符重载简介所谓重载,就是赋予新的含义。
函数重载(Function Overloading)可以让⼀个函数名有多种功能,在不同情况下进⾏不同的操作。
同样运算符重载(Operator Overloading)可以让同⼀个运算符可以有不同的功能。
可以对 int、float、string 等不同类型数据进⾏操作<< 既是位移运算符,⼜可以配合 cout 向控制台输出数据也可以⾃定义运算符重载:class Complex{public:Complex();Complex(double real, double imag);Complex operator+(const Complex &a) const;void display() const;private:double m_real;double m_imag;};// ...// 实现运算符重载Complex Complex::operator+(const Complex &A) const{Complex B;B.m_real = this->m_real + A.m_real;B.m_imag = this -> m_imag + A.m_imag;return B;// return Complex(this->m_real + A.m_real, this->m_imag + A.m_imag);}int main(){Complex c1(4.3, 5.8);Complex c2(2.7, 3.7);Complex c3;c3 = c1 + c2; // 运算符重载c3.display();return 0;}运算结果7 + 9.5i运算符重载其实就是定义⼀个函数,在函数体内实现想要的功能,当⽤到该运算符时,编译器会⾃动调⽤这个函数,它本质上是函数重载。
运算符重载实验报告
![运算符重载实验报告](https://img.taocdn.com/s3/m/b60b9d9ad05abe23482fb4daa58da0116c171f9c.png)
运算符重载实验报告运算符重载实验报告引言:运算符重载是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。
姜志达实验十报告
![姜志达实验十报告](https://img.taocdn.com/s3/m/3108ab2743323968001c9211.png)
实验十实验报告——姜志达1.实验目的(1)掌握运算符重载的定义及实现。
(2)掌握具有运算符重载的应用。
2.实验设备硬件环境:微型计算机软件环境:操作系统:Windows语言环境:Visual C++3.预习要求学习教材有关运算符重载的内容,对基本运算符重载及特殊运算符重载有充分的理解。
对实验基本要求应在上机实验前仔细阅读,程序应事先编制完成,上机时录入调试,同时还应设计相应的测试用例集,检查程序的正确性、可靠性、完备性和容错能力。
4.实验内容(1)将一个16位二进制数表示成0和1的字符序列,即用一个字符数组来存放这个二进制数。
在这个类中设置两个构造函数,一个是传递整数参数的,另一个是传递字符串参数的。
因为用户在创建对象时传递的二进制数,可能是以整数形式给出,也可能是以数字串形式给出,系统应该都能接受。
另外有一个类型转换函数int(),用来将类类型向整型转换。
程序中的两个重载运算符“+”,“-”,用来完成两个二进制数之间的加减运算。
#include "iostream.h"#include "string.h"#include "conio.h"class binary { //定义二进制类char bits[16]; //二进制字模数组public:binary(char *); //字符串参数构造函数binary(int); //整型参数构造函数friend binary operator +(binary,binary); //重载“+”friend binary operator -(binary,binary); //重载“-”operator int(); //类类型转换函数void print();};binary::binary(char *num){int isrc=strlen(num)-1; //字符串长度-1为最低位int idest=15;while(isrc>=0 && idest>=0)bits[idest--]=(num[isrc--]=='0'?'0':'1'); // 逐位赋值 while(idest>=0) bits[idest--]='0'; // 空高位值0 }binary::binary(int num){for(int i=15; i>=0;i--){ bits[i]=( (1) ); //求余数num>>=1; //移位,相当于整除2}}binary operator +(binary n1, binary n2){unsigned carry=0;unsigned value;binary res="0";for(int i=15; i>=0; i--){value=(n1.bits[i]=='0'?0:1)+( (2) )+carry;res.bits[i]=(value%2==0?'0':'1');carry=value>>1;}return res;}binary operator -(binary n1, binary n2){unsigned borrow=0;int value;binary res="0";for(int i=15; i>=0; i--){value=(n1.bits[i]=='0'?0:1)-(n2.bits[i]=='0'?0:1)+borrow; res.bits[i]=(value==-1||value==1?'1':'0');borrow=(value==-1||borrow!=0&&(value==0||value==1)?1:0); }return res;}binary::operator int(){unsigned value=0;for(int i=0; i<=15; i++)value=( (3) )+(bits[i]=='0'?0:1);return value;}void binary::print(){char str[17];strncpy(str,bits,16);str[16]='\0';cout<<str<<"\n";}main(){binary n1="1011";binary n2=int(n1)+15;binary n3=n1-binary(7);n1.print();n2.print();n3.print();cout<<int(n2)+5<<endl;cout<<n2-binary(5)<<endl;cout<<n3+binary(5)<<endl;cout<<int(n3)-5<<endl;getch();return 1;}[基本要求]●阅读下列程序,根据题意要求在处填上合适的内容完成程序。
c++运算符重载实验心得
![c++运算符重载实验心得](https://img.taocdn.com/s3/m/69f01945f342336c1eb91a37f111f18582d00c5f.png)
c++运算符重载实验心得
C++运算符重载是一项功能强大的特性,它允许程序员通过自定义运算符的行为来简化和优化代码。
在我的实验中,我学习了如何创建和重载不同类型的运算符,以及如何在自定义类中使用它们。
在C++中,我们可以使用运算符重载来定义自己的类和数据类型的操作。
例如,我们可以重载加号运算符来实现两个自定义类的相加操作。
这使得代码更易于阅读和理解,并且可以减少代码的复杂性。
在我的实验中,我学习了如何重载算术运算符,比如加、减、乘和除。
我还学习了如何重载比较运算符,如小于、大于和等于运算符。
这些重载的运算符允许我直接使用自定义类的对象进行运算而不需要编
写复杂的代码。
此外,我还学习了如何重载输入和输出运算符,使得输入和输出数据变得更加简单和直观。
这使得程序员可以更加轻松地向用户展示数据或者从用户那里获取数据。
总之,C++运算符重载是一项强大的特性,它可以极大地简化和优化代码。
通过学习和掌握这项特性,程序员可以更加轻松地创建和使用自定义类和数据类型。
运算符重载和类模板实验报告
![运算符重载和类模板实验报告](https://img.taocdn.com/s3/m/ab09032e192e45361066f53e.png)
洛阳理工学院实验报告
系别
计算机与信息工程系
班级
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);
运算符重载实验模板
![运算符重载实验模板](https://img.taocdn.com/s3/m/07511c280066f5335a812195.png)
高级程序设计语言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.实验中遇到的问题及解决方法。
[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;}运行结果【实例编程】运行结果。
c++运算符重载实验心得
![c++运算符重载实验心得](https://img.taocdn.com/s3/m/52889e2154270722192e453610661ed9ad515592.png)
c++运算符重载实验心得
在C++中,运算符可以被重载以在自定义数据类型上执行特定操作。
在这个实验中,我学习了如何使用C++中的运算符重载,以及如何实现对自定义数据类型的专门操作。
以下是我的一些心得体会:
1. 运算符重载可以使代码更加简洁和易读。
通过重载运算符,我们可以使用类似于内置类型的语法来操作自定义类型,这样代码更加容易理解和维护。
2. 每个运算符都有其特定的重载方式。
例如,重载加法运算符可以使用成员函数或自由函数来实现,但重载等于运算符只能使用成员函数来实现。
3. 重载运算符时需要注意参数和返回值。
参数通常是类的对象或引用,而返回值可以是任何类型,包括类的对象、指针或引用。
4. 运算符重载还可以使用友元函数来实现,这样可以访问类的私有成员。
但是,应该谨慎使用友元函数,因为它们可能破坏类的封装性。
5. 在重载运算符时,应该遵循一些常规规则。
例如,对于双目运算
符,应该使用const关键字来保证左右操作数的不可变性;对于单目运算符,应该使用++或--操作符,并将其实现为成员函数。
总之,通过学习C++运算符重载,我更好地理解了类的封装性和抽象性,以及如何在自定义类型上执行特定操作。
这将对我的日后编程工作带来很大的帮助。
运算符重载实验报告
![运算符重载实验报告](https://img.taocdn.com/s3/m/78857665366baf1ffc4ffe4733687e21af45fff6.png)
一、实验目的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. 运算符重载的实际应用运算符重载在实际编程中具有以下优势:- 提高代码可读性:使用自定义类型时,可以像操作基本数据类型一样使用运算符,提高代码的可读性。
运算符重载实验
![运算符重载实验](https://img.taocdn.com/s3/m/774aee0b844769eae009eda4.png)
运算符重载的应用【实验目的】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++实验报告之静态成员、运算符重载
![C++实验报告之静态成员、运算符重载](https://img.taocdn.com/s3/m/bbb47f19fc4ffe473368abe3.png)
题目1:定义一个复数类,通过重载运算符:*,/,直接实现二个复数之间的乘除运算。
编写一个完整的程序,测试重载运算符的正确性。
要求乘法“*”用友元函数实现重载,除法“/”用成员函数实现重载。
源程序1/*******************第1题*******************//******************单森汉*****************//******************2012-5-1*****************/#include<iostream>using std::cout;using std::endl;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 &);friend Complex operator -(Complex &, 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){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;}Complex Complex::operator + ( Complex &c){Complex t;t.Real = Real + c.Real;t.Image = Image + c.Image;return t;}Complex operator -(Complex &c1, Complex &c2){Complex t;t.Real=c1.Real-c2.Real;t.Image=c1.Image-c2.Image;return t;}void main(){Complex c1(1,2),c2(3,4),c3;c3=c1*c2;cout<<"两个复数的乘法c3=c1*c2:";c3.Show();c3=c1/c2;cout<<"两个复数的除法c3=c1/c2:";c3.Show();Complex c4(1,2),c5(3,4),c6,c7(1,2),c8(3,0),c9; c6=c4+c5;cout<<"两个复数的加法c6=c4+c5:";c6.Show();c6=c4-c5;cout<<"两个复数的减法c6=c4-c5:";c6.Show();c9=c7+c8;cout<<"一个复数与一个实数的加法c9=c7+c8:"; c9.Show();c9=c7-c8;cout<<"一个复数与一个实数的减法c9=c7-c8:"; c9.Show();}运行结果截图题目2:定义一个向量(一维数组)类,通过重载运算符实现向量之间的加法和减法。
运算符重载
![运算符重载](https://img.taocdn.com/s3/m/acac424cf7ec4afe04a1df6c.png)
24
运算符重载
思考:如果希望表达式i+c1有意义, 思考:如果希望表达式i+c1有意义,应该 i+c1有意义 如何定义重载运算符函数? 如何定义重载运算符函数?
friend Complex operator+(int &i,Complex &c); Complex operator+(int &i, Complex &c) {return Complex(i+c.real,c.imag);}
2
什么是运算符重载
代码分析: 代码分析: 例10.1 通过函数来实现复数 相加。 相加。
CCS E
3
运算符重载的方法
运算符重载的方法是定义一个重载运 算符的函数, 算符的函数,在需要执行被重载的运 算符时,系统就自动调用该函数, 算符时,系统就自动调用该函数,以 实现相应的运算。也就是说, 实现相应的运算。也就是说,运算符 重载是通过定义函数实现的。 重载是通过定义函数实现的。运算符 重载实质上是函数的重载。 重载实质上是函数的重载。
CCS E
21
运算符重载
如果将运算符重载函数作为成员函数, 如果将运算符重载函数作为成员函数, 它可以通过this this指针自由地访问本类 它可以通过this指针自由地访问本类 的数据成员, 的数据成员,因此可以少写一个函数 的参数。 的参数。但必须要求运算表达式第一 个参数(即运算符左侧的操作数) 个参数(即运算符左侧的操作数)是一 个类对象, 个类对象,而且与运算符函数的类型 相同。 相同。因为必须通过类的对象去调用 该类的成员函数,而且只有运算符重 该类的成员函数, 载函数返回值与该对象同类型, 载函数返回值与该对象同类型,运算 结果才有意义。 结果才有意义。
运算符重载—C++课程实验报告
![运算符重载—C++课程实验报告](https://img.taocdn.com/s3/m/e7e5d2dfb9d528ea80c7790c.png)
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的值为:";
运算符重载——精选推荐
![运算符重载——精选推荐](https://img.taocdn.com/s3/m/f96b2cc077a20029bd64783e0912a21614797fad.png)
运算符重载运算符重载学习运算符重载,让运算符能做⼀些原来做不了的事情,⽅便它的使⽤⼀、运算符重载的概念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)不能返回局部变量的引⽤。
运算符重载-- 实验报告
![运算符重载-- 实验报告](https://img.taocdn.com/s3/m/0009256ea98271fe910ef90f.png)
南昌航空大学实验报告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;}五、程序调试经调试无误后,运行的结果为:六、实验总结通过这次的试验,我明显的感觉到自己对这方面的知识掌握的还不够熟练,不能顺利地、流畅地运用这方面的知识,因为我没有在规定的时间内完成程序的设计,课后还是要多复习。
运算符重载实验报告
![运算符重载实验报告](https://img.taocdn.com/s3/m/04e9aa81a0116c175f0e483a.png)
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日
C++实验10运算符重载
![C++实验10运算符重载](https://img.taocdn.com/s3/m/89d972f24693daef5ef73d71.png)
实验10 运算符重载1.实习目的及要求1)掌握运算符重载的基本概念和方法;2)熟习几种特殊的运算符的重载2.预习预习运算符重载的概念、运算符重载的一般方法,包括成员函数重载和友元函数重载;以及几种特殊的运算符,包括++和- - 运算符、赋值运算符、3.实验内容3.1分析下面的程序,指出程序运行的结果:1) 分析下面的程序,指出程序运行的结果:类分析和对象分析:结果预测:此程序实现对加法的重载,两对象(坐标)的x 和y 数据项分别相加,即两点坐标相加得出新点,所以结果预测为:30,302) 分析下面的程序,指出程序运行的结果:类和对象分析:结果预测:重载加法,使“+”适用于具体日期的计算,2001年(平年)2月10日(平年2月是28天)的20天后是2001年3月2日,所以结果预测为:3/2/20013.2 编写并调试程序:1)定义一个描述平面上一个点的类point,重载“++”和“--”运算符,并区分这两种运算符的前置和后置操作,构成一个完整的程序。
1)对象分析:只有一类对象:点2)类的分析和设计:一个描述平面上一个点的类point,重载“++”和“--”运算符操作设计:a)类声明和类实现:Main部分实现:程序结果:2)构造一个分数类rationalNumber,该类中包括分子和分母两个成员数据,并具有下述功能:(1)建立构造函数,它能防止分母为零,当分数不是最简形式时进行约分,并避免分母为负数。
(2)重载加法、减法、乘法以及除法运算符。
(3)重载关系运算符:>、<、==等。
◆对象分析:只有一类对象:分数◆类的分析和设计:分数类rationalNumber,该类中包括分子和分母两个成员数据,具有构造函数,重载运算符等功能类声明和类实现:Main部分实现:程序结果:*4 课后练习调试下面的程序,指出程序实现的功能及程序输出结果,掌握对象数组、进一步理解类是如何实现。
1)调试程序1具体分析如分析题1,本程序实现的功能是两点坐标的加法。
C++实验报告(10)运算符重载
![C++实验报告(10)运算符重载](https://img.taocdn.com/s3/m/e1f9a21bbed5b9f3f90f1cfb.png)
填写内容时,可把表格扩大。
{cout<<"num:"<<num<<"\nname:"<<name<<"\nsex:"<<sex<<"\npay:"<<pay<<"\n\n";}
int main()
{Teacher teacher1(10001,"Li",'f',1234.5),teacher2;
Student student1(20010,"Wang",'m',89.5);
Complex operator+(int &i);
friend Complex operator+(int&,Complex &);
void display();
private:
double real;
double imag;
};
Complex Complex::operator+(Complex &c)
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);
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
if(m==0)
{
cout<<"分母为零!"<<endl;
exit(1);
}
else if(m<0)
{fz=-z;
fm=-m;
}
else
{fm=m;fz=z;
}
simple();
}
rationalNumber operator+ (rationalNumber& r1,rationalNumber& r2){
bool operator >(const rationalNumber& r1);
bool operator <(const rationalNumber& r1);
bool operator ==(const rationalNumber& r1);
};
rationalNumber::rationalNumber(int z,int m)
public:
date(int m,int d,int y){mo=m;da=d;yr=y;}
date(){}
void disp()
{cout<<mo<<"/"<<da<<"/"<<yr<<endl;}
date operator+(int day)
{
date dt=*this;
day+=dt.da;//cout<<day<<endl;
class A{
public:
A(int i):x(i){}
A()
{x=0;
}
friend A operator ++ (A a);
friend A operator -- (A &a);
void print();
private:
int x;
};
A operator ++ (A a)
{++a.x;
return a;
};
void point::print()
{cout<<"x= "<<x<<" "<<"y= "<<y<<endl;}
point point::operator++()
{++x;++y;
return * this;
}
point point::operator++(int)
{point temp(* this);
obj3.print();
obj2.print();
return 0;
}
程序运行的结果是:
x= 6 y= 9
x= 6 y= 9
x= 7 y= 10
x= 7 y= 10
x= 9 y= 7
x= 8 y= 6
x= 8 y= 6
x= 7 y= 5
Press any key to continue
2)构造一个分数类rationalNumber,该类中包括分子和分母两个成员数据,并具有下述功能:
5.15
#include<iostream>
using namespace std;
class Words{
public:
Words(char*s)
{str=new char[strlen(s)+1];
strcpy(str,s);
len=strlen(s);
}
void disp();
char operator[](int n);
{ int k,i;
if(abs(fz)<fm)
k=abs(fz);
else
k=fm;
for(i=1;i<=k;i++)
{
if(fz%i==0&&fm%i==0)
{
fz=fz/i;
fm=fm/i;
}
}
}
//m,n的最大公约数,假定m、n的最大公约数是v,则它们的最小公倍数就是m*n/v。
int fun (int m,int n){
实验十运算符重载
1.实验目的及要求
1)掌握运算符重载的基本概念和方法。
2)熟习几种特殊的运算符的重载。
2.实验内容
1.分析下面的程序,指出程序运行的结果:
1)
#include<iostream.h>
class point{
int x,y;
public:
point(int vx,int vy){
x=vx; y=vy;}
public:
point(int x1=0,int y1=0)
{x=x1;y=y1;}
void print();
point operator++();
point operator++(int);
point operator--();
point operator--(int);
private:
int x,y;
point obj(5,8),obj1,obj2(9,7),obj3;
++obj;
obj.print();
obj1=obj++;
obj1.print();
obj.print();
obj.print();
cout<<endl;
obj2.print();
--obj2;
obj2.print();
obj3=obj2--;
rationalNumber r;
if(r1.fz==0)
return r2;
else
{r.fm=r1.fm*r2.fm;
r.fz=(r1.fz*r2.fm)+(r2.fz*r1.fm);
return r;
}
}
rationalNumber operator- (rationalNumber& r1,rationalNumber& r2){
return 0;
}
运行结果:
This is C++ book.
第1个字符: T
第16个字符: k
第26个字符:数组下标超界!
Press any key to continue
5.16
#include<iostream>
using namespace std;
class Length{
int meter;
public:
Length(int m)
{meter=m;
}
operator double()
{return (1.0*meter/1000);
}
};
int main()
{Length a(1500);
double m=float(a);
cout<<"m="<<m<<"千米"<<endl;
return 0;
rationalNumber r;
r.fm=r1.fm*r2.fm;
r.fz=r1.fz*r2.fz;
return r;
}
rationalNumber operator/ (rationalNumber& r1,rationalNumber& r2){
1建立构造函数,它能防止分母为0,当分数不是最简形式时进行约分,并避免分母为负数。
2重载加法、减法、乘法和除法运算符。
3重载关系运算符:>、<、==等。
提示:分数约分函数:
class rationalNumber//分数类
{intfm,fz;//fm—分母fz—分子
……
};
void simple()//约分函数
}
A operator -- (A &a)
{--a.x;
return a;
}
void A::print()
{cout<<x<<endl;}
int main()
{
A a(பைடு நூலகம்);
++a;
a.print();
--a;
a.print();
return 0;
}
运行结果:
7
6
Press any key to continue
friend rationalNumber operator -(rationalNumber& r1,rationalNumber& r2);
friend rationalNumber operator *(rationalNumber& r1,rationalNumber& r2);
friend rationalNumber operator /(rationalNumber& r1,rationalNumber& r2);
return point(px,py);
}
void print(){cout<<x<<","<<y<<endl;}
};
void main(void)
{
point p1(10,10),p2(20,20);