当前位置：文档之家 › 关系运算符重载实例2015

关系运算符重载实例2015

  • 格式：docx
  • 大小：12.56 KB
  • 文档页数：3

下载文档原格式

  / 3

合集下载

运算符重载的案例

运算符重载的案例
p1=p2/p3;
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);//声明赋值运算符重载=

复习五 运算符重载(改)

复习五 运算符重载(改)
1
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运算符重载
北华航天工业学院计算机系 安志远 2004
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第四章 运算符重载

4第四章 运算符重载
1 2 3
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; ▪}
  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 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。