关系运算符重载实例2015
运算符重载的案例
cout<<p1.x<<","<<p1.y<<endl;
p1=p2++;//验证单目运算符重载
cout<<p1.x<<","<<p1.y<<endl;
bool p4;//验证关系运算符
p4=(p2==p3);
printf("%d",p4);
p4=(p2>p3);
point operator -(const point &p);//声明运算符重载-
point operator *(const point &p);//声明运算符重载*
point operator /(const point &p);//声明运算符重载/
//关系运算符重载
bool operator ==(const point &p);//声明运算符重载==
{
point temp;
temp.x=x/p.x;
temp.y=y/p.y;
return temp;
}
bool point::operator ==(const point &p)//==运算符重载
{
if(x==p.x&&y==p.y)
return true;
else
bool operator > (const point &p);//声明运算符重载>
//赋值运算符重载
point &operator =(const point &p);//声明赋值运算符重载=
复习五 运算符重载(改)
6.1 运算符重载的规则
算符重载就是赋予已有的运算符多重含义 运算符重载就是赋予已有的运算符多重含义。 例如： 例如：a=3+4； ； a=”abc”+”def”; 同一个运算符“＋”，由于所操作的数据类型不 同一个运算符“ 同而具有不同的意义，这就是运算符重载。 同而具有不同的意义，这就是运算符重载。 运算符重载是C++的一项强大功能。通过重载， 运算符重载是 的一项强大功能。通过重载， 的一项强大功能 可以扩展C++运算符的功能，使它们能够操作用户 运算符的功能， 可以扩展 运算符的功能 自定义的数据类型， 自定义的数据类型，增加程序代码的直观性和可读 性
5
void main(void){ Complex c1(1,2),c2(3,4),c3,c4,; c3=c1+c2; c4=c1-c2; } c1+c2被解释为：operator+(c1,c2) 被解释为： 被解释为 c1-c2被解释为： operator-(c1,c2) 被解释为： 被解释为
6
cout<<r;
if (i>0) cout<<"+"; If (i!=0) cout<<i<<"i"<<endl; }
void main(void) { Complex c1(1,2),c2(3,4),c3,c4,; c3=c1+c2; C++会将它们转换成下面形式的调用 会将它们转换成下面形式的调用 c4=c1-c2; 语句： 语句： c1.display(); // 1+2i c3=c1.operator+(c2); c2.display(); // 3+4i c4=c1.operator –(c2); c3.display(); // 4+6i c4.display();} // -2-2i
第六章运算符重载
复数 a = 2.3 + 4.6i 复数 b = 6.7 + 9.8i
a+b = 9.0 + 14.4i a-b = -4.4 - 5.2i
. . .
. .
.
. . . . . . . .
. . . . . . . .
. . . . . . . . .
. .
. .
. .
. .
.
编程题回顾：复数
抽象
double real; double image;
Complex AddComplex (Complex right) Complex SubComplex (Complex right) Complex MulComplex (Complex right)
. . .
. .
.
. . . . . . . .
运算符重载
耿耀君
计算机科学系
June 19, 2015
. . .
. .
.
. . . . . . . .
. . . . . . . .
. . . . . . . . .
. .
. .
. .
. .
.
耿耀君 (计算机科学系)
运算符重载
June 19, 2015
1 / 51
1
导引 运算符重载
2
. . .
. .
耿耀君 (计算机科学系)
double real; double image;
Complex AddComplex (Complex right) Complex SubComplex (Complex right) Complex MulComplex (Complex right) Complex DivComplex (Complex right)
运算符重载
void complex::print( ) { if (imag==0) cout<<real<<endl; else if(imag>0) cout<<real<<"+"<<imag<<"i\n"; else cout<<real<<imag<<"i\n"; } complex operator -(complex obj) { complex temp; temp. real= -obj.real ; temp. imag= -obj.imag; return temp; }
10
void main( ) { complex com1(2.3,4.6),com2(3.6,2.8),result; cout<<"complex com1 and com2 orderly:\n"; com1.print( ); com2.print( ); result=com1+com2; cout<<"com1+com2="; result.print( ); result=com1-com2; cout<<"com1-com2="; result.print( ); result=com1*com2; cout<<"com1*com2="; result.print( ); result=com1/com2; cout<<"com1/com2="; result.print( ); }
2、双目运算符的重载
6运算符重载
6.1.2 运算符重载的语法形式
➢ 运算符通常是对类中的私有成员进行操作，故重载运算符应 能访问类中的私有成员，所以重载运算符一般采用成员函数或 友员函数的形式。 ➢ 成员函数的语法形式为：
类型 类名 :: operator op ( 参数表 )
{
// 相对于该类定义的操作
else
{ cout << "\n Data overflow !" << endl ;
Hale Waihona Puke #include<iostream.h> #include<stdlib.h> class Calculator { public:
Calculator() { value = 0 ; } ; void operator ++ () ; void operator -- () ; unsigned int operator() () ; private: unsigned int value; }; void main()
第6章 运算符重载
运算符重载使得用户自定义的数据以一种更简洁的方式工作，
就是赋予已有的运算符多重含义。
能表示为
例如
? c1 = c1 + c2 ;
int x , y ; y=x+y;
complex c1 , c2 ; c1 = Cadd (c1 , c2 ) ;
定能义表示为
? // 运复m算数1类符=对重m象载1 +函m数2 ;
{
// 相对于该类定义的操作
} ➢ 一个运算符被重载后，原有意义没有失去，只是定义了相对 一特定类的一个新运算符
4第四章 运算符重载
const complex operator - (const complex &c) const; void display(); //输出复数 private: //私有数据成员 1.是为了堵塞a+b=c的漏洞。 double real; //复数实部 2. 3.是为了扩大适应性。 double imag; //复数虚部 };
17
[ ]运算符重载为成员函数
下标运算符［］可以重载： 重载形式为：operator［］(int); 当 X x; 隐含调用。 x[y] 可被解释为： 显式调用。 x. operator [ ](y)； 只能重载为成员函数，不能使用友元函数。 这个类显然是个‚数组类‛。
18
前置++和后置++重载为成员函数
9
使用
void main(){
complex c1(5,4),c2(2,10),c3; //三个复数类的对象 cout<<"c1="; cout<<"c2="; c1.display(); c2.display();
c3=c1-c2; //使用重载运算符完成复数减法 cout<<"c3=c1-c2="; c3.display(); 程序输出结果为：
这三个运算符是许多 教课书没有提到的。
唯一的一个三目运 算符不能重载。
3
运算符重载的基础
设计运算符重载函数，首先要了解运算符原本的运算语义。重
载函数要忠实遵守该运算符作用于基本数据类型时的语义，
并表现出自身所特有的性质。 例如：+ 、+= 、=、++(前)、++(后) ....
运算符重载
第4章运算符重载4.1 什么是运算符重载所谓重载，就是重新赋予新的含义。
函数重载就是对一个已有的函数赋予新的含义，使之实现新功能。
运算符也可以重载。
实际上，我们已经在不知不觉之中使用了运算符重载。
如：+可以对int、float、double的数据进行加法运算。
现在要讨论的问题是：用户能否根据自己的需要对C++已提供的运算符进行重载，赋予它们新的含义，使之一名多用。
譬如，能否用“+”号进行两个复数、两个点的相加。
在C++中不能在程序中直接用运算符“+”对复数进行相加运算。
用户必须自己设法实现复数相加。
例如用户可以通过定义一个专门的函数来实现复数相加。
见下例。
//例4.1 通过函数来实现复数相加。
#include <iostream>using namespace std;class Complex{public:Complex(){real=0;imag=0;} //构造函数Complex(double r,double i){real=r;imag=i;} //构造函数重载Complex complex_add(Complex &c2); //声明复数相加的函数void display(); //声明输出函数private:double real, imag;};Complex Complex::complex_add(Complex &c2){ Complex c;c.real=real+c2.real;c.imag=imag+c2.imag;return c;//以上可简写为：return Complex(real+c2.real,imag+c2.imag);}void Complex::display(){ cout<<"("<<real<<","<<imag<<"i)"<<endl;}int main(){ Complex c1(3,4),c2(5,-10),c3;c3=plex_add(c2);cout<<"c1="; c1.display();cout<<"c2="; c2.display();cout<<"c1+c2="; c3.display();return 0;}结果无疑是正确的，但调用方式不直观、太烦琐，使人感到很不方便。
运算符重载
说明：
Complex Complex::operator+(Complex c){ Complex Temp(Real+c.Real , Image+c.Image) ; return Temp ; }
当成员函数的参数为同一类（class）的对象或它的引 用，在函数体内使用参数对象的私有数据成员时，可 用对象名加成员访问操作符点号进行。 从逻辑上讲，每个对象有自己的成员函数，访问同类其 他对象的私有数据成员应通过该对象的公有函数，不 能直接访问。但在物理上只有一个成员函数代码，所 以直接访问是合理的。仅在成员函数中可以这样做。
int main(void){ Complex c1(1.0,1.0) , c2(2.0,2.0) , c3(4.0,4.0) , c; double d=0.5 ; c1.Print(); c=c2+c3; c.Print(); //两复数相加 c+=c2+=c1; c.Print(); //连续加赋值 c=c+d; c.Print(); //复数加实数 c=d+c; c.Print(); //实数加复数 c=c3*c2; c.Print(); c=c3/c1; c.Print(); c=c3*d; c.Print(); //复数乘以实数 c=c3/d; c.Print() ; //复数除以实数 cout<<"c3的模为："<<abs(c3)<<endl ; return 0;}
4. C++中只有极少数的运算符不允许重载。
运算符
运算符名称
三目条件运算 符 成员与成员指 针操作符 作用域操作符 类型字长操作 符
禁止重载的理由
C++运算符重载讲解与经典实例 (2)
5.重载运算符有哪些限制:
(1)不可臆造新的运算符。必须把重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中。
(c1+c2)*(c1-c2)*c2/c1=9.61538+25.2308i
在程序中，类complex定义了4个成员函数作为运算符重载函数。将运算符重载函数说明为类的成员函数格式如下：
＜类名＞operator＜运算符＞(＜参数表＞)
其中，operator是定义运算符重载函数的关键字。
程序中出现的表达式：
位操作运算符：&,|,~,^,＜＜,＞＞
逻辑运算符：!,&&,||;
比较运算符：＜,＞,＞=,＜=,==,!=;
赋值运算符：=,+=,-=,*=,/=,%=,&=,|=,^=,＜＜=,＞＞=;
其他运算符：[],(),-＞,,(逗号运算符),new,delete,new[],delete[],-＞*。
double real;
double imag;
};
complex a(10,20),b(5,8);
“a+b”运算如何实现？这时候我们需要自己编写程序来说明“+”在作用于complex类对象时，该实现什么样的功能，这就是运算符重载。运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据导致不同类型的行为。
运算符重载形式有两种，重载为类的成员函数和重载为类的友元函数。
运算符重载为类的成员函数的一般语法形式为：
C_运算符重载_各类详细介绍
▪ 说明
运算符重载函数 operator@()可以返回任何类型，甚至可 以是 void类型，但通常返回类型与它所操作的类的类型 相同，这样可使重载运算符用在复杂的表达式中。例如， 在例7-2中，可以将几个复数连续进行加、减、乘、除的 运算。
用友元函数重载单目运算符时，需要一个显式的操作数， 例7-3中，用友元函数重载单目运算符“-”
#include<iostream.h> class nclass{ int a,b; public:
nclass(int x=0,int y=0) { a=x;b=y;} friend nclass operator -(nclass obj); void show(); };
▪ complex operator+(complex com1,complex com2) { return complex(com1.real+com2.real,com1.imag+com2.imag;}
▪ 这种方法是直接将一个无名临时对象创建到主调函数中，那么 运行效率高于前一种。
▪ 单目运算符重载
nclass operator-(nclass obj) { obj.a=-obj.a;
obj.b=-obj.b; return obj;} void nclass::show() { cout<<"a="<<a<<" b"<<b;} ▪ main() ▪{ ▪ nclass ob1(10,20),ob2; ▪ ob1.show(); ▪ ob2=-ob1; ▪ ob2.show(); ▪ return 0; ▪}
运算符重载综合实例
运算符重载综合实例class MyComplex{ double Real;double Imag;public://构造函数MyComplex(const double &r=0.0,const double &i=0.0){Real=r;Imag=i;cout<<"Constructor !"<<endl;} //拷贝构造函数MyComplex(const MyComplex &);double GetReal(){return Real;}double GetImag(){return Imag;}//赋值运算符重载为成员函数MyComplex operator=(const MyComplex &c);//负数运算符重载为成员函数MyComplex operator-();//后缀加1，成员函数MyComplex operator++(int);//后缀减1，外部函数friend MyComplex operator--(MyComplex &,int);//加法，外部函数friend MyComplex operator+(const MyComplex &, const MyComplex &);//减法，成员函数MyComplex operator-(const MyComplex &);//加赋值，成员函数MyComplex operator+=(const MyComplex &);//比较，外部函数和friend int operator==(const MyComplex &, const MyComplex &);};MyComplex operator--( MyComplex &c,int){MyComplex result(c.Real--,c.Imag--);cout<<"operatorpostfix--"<<endl;return result;}MyComplex operator+(const MyComplex &c1, const MyComplex &c2){MyComplex result(c1.Real+c2.Real,c1.Imag+c2.Imag);cout<<"operator+"<<endl;return result;}int operator==(const MyComplex &c1, const MyComplex &c2){cout<<"operator=="<<endl;return (c1.Real==c2.Real)&&(c1.Imag==c2.Imag);}MyComplex::MyComplex(const MyComplex &c){Real=c.Real;Imag=c.Imag;cout<<"Copy Constructor !"<<endl;}MyComplex MyComplex::operator=(const MyComplex &c){Real=c.Real;Imag=c.Imag; cout<<"operator="<<endl;return *this;} MyComplex MyComplex::operator-(){Real=-Real;Imag=-Imag;cout<<"operatorunary-"<<endl;return *this;}MyComplex MyComplex::operator++(int){MyComplex result(Real++,Imag++);cout<<"operatorpostfix++"<<endl; return result;}MyComplex MyComplex::operator-(const MyComplex &c){Real-=c.Real; Imag-=c.Imag;cout<<"operatorbinary-"<<endl;return *this;} MyComplex MyComplex::operator+=(const MyComplex &c){Real+=c.Real; Imag+=c.Imag; cout<<"operator+="<<endl; return *this;}void main(){MyComplex a(10,20),b(11,21),e,*p;MyComplex c(a);MyComplex d=b;d+=c++;e=((a+b)-(c--))+(-d);p=new MyComplex(21,22);if(!p) return;e+=(d==(*p));if(p) delete p;cout<<a.GetReal()<<"+j"<<a.GetImag()<<endl;cout<<b.GetReal()<<"+j"<<b.GetImag()<<endl;cout<<c.GetReal()<<"+j"<<c.GetImag()<<endl;cout<<d.GetReal()<<"+j"<<d.GetImag()<<endl;cout<<e.GetReal()<<"+j"<<e.GetImag()<<endl;}Constructor !Constructor !Constructor !Copy Constructor !Copy Constructor !Constructor !operatorpostfix++Copy Constructor !operator+=Copy Constructor !operatorunary-Copy Constructor !Constructor !operatorpostfix--Copy Constructor !Constructor !operator+Copy Constructor ! operatorbinary- Copy Constructor ! Constructor ! operator+Copy Constructor ! operator=Copy Constructor ! Constructor ! operator== Constructor ! operator+=Copy Constructor ! 10+j2011+j2110+j20-21+j-41-11+j-21。
5种重载的运算符及其对应的方法
5种重载的运算符及其对应的方法重载运算符是C++语言的一个重要特性，它允许自定义类类型对内置运算符进行操作。
通过重载运算符，可以使得自定义类类型的对象可以像内置类型一样使用运算符。
在C++中，有许多运算符都可以通过重载来定义对应的操作。
本文将介绍5种常见的重载运算符及其对应的方法。
1. 赋值运算符（=）赋值运算符重载函数的原型为：Class& operator=(const Class& other)这个运算符用于将一个对象的值赋给另一个对象，例如：```cppClass obj1;Class obj2;obj2 = obj1; // 调用赋值运算符重载函数```2. 算术运算符（+、-、*、/、%）算术运算符重载函数的原型为：Class operator+(const Class& other)、Class operator-(const Class& other)、Class operator*(const Class& other)、Classoperator/(const Class& other)、Class operator%(const Class& other)这些运算符用于进行对象之间的加减乘除和取模运算，例如：```cppClass obj1;Class obj2;Class obj3;obj3 = obj1 + obj2; // 调用加法运算符重载函数```3. 关系运算符（==、!=、>、<、>=、<=）关系运算符重载函数的原型为：bool operator==(const Class& other)、bool operator!=(const Class& other)、bool operator>(const Class& other)、booloperator<(const Class& other)、bool operator>=(const Class& other)、booloperator<=(const Class& other)这些运算符用于比较两个对象之间的大小和相等关系，返回一个布尔值，例如：```cppClass obj1;Class obj2;if(obj1 == obj2) // 调用等于运算符重载函数{// 两个对象相等}```4. 递增、递减运算符（++、--）递增、递减运算符重载函数的原型为：Class& operator++()、Classoperator++(int)、Class& operator--()、Class operator--(int)这些运算符用于对对象进行递增、递减操作，分为前置和后置形式，例如：```cppClass obj;obj++; // 调用后置递增运算符重载函数```5. 下标运算符（[]）下标运算符重载函数的原型为：Type& operator[](int index)这个运算符用于对对象进行类似数组的访问操作，例如：```cppClass obj;Type value = obj[index]; // 调用下标运算符重载函数```通过重载运算符，可以使得自定义类类型的对象能够以一种直观、简洁的方式与内置类型进行相似的操作。
运算符重载
{
rpart=rp;
ipart=ip;
}
Complex add( const Complex & com )
{
Complex temp ;
temp .rpart= com .rpart+rpart;
temp .ipart= com .ip+ipart;
return temp ;
}
2020/7/2
பைடு நூலகம்};
★单目运算符重载 ：
Complex Complex:: operator {
Complex temp;
( 单) 目无参数 双目一个参数
temp.rpart=-rpart;
temp.ipart)=-ipart;
return temp;
}
Complex c=-a+b;
(a.operator-( )).operator+(b)
};
point point::operator+ (point p1)
{ point p; p.x=x+p1.x; p.y=y+p1.y; return p; }
void main()
{ point p1(10,10),p2(20,20); p1=p1+p2 ;
p1.print(); ++p1; p1.print();
}
//(╳)
运算符成员函数——调用成员函数的对象隐式成为表达式的第一个运算数 外部运算符函数——其第一个参数直接对应表达式的第一个运算数；
x1=x2+x3;
operator+(x2, x3);
2020/7/2
6 6
第8章运算符重载
第八章操作符重载重载是C++多态性的体现之一。
当定义新的数据类型之后，C++原有操作符提供的操作在语义往往不能满足对新的数据类型的对象进行操作，因此必须对C++原有操作符的操作语义进行扩充，这就是重载的应用需求背景。
8.1操作符重载概述当在同一作用域内声明两个或多个相同的名字(即标识符)时，称该名字被重载。
在同一作用域内的两个声明，如果声明的名字相同但是数据类型不同，则称这两个声明为重载声明。
C++规定，只有函数声明可以被重载，对象声明或类型声明不允许重载。
换言之，C++的这一规定将重载严格限制在函数范畴。
当重载的函数被调用时，从诸个可调用的重载函数( viable fu nctio ns )中究竟调用那一个函数则由调用时实参的类型与函数声明时形参的类型相比较结果的一致性决定。
这个选择与决定的过程称为重载解析。
在C++中,根据函数的定义者是谁可以将函数分为两类。
一类是由程序员定义的函数，它们往往被称为用户自定义函数，另一类则是系统提供的函数。
就系统提供的函数而言，根据它们的调用方式，又可以进一步分为两类。
一类是与用户自定义函数调用方式相同的系统函数，它们往往称为库函数或类库中的成员函数；另一类则沿用自然语言和数学语言的使用习惯，在各类表达式中完成相应的运算，它们往往称为操作符或运算符，但实际上是系统的预定义函数或操作符函数。
例如对整型对象x、y，x+y 实际表示对预定义函数’+'的调用。
x和y是预定义函数’+'的参数，但一般习惯上称为‘ + '的左操作数和右操作数。
由于操作符实际上也是函数，不同的只在于操作符是系统的预定义函数，因此操作符和用户自定义函数一样也可以重载。
以加法操作‘ +'为例，C++提供的‘ +'操作如果不考虑类库支持，则只能进行整数或实数的加法运算，若考虑类库支持则能够进行一般复数的运算。
如果用复数来表示电路中的电流和电压，根据电路理论，只有电流和电流才能进行相加减的运算；同理，只有电压和电压才能进行相加减的运算。
C++之关系与下标操作符重载
TSINGHUA UNIVERSITY
■
下标操作符重载
下标操作符重载的场合与目的
- 如果对象具有数组成员，且该成员为主要成员，可以重载下 标操作符 - 目的：以允许在对象上通过数组下标访问该数组成员的元素
下标操作符必须重载两个版本
- 常函数版本用于处理常量
数组下标越界错误
- 可以在重载函数中处理数组下标越界错误，或使用异常处理 机制
TSINGHUA UNIVERSITY
ห้องสมุดไป่ตู้
■
下标操作符重载
int & Couple::operator[]( int index ) { if( index < 0 || index > 1 ) throw std::out_of_range( "Index is out of range!" ); return _a[index]; } const int & Couple::operator[]( int index ) const { if( index < 0 || index > 1 ) throw std::out_of_range( "Index is out of range!" ); return _a[index]; } int main() { Couple a( 1, 2 ), b( 3, 4 ); cin >> a[0] >> a[1]; cout << b[0] << " " << b[1] << endl; return 0; }
TSINGHUA UNIVERSITY
■
下标操作符重载
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include <iostream.h>
//using namespace std;
class Date
{
private:
int year;
int month;
int day;
public:
Date(){}
Date(int y,int m,int d);
void display();
friend bool operator >(Date &d1,Date &d2);
friend bool operator <(Date &d1,Date &d2);
friend bool operator ==(Date &d1,Date &d2);
};
Date::Date(int y,int m,int d)
{
this->year=y;
this->month=m;
this->day=d;
}
void Date::display()
{
cout<<this->year<<"-"<<this->month<<"-"<<this->day; }
bool operator >(Date &d1,Date &d2)
{
if(d1.year>d2.year)
return true;
else if(d1.year==d2.year)
{
if(d1.month>d2.month)
return true;
else if(d1.month==d2.month)
{
if(d1.day>d2.day)
return true;
else return false;
}
else
return false;
}
else
return false;
}
bool operator <(Date &d1,Date &d2)
{
if(d1.year<d2.year)
return true;
else if(d1.year==d2.year)
{
if(d1.month<d2.month)
return true;
else if(d1.month==d2.month)
{
if(d1.day<d2.day)
return true;
else return false;
}
else
return false;
}
else
return false;
}
bool operator ==(Date &d1,Date &d2)
{
bool b;
b=d1.year==d2.year&&d1.month==d2.month&&d1.day==d2.day;
return b;
}
void Compare(Date &d1,Date &d2)
{
d1.display();
if(d1>d2)
cout<<"大于";
if(d1<d2)
cout<<"小于";
if(d1==d2)
cout<<"等于";
d2.display();
cout<<"\n";
}
int main()
{
Date d1(2015,11,15),d2(2015,9,5);
Date d3(2015,5,1),d4(2015,5,7);
Date d5(2015,11,15),d6(2015,11,15);
Compare(d1,d2);
Compare(d3,d4);
Compare(d5,d6);
return 0;
}
程序执行结果为：
2015-11-15大于2015-9-5
2015-5-1小于2015-5-7
2015-11-15等于2015-11-15。