第7章 运算符重载

Time Time::operator +(Time& time) { int h,m,s; s=time.seconds+seconds; m=time.minutes+minutes+s/60; h=time.hours+hours+m/60; Time result(h,m%60,s%60); return result; } void Time::gettime() { cout<<hours<<":"<<minutes<<":"<<seconds<<endl; } void main( ) { Time t1(8,51,40),t2(4,15,30),t3; t3=t1+t2; t3.gettime(); } 输出结果为： 13：7：10
返回首页
表7-1 C++可以重载的Βιβλιοθήκη Baidu算符
表7-2 C++不能被重载的运算符
运算符重载的规则如下：



（1）C++中的运算符除了少数几个以外，全部 可以重载，而且只能重载已有的这些运算符。 （2）重载之后运算符的优先级和结合性都不会 改变。 （3）运算符重载是针对新类型数据的实际需要， 对原有运算符进行适当的改造。
例7-4：下面程序修改了例7-2，将操作符重载为友元函数实现。 #include <iostream.h> class Time { public: Time(){ hours=0;minutes=0;seconds=0;} //无参构造函数 Time(int h, int m,int s) //重载构造函数 { hours=h; minutes=m; seconds=s; } friend Time operator +(Time&,Time&); //重载运算符为友元 函数形式 void gettime( ); private: int hours,minutes,seconds; };
如同 “ ++ ”运 算符有前缀和后缀两种使用形式一样， “++”和“--”重载运算符也有前缀和后缀两种运算符 重载形式，以“ ++ ”重载运算符为例，其语法格式如 下： <函数类型> operator ++（）; //前缀运算 <函数类型> operator ++（int）; //后缀运算 使用前缀运算符的语法格式如下： ++<对象>;

Increase & operator++(Increase & a) { a.value++; return a; } Increase operator++(Increase& a, int) { Increase temp(a); 保存原有对象值 a.value++; return temp; } void main() { Increase n(20); n.display();
使用后缀运算符的语法格式如下： <对象>++;
例7-5：成员函数重载示例。 #include <iostream.h> class Increase{ public: Increase(int x):value(x){} Increase & operator++(); //前增量 Increase operator++(int); //后增量 void display(){ cout <<"the value is " <<endl; } private: int value; }; Increase & Increase::operator++() { value++; //先增量 return *this; //再返回原对象
(n++)++; 作对临时对象进行 n.display(); } 此程序的运行结果为： the value is 20 the value is 20 the value is 21 the value is 22 the value is 24 the value is 25
// 第二次增量操
例7-6：友元函数重载示例。 #include <iostream.h> class Increase{ public: Increase(int x):value(x){} friend Increase & operator++(Increase & ); //前增量 friend Increase operator++(Increase &,int); //后增量 void display(){ cout <<"the value is " <<value <<endl; } private: int value; };
7.1 运算符重载概述


运算符重载是对已有的运算符赋予多重含义， 同一个运算符作用于不同类型的数据导致不同 类型的行为。 运算符重载的实质就是函数重载。在实现过程 中，首先把指定的运算表达式转化为对运算符 函数的调用，运算对象转化为运算符函数的实 参，然后根据实参的类型来确定需要调用的函 数，这个过程是在编译过程中完成的。
例7-1：以成员函数重载运算符重载两字符串加法。 #include <iostream.h> #include <string.h> class String { char name[256]; public: String(char* str) { strcpy(name,str);} String(){} ~String(){} String operator+(const String&); void display() { cout<<"The string is:"<<name<<endl;} };
//显示临时对象值 //显示原有对象
// 第二次增量操作对
返回本节
7.4 二元运算符重载


对于双目运算符，一个运算数是对象本身的数 据，由 this 指针给出，另一个运算数则需要通 过运算符重载函数的参数表来传递。下面分别 介绍这两种情况。 对于双目运算符B，如果要重载B为类的成员函 数，使之能够实现表达式“oprd1 B oprd2”， 其中 oprd1 为 A 类的对象，则应当把 B 重载为 A 类的成员函数，该函数只有一个形参，形参的 类型是 oprd2 所属的类型。经过重载之后，表 达 式 oprd1 B oprd2 就 相 当 于 函 数 调 用 “oprd1.operator B(oprd2)”。

Time operator +(Time& time1,Time& time2) { int h,m,s; s=time1.seconds+time2.seconds; // 计算秒 数 m=time1.minutes+time2.minutes+s/60; // 计算分数 h=time1.hours+time2.hours+m/60; // 计算小时数 Time result(h,m%60,s%60); return result; }
返回本节
7.3 一元运算符重载


类的单目运算符可重载为一个没有参数的非静 态成员函数或者带有一个参数的非成员函数， 参数必须是用户自定义类型的对象或者是对该 对象的引用。 在C++中，单目运算符有++和--，它们是变量自 动增1和自动减1的运算符。在类中可以对这两 个单目运算符进行重载。
返回首页

<<value
} Increase Increase::operator++(int) { Increase temp(*this); //临时对象存放原有对象值 value++; //原有对象增量修改 return temp; //返回原有对象值 } void main() { Increase n(20); n.display(); (n++).display(); //显示临时对象值 n.display(); //显示原有对象 ++n; n.display(); ++(++n); n.display();

bool operator! =(Point); //运算符重载，判断两个对象是否不相同 void operator+ =(Point); //运算符重载，将两个点对象相加 void operator- =(Point); //运算符重载，将两个点对象相减 Point operator+(Point); //运算符重载，相加并将结果放在左 操作数中 Point operator-(Point); //运算符重载，相减并将结果放在左操作数中 int getx() {return x;} int gety() {return y;} void disp() { cout<<"("<<x<<","<<y<<")"<<endl; } }; Point::Point(Point &p) { x=p.x;y=p.y;
//前增量 //再返回原对象
// 通过拷贝构造函数 //原有对象增量修改 //返回原有对象值
(n++).display(); n.display(); ++n; n.display(); ++(++n); n.display(); (n++)++; 临时对象进行 n.display(); } 此程序的运行结果为： the value is 20 the value is 20 the value is 21 the value is 22 the value is 24 the value is 25
返回首页
例7-7：设计一个点类Point，实现点对象之间的各种运算。 #include <iostream.h> class Point { int x,y; public: Point() {x=y=0; Point(int i,int j) {x=i;y=j;} Point(Point &); ~Point() {} void offset(int,int); //提供对点的偏移 void offset(Point); // 重载，偏移量用 Point 类对 象表示 bool operator= =(Point); // 运算符重载，判断两个对象 是否相同
void Time::gettime( ) { cout<<hours<<":"<<minutes<<":"<<seconds<<endl; } void main( ) { Time t1(8,51,40),t2(4,15,30),t3; t3=t1+t2; t3.gettime( ); } 输出结果为： 13：7：10

static char* str; String String::operator+(const String& a) { strcpy(str,name); strcat(str,a.name); return String(str); } void main() { str=new char[256]; String demo1("Visual c++"); String demo2("6.0"); demo1.display(); demo2.display();
String demo3=demo1+demo2; demo3.display(); String demo4=demo3+"Programming."; demo4.display(); delete str; } 此程序的运行结果为： The string is : Visual C++ The string is : 6.0 The string is : Visual C++ 6.0 The string is : Visual C++ Programming.
返回本节
7.2 运算符重载的实现
运算符的重载形式有两种：重载为类的成员函数和重载为 类的友元函数。运算符重载为类的成员函数的语法形式 如下： <函数类型> operator <运算符>（<形参表>） { <函数体>; } 运算符重载为类的友元函数的语法形式如下： friend <函数类型 > operator < 运算符 > （ <形参表 >） { <函数体>; } 返回首页
例7-2：下面程序定义一个Time类用来保存时间（时、分、秒），通过重 载操作符“+”实现两个时间的相加。 #include <iostream.h> class Time { public: Time(){ hours=0;minutes=0;seconds=0;} //无参构造函数 Time(int h, int m,int s) //重载构造函数 { hours=h; minutes=m; seconds=s; } Time operator +(Time&); // 操作符重载为成员函数，返回结 果为Time类 void gettime(); private: int hours,minutes,seconds; };