1、除了函数调用符之外，重载操作符的形参数目(包括成员函数的隐式this指针)与操作符的操作数目相同。函数调用操作符可以接受任意数目的操作数。
表1 可重载的操作符名
|
+ |
- |
* |
/ |
% |
^ |
|
& |
| |
~ |
! |
, |
= |
|
< |
> |
<= |
>= |
++ |
-- |
|
<< |
>> |
== |
!= |
&& |
|| |
|
+= |
-= |
/= |
%= |
^= |
&= |
|
|= |
*= |
<<= |
>>= |
[] |
() |
|
-> |
->* |
new |
new[] |
delete |
delete [] |
表2 不能重载的操作符
|
:: |
.* |
. |
?: |
不能通过连接其他合法符号来创建任何新的操作符。
2、重载操作符必须具有一个类类型/枚举类型操作数。不能改变内置操作符原有的优先级和结合性。除了函数调用操作符operator()之外，重载操作符时使用默认实参是非法的。
3、作为成员函数的操作符有一个隐含的this指针，限定为第一个操作数。
4、一般将算术和关系操作符定义为非成员函数，而将赋值操作符定义为成员。
5、加返回右值，而复合赋值返回对左操作数引用。
6、重载的设计
1）不要重载具有内置含义的操作符
赋值操作符(可定义自己的)、取地址操作符和逗号操作符对类类型操作数有默认含义。内置逻辑与（&&）和逻辑或（||）操作符使用短路求值，如果重新定义该操作符，将失去操作符的短路求值特征。
2）用作关联容器键类型的类就有<操作符，顺序容器中应定义==操作符。为了相应算法操作的方便。如sort,find等。
3）总结
• 赋值（=）、下标（[]）、调用（()）和成员访问箭头（->）等操作符必须定义为成员，将这些操作符定义为非成员函数将在编译时标记为错误。
• 像赋值一样，复合赋值操作符通常应定义为类的成员，与赋值不同的是，不一定非得这样做，如果定义非成员复合赋值操作符，不会出现编译错误。
• 改变对象状态或与给定类型紧密联系的其他一些操作符，如自增、自减和解引用，通常就定义为类成员。
• 对称的操作符，如算术操作符、相等操作符、关系操作符和位操作符，最好定义为普通非成员函数。
7、重载操作符的定义示例
1）输出<<
示例
ostream& operator<<(ostream& os, const ClassType *object)
{
//...
os << //...
return os;
}
通常所做格式化应尽量少。
IO操作符必须为非成员函数，否则会出现 item << cout的这种不自然情形。
2）输入>>
输入操作符必须处理错误和文件结束的可能性。
示例
istream& operator>>(istream& in, Sales_Item& s)
{
double price;
in >> s.isbn >> s.units_sold >> price;
if (in)
s.revenue = s.units_sold * price;
else
s = Sales_item(); //input failed:reset object to default state
return in;
}
通常输入操作符仅需设置failbit，设置eofbit意思是文件耗尽，设置badbit指出流被破坏。
3）算术操作符和关系操作符
示例
Sales_item operator+(const Salse_item& lhs, const Salse_item& rhs)
{
Sales_item ret(lhs);
ret += rhs; //非常好用的方法
return ret;
}
4）相等操作符与不等操作符一起实现
示例
inline bool
operator==(const ClassType &lhs, const ClassType &rhs)
{
return ...
}
inline bool
operator!=(const ClassType &lhs, const ClassType &rhs)
{
return !(lhs == rhs);
}
5）一般而言，赋值操作符与复合赋值操作符应返回左操作数的引用(*this)。
6）下标操作符
定义两个版本：一个为非const成员并返回引用，另一个为const成员并返回const引用。
示例
class Foo
{
public:
int &operator[](const size_t);
const int &operator[](const size_t) const;
//...
private:
vector<int> data;
};
int& Foo::operator[](const size_t index)
{
return data[index]; //注意，这里没有进行下标越界检查
}
const int& Foo::operator [](const size_t index) const
{
return data[index];
}
7）成员访问操作符
同样，也是两个版本。
重载箭头操作符必须返回指向类类型的指针，或返回定义了自己的箭头操作符的类类型对象(或引用)。
示例
#include "iostream"
#include "stdio.h"
using namespace std;
class ScreenPtr;
class Screen //用于ScreenPtr中操作对象的类
{
public:
Screen()
{
cout << "In Screen" << endl;
}
void display()
{
cout << "In Screen Display" << endl;
}
};
class ScrPtr //智能指针，用来管理ScreenPtr类中要操作对象的类的指针
{
friend class ScreenPtr;
Screen *sp;
size_t use;
ScrPtr(Screen *p):sp(p), use(1) {}
~ScrPtr()
{
delete sp;
}
};
class ScreenPtr
{
public:
ScreenPtr(Screen *p):ptr(new ScrPtr(p)) {}
ScreenPtr(const ScreenPtr &orig):ptr(orig.ptr) //复制构造函数
{
++ptr->use;
}
ScreenPtr& operator=(const ScreenPtr&){}
~ScreenPtr()
{
if (--ptr->use == 0)
{
delete ptr;
}
cout << "In ScreenPtr" << endl;
}
public:
Screen& operator*()
{
return *ptr->sp;
}
Screen* operator->()
{
return ptr->sp;
}
const Screen& operator*() const
{
return *ptr->sp;
}
const Screen* operator->() const
{
return ptr->sp;
}
private:
ScrPtr *ptr;
};
int main()
{
Screen *myscreen = new Screen();
ScreenPtr p(myscreen);
p->display();
return 0;
}
说明：point->action();
1.If point is a pointer to a class object that has a member named action , then
the compiler writes code to call the action member of that object.
2.Otherwise, if point is an object of a class that defines operator-> , then
point->action is the same as point.operator->()->action . That is, we execute
operator->() on point and then repeat these three steps, using the result of
executing operator-> on point .
3. Otherwise, the code is in error.