运算符重载综合实例

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);//声明赋值运算符重载=

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、双目运算符的重载

第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”参数，无实际意义，只是与第一个函数区别开来。

实验9 运算符重载（1）一、实验目的1、掌握运算符重载的概念；二、实验内容1、用成员函数重载运算符，使对整型的运算符=、+、-、*、/ 适用于分数运算。

要求：（1）输出结果是最简分数（可以是带分数）；（2）分母为1，只输出分子。

过程分析：1) 定义一个类Complex，在公共部分定义构造函数，输出函数，和运算符=、+、-、*、/的重载函数，此处运算符=可以使用系统默认的运算符=的函数。

在私有部分定义两个数据成员x和y。

2) 定义构造函数时先在类里面声明构造函数，并对参数初始化，再在类外定义构造函数，分别给x和y初始化。

3) 定义输出函数print（），对分数进行化简，采用的方法是利用for循环，分子分母均除以i，i从2增加到分子分母中更小的一个数后截止，每次增加1，在利用if else 语句，如果分子分母除以i均被整除，则说明这是的i是分子分母的公约数，分子分母均赋值为整除后的结果值，同时将i重新赋值为2，因为再求公约数是要再从i=2开始循环；否则i++，表示及进入下一个循环。

化成最简形式后在利用if else语句，判断最终结果值的分母是否为1，如果不是，则输出分数，否则只输出分子。

4) 定义运算符+重载函数，参数作为+的右操作对象，调用函数的对象作为左操作对象，在函数里定义一个Complex对象d，将左右操作对象的分数相加，将得到的结果的分子和分母分别赋给d的分子和分母，返回类的对象d。

5) 定义运算符-重载函数，参数作为-的右操作对象，调用函数的对象作为左操作对象，在函数里定义一个Complex对象d，将左右操作对象的分数相减，并将得到的结果的分子和分母分别赋给d的分子和分母，返回类的对象d。

6) 定义运算符*重载函数，参数作为*的右操作对象，调用函数的对象作为左操作对象，在函数里定义一个Complex对象d，将左右操作对象的分数相乘，并将得到的结果的分子和分母分别赋给d的分子和分母，返回类的对象d。

北华航天工业学院计算机系 安志远 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 ;
{
// 相对于该类定义的操作
} ➢ 一个运算符被重载后，原有意义没有失去，只是定义了相对 一特定类的一个新运算符

希望本文所述对大家的C#程序设计有所帮助。
这篇文章主要给大家介绍了关于c如何给枚举类型增加一个描述特性的相关资料文中通过示例代码介绍的非常详细对大家的学习或者工作具有一定的参考学习价值需要的朋友们下面来一起学习学习吧
C#运 算 符 重 载 用 法 实 例 分 析
本文实例讲述了C#运算符重载用法。分享给大家供大家参考。具体分析如下：
public class Plane { public virtual double TopSpeed() { return 300.0D;} public static bool operator>(Plane one, Plane two) { return one.TopSpeed() > two.TopSpeed(); } public static bool operator<(Plane one, Plane two) { return one.TopSpeed() < two.TopSpeed(); } } class Jet : Pe TopSpeed() { return 900.0D; } public override string ToString() { return "I'm a Jet"; } } class Airport { [STAThread] static void Main(string[] args) { Plane plane = new Jet(); Console.WriteLine("plane's top speed: {0}",plane.TopSpeed()); Jet jet = new Jet(); Console.WriteLine("jet's top speed: {0}",jet.TopSpeed()); Console.WriteLine("Plane > Jet = {0}", plane > jet); Console.ReadLine(); } }

▪ 有关友元函数重载单目运算符后缀方式的表示方法，将在后 面介绍
▪ 说明
运算符重载函数 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; ▪}

定义一种简化旳复数类complex: class complex { public: double real,imag; complex(double r=0,double i=0) { real=r; imag=i;}
}; 若要把类complex旳两个对象com1和com2加在一起,下面旳语句
是不能实现旳: main() { complex com1(1.1,2.2),com2(3.3,4.4),total; total=com1+com2; //错误 //… return 0; }
第7章 运算符重载
7.1为何引入运算符重载
int sum_i; float sum_f; int i1=123， i2=456; float f1=3.45， f2=56.78; sum_i= i1+i2;//两个整数相加 cout<<"i1+i2 ="<< sum_i; sum_f= f1+f2; //两个浮点数相加 cout<<"f1+f2 ="<< sum_f; sum_f= i1+i2+f1; //进行类型转换后相加 cout<<"i1+i2+f1 ="<<sum_f;
. .* ：： ？Sizeof() ?:不能重载
（3）运算符重载后，不能变化运算符操作数旳
个数、优先级、结合性、语法构造。
（4）不能定义新旳运算符
7.3.1 单目运算符“++”和“--”旳重载 在C++中,能够经过在运算符函数参数表中是否插 入关键字int来区别前缀和后缀这两种方式。 例如：重载单目运算符++

一、为什么要重载操作符1．操作符重载就是把操作符比如+，-，*，/这些运算符赋于新的意义。

2．操作符重载的目的：C++有许多内置的数据类型，包括int，char，double等，每一种类型都有许多运算符，例如加+，减，乘，除等。

当用户定义了类的对象时，两个对象之间是不能进行这些操作的，比如hyong类的对象a+b，这样的语句如果没有重载+运算符就会出错。

但C++允许用户把这些运算符添加到自已的类中以方便类对象之间的运算就像内置类型的运算一样方便，比如对象a+b这样就很明白更容易懂，当然也可以在类中定义一个对象间相加的函数，比如 a.add(b)调用函数add()以实现两个对象a和b相加，但是这条语句没有比a+b更容易让人理解。

3．怎样实现操作符重载：要实现操作符重载就要使用操作符重载函数，操作符重载函数用关见字operator实现，其形式为：反回类型 operator 操作符 (参数列表){}。

操作符重载函数是一个函数，只不过这个函数的函数名为operator再加上后面要重载的操作符而已，比如要重载+号，则： hyong operator +(hyong m){}这就声明了一个反回类型为hyong的操作符函数，其函数名为operator +4．作为类的成员和友元或者独立于类的区别当操作符重载函数作为类的成员函数时，操作符重载函数的参数会比作为友元或者独立于类的操作符重载函数少一个参数，因为操作符重载类成员函数把调用该函数的第一个类的对象作为函数的第一个参数，也就是隐含的this指针指向调用该函数的第一个对象，所以会少一个参数。

5．调用操作符重载函数的方式：5.1 调用类中的操作符重载函数的方法：当调用类中定义的操作符重载函数时最左边的对象是调用操作符重载函数的对象。

比如在类hyong中重定义的+操作符 hyong operator +(hyong m){}，有类hyong的对象m和n则调用操作符重载函数的方法有m+n和m.operator +(n)，前一条语句会自动转换为后面这条语句，且m+n的表达式中最左边的对象是调用操作符重载函数的对象，而最右边的那个将被作为参数传送。

c++运算符重载经典举例算法运算符重载// A class Complex, and its arithmetic operations.#include <iostream.h>#include <stdlib.h>#include <conio.h>class Complex{public:Complex( float r = 0, float i = 0 ) : _r( r ), _i( i ) {}void print( ) const;friend const Complex operator+(const Complex& x, const Complex& y);friend const Complex operator-(const Complex& x, const Complex& y);friend const Complex operator*(const Complex& x, constComplex& y);friend const Complex operator/(const Complex& x, const Complex& y);private:float _r;float _i;};void Complex::print( ) const{cout<<"_r = " <<_r<<endl;cout<<"_I = "<<_i<<endl;}inline const Complex operator+(const Complex& x, const Complex& y){return Complex( x._r + y._r, x._i + y._i);}inline const Complex operator-(const Complex& x, const Complex& y){return Complex(x._r - y._r, x._i - y._i);}inline const Complex operator*(const Complex& x, const Complex& y){return Complex( x._r * y._r - x._i * y._i, x._r * y._i + x._i * y._r);}const Complex operator/(const Complex& x, const Complex& y) {if (y._r == 0 && y._i == 0){exit(1);}float den = y._r * y._r + y._i * y._i;Complex aComplex((x._r * y._r + x._i * y._i) / den,(x._i * y._r - x._r * y._i) / den);//return Complex((x._r * y._r + x._i * y._i) / den, // (x._i * y._r - x._r * y._i) / den);return aComplex;}int main( ){Complex x(2, 3), y(-1, 3);cout << "x is "; x.print( );cout << "y is "; y.print( );cout << "x + y is ";(x + y).print( );cout << "x - y is ";(x - y).print( );cout << "x * y is ";(x * y).print( );cout << "x / y is ";(x / y).print( );return 0;}引用报告回复sdb新手上路UID 1050精华 0积分 0帖子 24阅读权限 10注册 2007-4-2状态 离线 #2 使用道具 发表于 2007-7-11 14:52 资料 个人空间 短消息 加为好友 重载为成员函数 // A class Complex, and its arithmetic operations. #include <iostream.h>#include <stdlib.h>#include <conio.h>class Complex{public:Complex( float r = 0, float i = 0 ) : _r( r ), _i( i ) {}void print( ) const;const Complex operator+(const Complex& y); const Complex operator-(const Complex& y);const Complex operator*(const Complex& y);const Complex operator/(const Complex& y);private:float _r;float _i;};void Complex::print( ) const{cout<<"_r = " <<_r<<endl;cout<<"_I = "<<_i<<endl;}inline const Complex Complex::opearator+(const Complex& y){return Complex( _r + y._r, _i + y._i);}inline const Complex Complex::operator-(const Complex& y){return Complex(_r - y._r, _i - y._i);}inline const Complex Complex::operator*(const Complex& y){return Complex( _r * y._r - _i * y._i, _r * y._i + _i * y._r);}const Complex Complex::operator/(const Complex& y) {if (y._r == 0 && y._i == 0){exit(1);}float den = y._r * y._r + y._i * y._i;Complex aComplex((_r * y._r + _i * y._i) / den,(_i * y._r - _r * y._i) / den);//return Complex((x._r * y._r + x._i * y._i) / den, // (x._i * y._r - x._r * y._i) / den);return aComplex;}int main( ){Complex x(2, 3), y(-1, 3);cout << "x is "; x.print( );cout << "y is "; y.print( );cout << "x + y is ";(x + y).print( );cout << "x - y is ";(x - y).print( );cout << "x * y is ";(x * y).print( );cout << "x / y is ";(x / y).print( );return 0;}[本帖最后由sdb 于2007-7-11 14:58 编辑]引用报告回复sdb新手上路UID 1050精华 0积分 0帖子 24阅读权限 10注册 2007-4-2状态 离线 #3 使用道具 发表于 2007-7-11 14:53 资料 个人空间 短消息 加为好友 重载下标操作符 // Class Vector is to demonstrator overloading the subscript operator#include <iostream.h>#define size 5class Vector{private:int rep[size];public:const int& operator[ ](int index) const{return rep[index];}int& operator[ ](int index){return rep[index];}};// Using the overloaded operator [ ], this function does not access// the private member of class Vectorostream& operator<<(ostream& out, const Vector& a) {for (int i = 0; i < size; ++i){out << a <<endl;//out<<a.rep;// the const version of operator[ ] is used }return out;}int main( ){Vector x;cout << "Enter " << size << " integers.\n";for (int i = 0; i < size; ++i){cin >> x;} // the non-const version of operator [ ] is usedconst Vector y = x;cout <<"y = ";cout << y;x[0] = 1; // Non-const version againcout <<"y = ";cout<< y;cout <<"x = ";cout<<x;return 0;////////////////////////////////////////////////////// This example defines the second version of the class Vector, which has overloaded operators =, // [ ] and <<.#include <iostream.h>class Vector{public:Vector(int s, int an_array[ ]); // a constructor~ Vector( ){delete [ ] rep;} // a destructorint get_size( ) const {return size;} // an accessorconst Vector& operator=(const Vector& x);int& operator[ ](int index) { return rep[index]; }const int& operator[ ](int index) const { return rep[index];}private:int *rep;int size;};// A constructor initializing the members of rep by the parameter an_arrayVector:: Vector(int s, int an_array[ ]) : size(s), rep( new int[s] ){for (int i = 0; i < size; ++i){rep = an_array;}}// Note that the initializer uses new int[s] to initialize rep, but not new int[size]// because the initializers may not be evaluated in the specified order.const Vector& Vector::operator=(const Vector& x){if( this != &x){size = x.size;delete [ ] rep; // clean up the old one.rep = new int[size];for (int i = 0; i < size; ++i){rep = x.rep;}}return *this;}ostream& operator<<(ostream& out, const Vector& x) {int s = x.get_size( );for (int i = 0; i < s; ++i){out << x<<endl;}return out;}int main(){int array[5] = { 1, 2, 3, 4, 5 };Vector v1( 5, array );cout<<"v1= "<<v1<<endl;Vector v2 = v1;cout<<"v2= "<<v2<<endl;v1[4] = 100;cout<<"v2= "<<v2<<endl;return 0;}[本帖最后由sdb 于2007-7-11 14:58 编辑]引用报告回复sdb新手上路UID 1050精华 0积分 0帖子 24阅读权限 10注册 2007-4-2状态 离线 #4 使用道具 发表于 2007-7-11 14:54 资料 个人空间 短消息 加为好友 输出符重载 // To illustrate the dangers of the default assignment with dynamic memory allocation.#include <iostream.h>#include <string.h>const int MAX_CHAR = 10;class Account{friend ostream& operator<<(ostream& os, Account &b);public:Account ( char* name ="unknown", char* mr = "Miss", float y=0.0){title= new char[strlen(mr)+1];strcpy(title,mr);strcpy(owner, name);balance = y;}void changetitle(char* newname){if( strlen(newname) > strlen(title) ) {delete []title;title = NULL;title = new char[strlen(newname)+1];strcpy( title, newname );}else{strcpy(title, newname);}}void changename(char* newname){strcpy( owner, newname );}~Account (){delete [ ] title;}private:char* title;char owner[MAX_CHAR];float balance;};ostream& operator<< (ostream& os, Account &b){os <<"who:"<< b.title << " " << b.owner <<" how much="<<b.balance<<"\n";os << endl;return os;}void main(){Account acc("Lou","Mr", 100);Account acc1;cout << acc;cout << acc1;acc1=acc;cout << acc1;acc1.changename("jean");cout << acc1;cout<<acc;acc1.changetitle("Dr.");cout << acc1;cout<<acc;}引用报告回复sdb新手上路UID 1050精华 0积分 0帖子 24阅读权限 10注册 2007-4-2状态 离线 #5 使用道具 发表于 2007-7-11 14:59 资料 个人空间 短消息 加为好友 容器的构造 // The following is another version of the class Vector with three constructors, a destructor (which // is the same as in the previous example), an overloaded assignmentoperator , an overloaded// output operator , and an overloaded equality operator .#include <iostream.h>class Vector{private:int *rep;int size;void clone(const Vector& a);void dispose( );public:Vector(int s=0);// a default constructor initializing all members of repto 0 if s is not 0.Vector(int *, int);// a constructor creates a Vector object from an ordinary arrayVector(const Vector& v); // a copy constructor~Vector( ) {dispose( );} // a destructor int get_size( ) const {return size;} // an accessorconst Vector& operator=(const Vector& x);int& operator[ ](int index) {return rep[index];}const int& operator[ ](int index) const {return rep[index];}};void Vector::clone(const Vector& a){this->size = a.size;rep = new int[size];for (int count = 0; count < size; ++count)rep[count] = a[count];}void Vector::dispose( ){ delete [ ] rep; }Vector::Vector(int s) : size(s){if (size <= 0){ rep = NULL; }else{rep = new int[size];for (int count = 0; count < size; ++count){ rep[count] = 0; }}}Vector::Vector(int * a, int s) : size(s), rep(new int[s]) {for (int count = 0; count < size; ++count){ rep[count] = a[count]; }}Vector::Vector(const Vector& v){ clone(v); }//for example: Vector a, v; a.=(v);const Vector& Vector::operator=(const Vector& x) {if ( this != &x ){delete []rep;this->size = a.size;rep = new int[size];for (int count = 0; count < size; ++count)rep[count] = a[count];}return *this;}// overloading operator <<, not a friend function ostream& operator<<(ostream& out, const Vector& x) {int s = x.get_size( );for (int i = 0; i < s; ++i){out << x<<endl;}out << endl;return out;}bool operator==(const Vector& a, const Vector& b) {bool yes = true;if (a.get_size( ) != b.get_size( )){ yes = false; }else{int s, index = 0;s = a.get_size( );while (index < s && a[index] == b[index]){ ++index; }if (index < s){ yes = false; }}return yes;}引用报告回复sdb新手上路UID 1050精华 0积分 0帖子 24阅读权限 10注册 2007-4-2状态 离线 #6 使用道具 发表于 2007-7-11 15:01 资料 个人空间 短消息 加为好友 类型转换 // The following example demonstrates when a constructor or a destructor is called:#include <iostream.h>class Demo{private:int i;public:// default constructorDemo(int n = 0) : i(n) {cout << "default constructor called\n";}// copy constructor: for example Demo b(a);Demo(const Demo& a){i = a.i;cout << "copy constructor called\n";}// destructor~Demo( ) {cout << "destructor called\n";}// assignment operatorconst Demo& operator=(const Demo& a){this->i = a.i;cout << "assignment operator used\n";return *this;}Demo& set_value(int n) {i = n; return *this;}// returning an object to facilitate function chainint get_value( ) {return i;}};Demo foo(Demo x)// pass by value to invoke copy constructor{Demo d;return d; // returning a localobject by value}int main( ){Demo a(2);{Demo b;b = foo(a);}Demo c = a;return 0;}引用报告回复sdb 新手上路U I D 1050精华 0积分 0帖子 24阅读权限10 注册2007-4-2状态 离线#7使用道具 发表于 2007-7-11 15:02 资料 个人空间 短消息 加为好友字符串的构造// Constructor type conversion#include <iostream.h>#include <string.h>class String{int len;char * rep;public:String( ) : len(0)// default constructor {rep = new char[1];strcpy(rep, "");}String(char * s)// another constructor {if (!s){len = 0;s = new char[1];strcpy(rep, "");}else{len = strlen(s);rep = new char[len + 1];strcpy(rep, s);}}String(const String& str) : len(str.len), rep(new char[str.len + 1]) // copy constructor{strcpy(rep, str.rep);}~String( ) // destructor{delete [ ] rep;}friend void print(const String& s); };void print(const String& s){cout << s.rep << " ";return;}int main( ){char * a = "first string";print(a);print("second string");String b = "bad initialization"; print(b);return 0;}引用报告回复sdb新手上路UID 1050精华 0积分 0帖子 24阅读权限 10注册 2007-4-2状态 离线 #8 使用道具 发表于 2007-7-11 15:04 资料 个人空间 短消息 加为好友 // The following program defines four arrays of objects in class Item. The first array initializes the // objects by calling the constructor explicitly. The second array uses the type conversion feature // of the constructor . Thethird array and the fourth arrays use the default values of the// constructor .#include <iostream.h>#include <string.h>class Item{char * name;int id;public:Item( ) : name(new char[1]), id(0) {strcpy(name, "");} Item(char * s, int i = 0) : id(i), name(new char[strlen(s) + 1]){ strcpy(name, s); }void set(char * s, int i){if( name ) delete [ ] name;name = new char[strlen(s) + 1];strcpy(name, s);id = i;}~Item( ) {delete [ ] name;}friend ostream& operator << (ostream& out, const Item& i);};ostream& operator << (ostream& out, const Item& i) {out << endl << << i.id << endl;return out;}int main( ){Item stationary[2] = {Item("pen", 1), Item("notebook", 2)};Item meat[3] = {"pork", "beef", "chicken"};Item nothing[2];Item * ptr = new Item[3];for (int count = 0; count < 2; ++count){ cout << stationary[count]; }for (int count = 0; count < 3; ++count){ cout << meat[count]; }for (int count = 0; count < 2; ++count){nothing[count].set("array", count + 1);cout << nothing[count];}for (int count = 0; count < 3; ++count){ptr[count].set("dynamic array", count + 1);cout << ptr[count];}delete [ ] ptr;return 0; }。

在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++中的运算符除了少数⼏个之外，全部可以重载，⽽且只能重载C++中已有的运算符。

不能重载的运算符只有五个，它们是：成员运算符“.”、指针运算符“*”、作⽤域运算符“：：”、“sizeof”、条件运算符“？：”。

②、重载之后运算符的优先级和结合性都不会改变。

③、运算符重载是针对新类型数据的实际需要，对原有运算符进⾏适当的改造。

⼀般来说，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时⾄少要有⼀个操作对象是⾃定义类型。

运算符重载为类的成员函数的⼀般语法形式为：函数类型 operator 运算符（形参表）{函数体；}⼲脆将⼀些运算符重新列出下⼀下：可以⽤作重载的运算符:算术运算符：+,-,*,/,%,++,--;位操作运算符：&,|,~,^,＜＜,＞＞逻辑运算符：!,&&,||;⽐较运算符：＜,＞,＞=,＜=,==,!=;赋值运算符：=,+=,-=,*=,/=,%=,&=,|=,^=,＜＜=,＞＞=;其他运算符：[],(),-＞,,(逗号运算符),new,delete,new[],delete[],-＞*下列运算符不允许重载：.,.*,::,?:（上⾯也说了的）下⾯给例⼦Boxoperator+(const Box&, const Box&);声明加法运算符⽤于把两个 Box 对象相加，返回最终的 Box 对象。

⼤多数的重载运算符可被定义为普通的⾮成员函数或者被定义为类成员函数。

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;。

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

//对于成员函数重载运算符而言，双目运算符的参数表中仅有一个参数，而单目则无参数。

同样的是重载，由于友元函数没有this指针，因此//在参数的个数上会有所区别的。

//***对运算符”+“的重载***/*#include<iostream>using namespace std;class trans{public:trans(int x=100){cha=x;}int operator+(int b);int cha;};int trans::operator+(int b){return cha-b;}int main(){trans t(90);int sum=10;sum=t.operator+(sum); //重载运算符”+“的显式调用//sum=t+sum; 重载运算符“+”的隐式调用cout<<sum<<endl;system("pause");return 0;}*///说明：在作为成员函数的情况下，对”+“运算符的重载所包含的参数个数只能有零个或一个。

//*** 对运算符”++“的重载一***//运算符"++"前置的情况/*#include<iostream>using namespace std;class trans{public:trans(int x=100){cha=x;}int operator++();int cha;};int trans::operator++(){return cha-1;}int main(){trans t(90);int sum;//sum=t.operator++(); //重载运算符”++“的显式调用sum=++t; //重载运算符“++”的隐式调用cout<<sum<<endl;system("pause");return 0;}*///*** 对运算符"++"的重载二***//运算符"++"后置的情况/*#include<iostream>using namespace std;class trans{public:trans(int x=100){cha=x;}int operator++(int);int cha;};int trans::operator++(int){return cha-9;}int main(){trans t(100);int sum;int arg; //仅在显式调用用到该参数。

简述运算符重载的规则。

篇一：运算符重载是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. 逻辑运算符重载逻辑运算符包括条件运算符和逻辑非运算符。

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

• 三目运算符有三个操作数参与运算，三目运算符只包 括问号运算符，行例如z?x:y
• 不确定目数运算符是操作数个数不确定，可依据需要 重载为不同的操作数个数，不确定目数运算符只包括 函数调用运算符“〔〕”
• 在C++中只能重载单目运算符、双目运算符及不确定
4.2.1 运算符重载为类的成员函数
• 通过该类的对象来调用运算符函数，由于对象本身将作为一 个操作数，因此要求第一个操作数的类型为用户自定义类， 参数表中的参数个数比操作数个数少一。
2+3i
6-5i
8-2i
请按任意键连续. . .
运算符重载
• 能否像实数的加法运算一样，直接用加号“+”来实 现复数运算呢？例如在程序中直接用“z3=z1+z2”进 展运算，这需要对运算符“+”进展重载。
• 运算符重载的方法在实质上就是定义一个重载运算符 的函数，在执行被重载的运算符时，系统将调用此函 数实现相应的运算。运算符重载本质就是函数的重载。
else if (image == 0) cout << real << endl;
// 虚部为0
else cout << real << “+” << image << “i” << endl; // 虚部为负
}
……
例4.1 通过函数实现复数相加例如。
……
Complex Complex::Add(const Complex &z1,const Complex &z2)
• 单目运算符的运算符在一般状况下重载为类的成员函数时，形参表为 • 空，以当前对象〔即调用该运算符函数的对象〕作为运算符唯一的操 • 作数。