C++中预定义的运算符的操作对象只能是基本数据类型。但实际上,对于许多用户自定义类型(例如类),也需要类似的运算操作。这时就必须在C++中重新定义这些运算符,赋予已有运算符新的功能,使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载,它提供了C++的可扩展性,也是C++最吸引人的特性之一。
运算符重载是通过创建运算符函数实现的,运算符函数定义了重载的运算符将要进行的操作。运算符函数的定义与其他函数的定义类似,惟一的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。运算符函数定义的一般格式如下:
{
<函数体>
}
运算符重载时要遵循以下规则:
(2) 重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中,不能创建新的运算符。
(3) 运算符重载实质上是函数重载,因此编译程序对运算符重载的选择,遵循函数重载的选择原则。
(4) 重载之后的运算符不能改变运算符的优先级和结合性,也不能改变运算符操作数的个数及语法结构。
(5) 运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象一起使用,或者用于用户自定义类型的对象和内部类型的对象混合使用时。
(6) 运算符重载是针对新类型数据的实际需要对原有运算符进行的适当的改造,重载的功能应当与原有功能相类似,避免没有目的地使用重载运算符。
运算符函数重载一般有两种形式:重载为类的成员函数和重载为类的非成员函数。非成员函数通常是友元。(可以把一个运算符作为一个非成员、非友元函数重载。但是,这样的运算符函数访问类的私有和保护成员时,必须使用类的公有接口中提供的设置数据和读取数据的函数,调用这些函数时会降低性能。可以内联这些函数以提高性能。)
成员函数运算符
<函数类型> operator <运算符>(<参数表>)
{
<函数体>
}
当运算符重载为类的成员函数时,函数的参数个数比原来的操作数要少一个(后置单目运算符除外),这是因为成员函数用this指针隐式地访问了类的一个对象,它充当了运算符函数最左边的操作数。因此:
(2) 前置单目运算符重载为类的成员函数时,不需要显式说明参数,即函数没有形参。
(3) 后置单目运算符重载为类的成员函数时,函数要带有一个整型形参。
调用成员函数运算符的格式如下:
<对象名>.operator <运算符>(<参数>)
它等价于
<对象名><运算符><参数>
例如:a+b等价于a.operator +(b)。一般情况下,我们采用运算符的习惯表达方式。
友元函数运算符
friend <函数类型> operator <运算符>(<参数表>)
{
<函数体>
}
当运算符重载为类的友元函数时,由于没有隐含的this指针,因此操作数的个数没有变化,所有的操作数都必须通过函数的形参进行传递,函数的参数与操作数自左至右一一对应。
operator <运算符>(<参数1>,<参数2>)
它等价于
<参数1><运算符><参数2>
例如:a+b等价于operator +(a,b)。
两种重载形式的比较
在多数情况下,将运算符重载为类的成员函数和类的友元函数都是可以的。但成员函数运算符与友元函数运算符也具有各自的一些特点:
(2) 以下一些双目运算符不能重载为类的友元函数:=、()、[]、->。
(3) 类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。
(4) 若一个运算符的操作需要修改对象的状态,选择重载为成员函数较好。
(5) 若运算符所需的操作数(尤其是第一个操作数)希望有隐式类型转换,则只能选用友元函数。
(6) 当运算符函数是一个成员函数时,最左边的操作数(或者只有最左边的操作数)必须是运算符类的一 个类对象(或者是对该类对象的引用)。如果左边的操作数必须是一个不同类的对象,或者是一个内部 类型的对象,该运算符函数必须作为一个友元函数来实现。
(7) 当需要重载运算符具有可交换性时,选择重载为友元函数。
定义格式
返回类型 operator运算符(形式参数表) { 函数体 }
参数个数的限定
非成员函数:
单目运算符:参数表中只有一个参数;
双目运算符:参数表中只有两个参数
成员函数:
单目运算符:参数表中没有参数;
双目运算符:参数表中只有一个参数
不能重载的运算符
1、不能重载的运算符有: ::, ., .*, ?:
2、必须重载为成员函数的运算符: [], (), –>, =
3、在类成员函数中重载运算符是不允许返回引用的,会出现“返回局部变量的地址”警告
4、cout << f1 << f2;
//用重载运算符表示,只能通过友员来实现
//如果要用成员函数,则会有cout.operator<<(const F& f),所以这是不
// 可能的.因此只能用友员来实现,operator<<(cout,f)
// 而cout是ostream型的,因此有以下标准格式.注意不能加const,因为
//cout是要改变的,会改变里的缓冲成员.
ostream& operator<<( /* 不能加const */ ostream& cout, constF&) //输出运算符的标准重载格式.
friend istream& operator>>(istream& is, F& f){ }//输入运算符重载标准格式
//重载运算符完整例子
//双目运算符重载
#include <iostream> using namespace std; class F{ int n; int d; public : F(int n=0, int d=1):n(n),d(d){} friend ostream& operator<<(ostream& os, const F& f){ os << '[' << f.n << '/' << f.d <<']'; return os; } F operator*(const F& o) { return F(n*o.n,d*o.d); } friend F operator/(const F& f1,const F& f2){ return F(f1.n*f2.d,f1.d*f2.n); } friend istream& operator>>(istream& is, F& f){ char ch; is >> f.n >> ch >> f.d; return is; } }; int main() { F f1(3,5),f2(11,7),f; cout << f1 << '*' << f2 << '=' << f1*f2 << endl; cout << f1 << '/' << f2 << '=' << f1/f2 << endl; cout << "Input 2 fractions :"; cin >> f1 >> f2; cout <<"f1=" << f1 << endl; cout << "f2=" << f2 << endl; }
* 单目运算符重载
-友元函数形式,返回类型 operatorX(形参)
使用:X obj ---> operatorX(obj);
-成员函数形式 尽量用成员 返回类型 operatorX(/*无形参*/)
使用: X obj ---> obj.operator();
//单目运算符重载
//把后++,后--当作双目运算符,第二个操作数是整形.
#include <iostream> using namespace std; class A{ int data; public : A(int d=0):data(d){} friend ostream& operator<<(ostream& os,const A& a){ os << a.data; return os; } friend istream& operator>>(istream& is,A& a){ is >> a.data; return is; } friend A& operator++(A& a){ a.data += 10; return a; } A& operator--(){ data -= 10; return *this; } friend A/* 不能用引用 */ operator++(A& a,int){ A old(a); a.data += 1; return old; } A /* 不能用引用 */ operator--(int){ A old(*this); data -= 1; return old; } }; int main() { A a1(50),a2(100); cout << "a1=" <<a1 << endl; cout << "a2=" <<a2 << endl; cout << "++a1=" << ++a1 << endl; cout << "--a1=" << --a1 << endl; cout << "a1++=" << a1++ << endl; cout << "a1=" <<a1 << endl; cout << "a2--=" << a2-- << endl; cout << "a2=" <<a2 << endl; }
运算符重载提供了一个自己规定运算符式作方式的方法,至少有一个操
作数是自定义类型的.基本类型我们是规定不了的.
强制类型转换:类型(数据) --> (不必写返回类型,因为始终与后面的类
型是相同的) operator类型(无形参) 只能写成成员函数,不能是友员.
#include<iostream>
using namespacestd;
classA{
intdata;
public:
A(intd=0):data(d){}
operator int(){
returndata;
}
operator bool(){
returndata!=0;
}
operator char(){
return(char)data;
}
};
intmain()
{
A a1(65),a2(200);
cout << "a1="<< (char)a1 << endl;
intd=a2;
if(a2)
cout << "good"<< endl;
}
对自定义类型的对象,使用运算符时,总是调用相应的运算符函数
三目运算符不能重载.
等号是双目运算符也可重载,它也只能是成员.
还有点号('.')不能重载.
双冒号(::)不能重载.
sizeof(类型)没法重载.
#号不是运算符,无所谓重载.
'= () [] -> 类型转换'只能是成员函数来重载,其它的随便,我们建议尽量
使用成员函数来写,有点只能用友元,比如输入输出.
==================================================
+ 双目运算符重载
- 友元形式:返 operator符号(形1,形2)
- 成员形式:返 operator符号(形)
+ 单目运算符重载
- 友元: 返 operator符号(形参)
- 成员: 返 operator符号()
+ 特例
- 加加
- 先加加
- 后加加 返回 operator符号(形,int)
- 减减
- 先减减
- 后减减