运算符重载的案例

合集下载

11章运算符重载

11章运算符重载

考虑用普通函数实现两个复数相加
Complex complex_add(Complex &c1, Complex &c2) { Complex c; c.real=c1.real+c2.real; c.imag=c1.imag+c2.imag; return c; }
将其声明为Complex 类的友元函数
int operator + (int a, int b) {return (a-b);}
(8)用于类对象的运算符一般必须重载,但有两个例外,运算 符“=”和“&”不必用户重载。 ① 赋值运算符(=)可以用于每一个类对象,可以利用它在 同类对象之间相互赋值(系统已经为每一个新声明的类重载 了一个赋值运算符,他的作用是逐个复制类的数据成员)。 ② 地址运算符&也不必重载,它能返回类对象在内存中 的起始地址。 (9)应当使重载运算符的功能类似于该运算符作用于标准类型 数据时所实现的功能。 (10)运算符重载函数可以是类的成员函数,也可以是类的友 元函数,还可以是既非类的成员函数也不是友元函数的普通 函数。
后自增
在自增(自减)运算符重载函数中,增加一个int型形参,就是后置自 增(自减)运算符函数。
#include <iostream> Complex Complex::operator ++ (int) using namespace std; { //对象复制,保存修改前对象状态 class Complex Complex temp(*this); {public: real++; imag++; //对象自增 Complex( ) return temp; //返回的是自加前的对象 {real=0; imag=0;} } Complex(double r,double i) {real=r; imag=i;} void Complex∷display( ) //重载后自增++函数 cout<<″(″<<real<<″,″<<imag<<″i) Complex operator + { +(int); void display( ); ″<<endl;} private: int main( ) double real; { Complex c1(3,4),c2; double imag; c2=c1++; // c1. operator ++ (0) }; cout<<″c1=″; c1.display( ); cout<<″c2=″; c2.display( ); }

复习五 运算符重载(改)

复习五  运算符重载(改)
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

第5讲_运算符重载(下)

第5讲_运算符重载(下)
双目运算符有2个操作数,如果运算符重载函数
作为成员函数,则只有一个参数。如为友元函数, 则有2个参数 单目运算符只有一个操作数,如果运算符重载函 数作为成员函数,则还可省略此参数。例如,下面 重载“++” “++” 有两种方式,前置自增运算符和后置自 增运算符,在重载时怎样区别这二者呢?
4
5
19
本讲重点
对象的引用做函数参数的意义(见P335) 对<<和>>的重载的方法 类的转换构造函数:其他类型本类 类的类型转换函数:本类其他类型

20
第4次作业
作业要求同前面,在第7周末交 1. 定义一个Teacher类和一个Student类,两者有一部分的数 据成员是相同的,例如:num, name和sex.编写程序,将 一个Student类对象转为Student类对象,只需将以上3个 相同的数据成员移植过去。(参加教材P343的第7题) 2. 在第3次作业的基础上,对“犀利人事管理系统”进行修 改。要求对>> 和<<进行重载。重载后使用“>>”可以从 键盘输入一个员工对象的所有信息。例如:employee emp[25]; cin>>emp[0];同样,对<<重载后,使用<<可以 输出员工(一个对象)的所有信息,cout << emp[0]
非标准类型数据间的转换
对于用户自己声明的类型,即非标准类型。编译系统并不
知道怎样进行转换? 如何实现不同类型的类对象之间的转换呢?
12
类型转换构造函数
转换构造函数(conversion
constructor function) 是将一 个其他类型的数据转换成自身类的对象 小结:构造函数: 默认构造函数。例:Complex类的默认构造函数:Complex( ); 用于初始化的构造函数。例:Complex(double r,double i); 用于复制对象的复制构造函数。Complex (Complex &c); 转换构造函数。转换构造函数只有一个形参, 如:Complex(double r) {real=r;imag=0;} 以上构造函数可同时出现在同个类中,是构造函数的重载。 编译系统会根据建立对象时给出的实参的个数与类型选择形参 与之匹配的构造函数

第14课 运算符重载

第14课 运算符重载

第14课运算符重载一、运算符重载的概念1、概念一符多用。

通过重载,对运算符赋予新的含义。

如“+”号,通过重载(C++系统完成),既可以进行整数运算,也可以进行浮点数运算。

2、实例:复数的加法(14_001.cpp)3、上例:对“+”运算符进行重载(14_002.cpp)-------------------------------------------------------------------------------二、运算符重载的规则1、不允许自己定义新的运算符2、不能重载的运算符(1). (成员访问运算符)(2)* (成员指针访问运算符)(3):: (域运算符)(4)sizeof (长度运算符)(5)?: (条件运算符)3、不能改变运算对象的个数4、不能改变运算符的运算级别5、不能改变结合性6、重载运算符的函数不能有默认的参数7、至少有一个参数是自定义的类对象(不能全是C++的标准类型)8、用于类对象的运算符必须重载,有两个例外:“=”“&”9、重载功能应该类似于标准的功能------------------------------------------------------------------------------- 三、运算符重载函数作为友元函数实例:复数相加(14_003.cpp)说明:1、在VC++ 6.0中运行此程序,应修改头两行,见程序。

2、由于友元函数会破坏类的封装性,所以应尽量避免使用。

四、重载双目运算符(有两个操作数,如“+”)1、实例:重载字符串比较运算符“==”、“>”、“<”、“!=”说明:C++的字符串类型,就是对以上的运算符进行了重载,方便了字符串的比较 2、程序(14_004.cpp):以“==”运算符重载为例注意:如果将重载函数定义为友元函数,则程序开头两句应改为:#include <iostream.h>3、重载“+”运算符,对类对象进行相加运算(14_exam.cpp)4、重载“<”运算符,对类对象进行比较(14_011.cpp)5、重载“<”运算符,判断点在不在背景空白处(14_012.cpp)-------------------------------------------------------------------------------五、重载单目运算符1、实例:重载运算符“++”(14_005.cpp)说明:第二个重载函数,多了一个“int”参数,无实际意义,只是与第一个函数区别开来。

C++运算符重载讲解与经典实例 (2)

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类对象时,该实现什么样的功能,这就是运算符重载。运算符重载是对已有的运算符赋予多重含义,使同一个运算符作用于不同类型的数据导致不同类型的行为。
运算符重载形式有两种,重载为类的成员函数和重载为类的友元函数。
运算符重载为类的成员函数的一般语法形式为:

运算符重载综合实例

运算符重载综合实例

运算符重载综合实例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。

实验五 运算符重载

实验五  运算符重载

实验六运算符重载(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。

简述运算符重载的规则。

简述运算符重载的规则。

简述运算符重载的规则。

篇一:运算符重载是C/C++语言中一种强大的功能,允许程序员自定义函数的行为,以处理不同类型的数据。

运算符重载允许程序员在函数中重载算术、逻辑和位运算符,从而能够处理数组、结构体和指针等不同类型的数据。

以下是运算符重载的规则:1. 算术运算符重载算术运算符包括加号、减号、乘号和除号。

每个算术运算符都有一组默认的行为,可以通过运算符重载来自定义它们的行为。

例如,重载加号运算符可以使函数接受一个整数参数,并返回一个新的整数。

下面是一个简单的例子,演示了如何重载加号运算符:```c++struct MyStruct {int value;};MyStruct operator+(const MyStruct& other, int value) {return MyStruct(value + other.value);}int main() {MyStruct mystruct1 = { 10 };MyStruct mystruct2 = { 20 };int result = mystruct1 + mystruct2;std::cout << "result = " << result << std::endl;return 0;}```在上面的例子中,我们定义了一个名为`MyStruct`的结构体类型,其中包含一个整数类型。

然后,我们定义了一个重载加号运算符的函数,该函数接受一个整数类型的参数,并返回一个新的`MyStruct`对象。

在`main`函数中,我们定义了两个`MyStruct`对象`mystruct1`和`mystruct2`,并将它们相加,结果存储在`result`变量中。

2. 逻辑运算符重载逻辑运算符包括条件运算符和逻辑非运算符。

每个逻辑运算符都有一组默认的行为,可以通过运算符重载来自定义它们的行为。

重载等号运算符

重载等号运算符

在C++中,重载等号运算符(operator=)允许你定义当两个对象进行赋值操作时的行为。

默认情况下,编译器会为类提供一个基本的赋值运算符实现,但通常情况下,你可能需要自定义赋值运算符以满足特定的需求。

重载等号运算符的函数原型通常如下:cpp复制代码ClassName& operator=(const ClassName& other);这个函数返回一个对调用对象的引用(通常使用ClassName&),并接受一个常量引用参数(通常是const ClassName&),它表示要被复制的对象。

以下是一个简单的示例,演示如何重载等号运算符:cpp复制代码class MyClass {private:int value;public:MyClass(int v) : value(v) {}// 重载等号运算符MyClass& operator=(const MyClass& other) {// 防止自赋值if (this == &other) {return *this;}// 执行赋值操作value = other.value;// 返回调用对象的引用return *this;}// 获取value的值int getValue()const {return value;}};int main() {MyClass obj1(10);MyClass obj2(20);// 使用重载的等号运算符obj2 = obj1;// 输出obj2的value,应该为10std::cout << obj2.getValue() << std::endl;return0;}在这个例子中,MyClass类重载了等号运算符,以便在obj2 = obj1;这样的语句执行时,obj2的value成员变量会被设置为obj1的value成员变量的值。

c++运算符重载复数加减乘除

c++运算符重载复数加减乘除

c++运算符重载复数加减乘除C++中的复数是由实部和虚部组成的数字,可以使用运算符重载来实现复数的加减乘除操作。

对于加法和减法,我们只需将实部和虚部分别相加或相减即可。

对于乘法,我们需要使用以下公式:(a+bi)×(c+di) = (ac-bd) + (ad+bc)i其中,a、b、c、d分别为复数的实部和虚部。

对于除法,我们需要使用以下公式:(a+bi) / (c+di) = ((ac+bd)/(c+d)) + ((bc-ad)/(c+d))i 实现时,我们需要在类中重载相应的运算符。

以下是一个示例程序:```#include <iostream>using namespace std;class Complex {private:float real, imag;public:Complex(float r = 0, float i = 0) : real(r), imag(i) {} Complex operator+(const Complex &c) {return Complex(real + c.real, imag + c.imag);}Complex operator-(const Complex &c) {return Complex(real - c.real, imag - c.imag);}Complex operator*(const Complex &c) {float r = real * c.real - imag * c.imag;float i = real * c.imag + imag * c.real;return Complex(r, i);}Complex operator/(const Complex &c) {float r = (real*c.real + imag*c.imag) / (c.real*c.real + c.imag*c.imag);float i = (imag*c.real - real*c.imag) / (c.real*c.real + c.imag*c.imag);return Complex(r, i);}void show() {cout << '(' << real << ' + ' << imag << 'i)' << endl;}};int main() {Complex c1(2, 3), c2(4, 5);Complex c3 = c1 + c2;c3.show(); // (6 + 8i)c3 = c1 - c2;c3.show(); // (-2 - 2i)c3 = c1 * c2;c3.show(); // (-7 + 22i)c3 = c1 / c2;c3.show(); // (0.560976 + 0.0243902i)return 0;}```运行结果:```(6 + 8i)(-2 - 2i)(-7 + 22i)(0.560976 + 0.0243902i)```以上是一个简单的复数运算符重载示例,可以根据需要进行扩展和优化。

第11章77 运算符重载

第11章77 运算符重载

bool operator<=(const Rational &r1) const;
bool operator>=(const Rational &r1) const;
bool operator!=(const Rational &r1) const;
void display() { cout << num << '/' << den; }
5
不能重载的运算符
. .* :: ?: sizeof
第11章77 运算符重载
6
第11章 运算符重载
什么是运算符重载 运算符重载的方法 几个特殊的运算符的重载 自定义类型转换运算符 运算符重载实例
第11章77 运算符重载
7
运算符重载的方法
运算符重载就是写一个函数解释某个运算符在 某个类中的含义
运算符的重载不能改变运算符的运算对象数。因此,重载函 数的形式参数个数(包括成员函数的隐式指针this)与运算 符的运算对象数相同
运算符重载可以重载成成员函数也可以重载成全局函数实现。 重载成全局函数时,最好把此函数设为友员函数
如果作为类的成员函数,它的形式参数个数比运算符的运算 对象数少1。这是因为成员函数有一个隐含的参数this。在 C++中,把隐含参数this作为运算符的第一个参数。
第11章77 运算符重载
4
可以重载的运算符
+ - * / % ^ &| ~ ! = < > += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= && || ++ -- ->* , -> [] () new delete new[] delete[]

python中运算符重载方法

python中运算符重载方法

python中运算符重载方法在Python中,运算符重载可以通过定义特殊的方法来实现。

这些方法通常以双下划线开头和结尾,例如`__add__`、`__sub__`、`__mul__`等。

当你在自定义的类中定义了这些方法后,Python会自动将相应的运算符重载到你的类上。

以下是一个简单的例子,演示如何在Python中重载加法运算符:```pythonclass ComplexNumber:def __init__(self, real, imag):= real= imagdef __add__(self, other):if isinstance(other, ComplexNumber):return ComplexNumber( + , + )else:raise TypeError("Unsupported operand type for +")def __str__(self):return f"{} + {}i"测试代码c1 = ComplexNumber(1, 2)c2 = ComplexNumber(3, 4)result = c1 + c2 调用 __add__ 方法print(result) 输出 4 + 6i```在这个例子中,我们定义了一个`ComplexNumber`类,并在其中重载了加法运算符。

当两个`ComplexNumber`对象使用加法运算符相加时,Python 会自动调用`__add__`方法。

如果另一个对象不是`ComplexNumber`类型,则会抛出一个`TypeError`异常。

C++程序设计课件 第6课 运算符重载

C++程序设计课件 第6课 运算符重载

第6课运算符重载一、运算符重载的含义重载是C++语言的一个特点,在第2课中我们讨论了函数重载,在本课中,我们来学习运算符重载。

首先来看一下,运算符重载的含义。

看下面的例子:--------------------------------------------------------------------- #include <iostream>using namespace std;int main(){int a1,a2;a1=10;a2=20;int a3=a1+a2;cout<<"a3="<<a3<<endl;return 0;}--------------------------------------------------------------------- 在“a3=a1+a2”这个表达式中,有一个加法运算,使用“+”号对两个变量进行运算。

那么,能否使用“+”号对类的两个对象进行运算呢?像下面这样:--------------------------------------------------------------------- #include <iostream>using namespace std;class A{…}int main(){A a1,a2,a3;…a3=a1+a2;…return 0;}--------------------------------------------------------------------- 回答是肯定的。

C++语言通过对“+”运算符进行重载,就可以实现这样的功能。

运算符重载,就是赋予运算符新的含义(功能),使之能够对类的对象进行运算,从而让程序更加简洁、更加直观。

运算符重载,是通过编写运算符的重载函数来实现的。

运算符重载函数的格式如图8-1所示。

python运算符重载小实例

python运算符重载小实例

在Python语言中提供了类似于C++的运算符重在功能:
一下为Python运算符重在调用的方法如下:
Method Overloads Call for
__init__ 构造函数 X=Class()
__del__ 析构函数 对象销毁
__add__ +
X+Y,X+=Y
__or__ |
X|Y,X|=Y
__repr__ 打印转换 print X,repr(X)
博客园 用户登录 代码改变世界 密码登录 短信登录 忘记登录用户名 忘记密码 记住我 登录 第三方登录/注册 没有账户, 立即注册
python运算符重载小实例
1 class Prod:
2 def __init__(self, value):
3
print '111'
4
self.value = value
__str__ 打印转换 print X,str(X)
__call__ 调用函数 X()
__getattr_ 限制
X.undefine
__setattr__ 取值
X.any=value
__getitem__ 索引
X[key],
__len__ 长度
len(X)
__cmp__ 比较
X==Y,X<Y
__lt__ 小于X<Y__eq__ 等于X=Y
__radd__ Right-Side + +X
__iadd__ +=
X+=Y
__iter__ 迭代
For In
5 def __call__(self, other):

C 运算符重载实例

C  运算符重载实例

1.赋值函数的重载示例程序代码如下#include "stdafx.h"#include <malloc.h>class stack{private:int *sp, top, max;void inflate();public:stack(int size = 10){sp = (int *)malloc(sizeof(int) * size); max = size;top = 0;}int pop();void push(int value);stack & operator=(stack & rightValue); };//栈的容量增倍void stack::inflate(){int index, *tp;tp = (int *)malloc(sizeof(int) * max * 2); for(index = 0; index < top; index++){tp[index] = sp[index];}max += max;free(sp);sp = tp;}//出栈int stack::pop(){if(top <= 0)throw 1;return sp[--top];}//入栈void stack::push(int value){if(top == max)inflate();sp[top++] = value;}//赋值函数stack & stack::operator=(stack & rightValue){top = rightValue.top;max = rightValue.max;sp = (int *)malloc(sizeof(int) * max);for(int index = 0; index < max; index++){sp[index] = rightValue.sp[index];}return *this;}void main(){stack x(100), y, z;z = y = x;}这里要注意的是赋值函数的返回值是stack &,这是为了实现链式表达式,如z = y = x;。

运算符重载

运算符重载

运算符重载“千里送鹅毛,礼轻情意重”。

在现代社会中,常有人以千里为单位,送贵重的礼物给对方;也有些人以“钱”为单位来回报他人……其实,这两种做法是不合理的。

因为它混淆了两个概念:一是礼物本身,二是礼物所包含的情感。

如果把“千里”换成金钱、或者权势地位呢?还能成立么?答案显然是否定的。

那就是——运算符重载!运算符重载和运算顺序无关吗?当然不是!你可以说这是误导,但是事实上却并非如此。

因为运算符重载后,结果仍旧是原来的数值,只要求出新的运算符即可得到正确的结果。

而且,运算符重载使用起来更加简便快捷,节省时间。

例如:求x=1/2+3/4的值。

若直接写出运算式: x=(1-3/4)/(1/2+3/4)=1/8。

则需要将 x=1/2+3/4分别进行四次乘除运算才能得到最终结果。

假设每次运算均按照运算符优先级排列,第一步: x=1/2+3/4=0,运算符优先级高于等于号(=),故运算符重载后,运算过程变为:x=1/2+3/4=1/8。

第二步: x=1/2+3/4=1/16,运算符优先级低于等于号(=),故运算符重载后,运算过程变为: x=1/2+3/4=1/32。

第三步: x=1/2+3/4=1/64,运算符优先级再度降低,故运算过程变为:x=1/2+3/4=1/128。

第四步: x=1/2+3/4=1/256,运算符优先级继续降低,故运算过程变为: x=1/2+3/4=1/512。

综上所述,运算符重载与运算顺序没有任何联系。

我们都知道,在电脑中,运算符重载是一项十分复杂的工作。

首先,必须根据问题的特点选择适宜的运算符。

其次,应该考虑运算符重载后的运算效率。

同样的问题,采取不同的运算符重载形式,往往会产生截然不同的结果。

例如:求 x=1/2+3/4的值。

若直接写出运算式: x=(1-3/4)/(1/2+3/4)=1/8。

则需要将 x=1/2+3/4分别进行四次乘除运算才能得到最终结果。

假设每次运算均按照运算符优先级排列,第一步: x=1/2+3/4=0,运算符优先级高于等于号(=),故运算符重载后,运算过程变为: x=1/2+3/4=1/8。

运算符重载模板写法

运算符重载模板写法

运算符重载模板写法运算符重载写为成员函数还是全局函数的格式,取决于你所要达到的⽬的。

重载为成员函数,那么该运算符的左边必须是某个类的对象实例。

重载为全局函数,可以⾃定义该运算符的左边是什么东西,右边是什么东西。

左边接受范围是第⼀个参数类型,右边接受范围是第⼆个参数类型。

运算符重载的注意点:⼀些常见的运算符重载模板:#include <iostream>using namespace std;class Point {int x;int y;public:Point(int x1 = 0, int y1 = 0) :x(x1), y(y1) {}Point(const Point& p) :x(p.x), y(p.y) {}// 输⼊输出运算符重载friend ostream& operator<<(ostream& output, const Point& p);friend istream& operator>>(istream& input, Point& p);// 第⼀个const保证了返回值不可被再次修改// 第三个const保证了const变量也能调⽤该操作符,也可保证成员变量不被修改const Point operator+ (const Point &p) const {return Point(x + p.x, y + p.y);}const Point operator- (const Point& p) const {return Point(x - p.x, y - p.y);}Point& operator+= (const Point& p) {x += p.x;y += p.y;return *this;}// 逻辑运算符bool operator== (const Point& p) const {return (x == p.x) && (y == p.y);}bool operator!= (const Point& p) {return (x != p.x) || (y != p.y);}// 负号,取反运算符const Point operator-() const {return Point(-x, -y);}//前置++Point& operator++() {x++;y++;return *this;}//后置++(括号内的int不可省略,不可更改)const Point operator++(int) {Point old = *this;x++;y++;return old;}void info() {cout << "(" << x << "," << y << ")" << endl;}};ostream& operator<<(ostream& output, const Point& p) { output << "(" << p.x << "," << p.y << ")";return output;}istream& operator>>(istream& input, Point& p) {input >> p.x >> p.y;return input;}int main() {Point p1(10, 20);Point p2(20, 30);Point p3;cout << p1 << endl;cin >> p3;cout << p3 << endl;return0;}。

5种重载的运算符及其对应的方法

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]; // 调用下标运算符重载函数```通过重载运算符,可以使得自定义类类型的对象能够以一种直观、简洁的方式与内置类型进行相似的操作。

第十章 运算符重载

第十章 运算符重载

7.赋值运算符
只要是用户定义的类或结构,都应能进行赋值运算,如: Struct S{int a,b; }; S a,b; a=b; //c语言允许如此赋值 对任何类,像拷贝构造函数一样,c++也默认提供赋值运算符,但要区别拷 贝构造函数和赋值运算符: void fn(MyClass& mc) { MyClass newMC=mc; //这是拷贝构造函数 newMC=mc; //这是赋值运算符 } 在拷贝构造函数中,我们碰到深拷贝与浅拷贝的问题,赋值运算符也同样, 什么时候浅拷贝不合适,就应提供赋值运算符。 通常赋值运算符有两部分,第一部分与析构函数类似,在其中取消对象已经 占用的资源。第二部分与拷贝构造函数类似,在其中分配新的资源。
6.转换运算符
转换运算符的声明形式为: operator 类型名( ); 它没有返回类型,因为类型名就代表了它的返回类型。 转换运算符将对象转换成类型名规定的类型。转换时的形式就象强不行的,因为强制转换只 能对基本数据类型进行操作,对类类型的操作是没有定义的。 要防止同一类型提供多个转换路径,它会导致编译出错,例如: class A { void main() { public: B sb; A(B& b); //用B构造A A a=A(sb); //是构造还是转换? //… } }; class B { public: operator A(); //B转换成A //… };
C++规定,运算符中,参数说明都是内部类型时,不能重载。例如不允许声 明: int * operator + (int, int*); 即不允许进行下述运算: int a=5; int *pa=&a; pa=a*pa; //error C++基本数据类型之间的关系是确定的,如果允许定义其上的新操作,那么, 基本数据类型的内在关系将混乱。 C++还规定了“. :: .* .-> ?:”这5个运算符不能重载,也不能创造新运算 符。例如,不允许声明: int operator @(int,int); 或者: int operator :: (int,int);
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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);//声明赋值运算符重载=
//单目运算符重载
point operator ++();//声明运算符重载++
//point operator +(point p);
p1+=p2;
cout<<p1.x<<","<<p1.y<<endl;
//p1=p2;//验证赋值运算符重载*/
//cout<<p1.x<<","<<p1.y<<endl;
/* p1=p2-p3;
cout<<p1.x<<","<<p1.y<<endl;
p1=p2*p3;
cout<<p1.x<<","<<p1.y<<endl;
{
point temp;
temp.x=x+p.x;
temp.y=y+p.y;
return temp;
}
point point::operator -(const point &p)//-运算符重载
{
point temp;
temp.x=x-p.x;
temp.y=y-p.y;
return false;
}
bool point::operator > (const point &p)// >运算符重载
{
if(x>p.x&&y>p.y)
return true;
else
return false;
}
point & point::operator =(const point &p)//赋值运算符重载
return temp;
}
point point::operator *(const point &p)//*运算符重载
{
point temp;
temp.x=x*p.x;
temp.y=y*p.y;
return temp;
}
point point::operator /(const point &p)// /运算符重载
{
x=p.x;
y=p.y;
return *this;
}
point point::operator ++()
{
x++;
y++;
return *this;
}
int main(int argc, char* argv[])
{
//point p4(p);
//cout<<p.x<<","<<p.y<<endl;
int x;
int y;
point()
{
x=0;
y=0;
}
point(x=a;
y=b;
}
point(point &p);//声明拷贝构造函数
//双目运算符重载
point operator +(const point &p);//声明运算符重载+
{
x=p.x;
y=p.y;
cout<<"调用拷贝构造函数!"<<endl;
}
/*point point::operator +(point p)
{
point temp;
temp.x=x+p.x;
temp.y=y+p.y;
return temp;
}
*/
point point::operator +(const point &p)//+运算符重载
//point p(1,2);
//cout<<p.x<<","<<p.y<<endl;
point p1(1,2),p2(2,2),p3(3,2);
p1=p2+p3;//验证双目运算符重载
cout<<p1.x<<","<<p1.y<<endl;
cout<<"*************"<<endl;
point &operator +=(const point &p);
};
point &point::operator +=(const point &p)
{
x+=p.x;
y+=p.y;
return *this;
}
point::point( point &p)//构造拷贝构造函数
printf("%d",p4);*/
getchar();
return 0;
}
// Operator.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include<iostream.h>
#include<stdio.h>
class point
{
public:
相关文档
最新文档