操作符重载

重载一个操作符，就是编写一个函数，当类对象按预先规定的方式使用这个运算符时，该函数就被调用。

 

下面列出重载操作符时必须遵循的一些规则：

 

• 不能重载用于C++内部数据类型的操作符。例如，不能重载双目整数加法运算符。
• 不能自己创造C++语言中不存在的操作符。例如，美元符号$不是C++中的运算符，因此不可以用来重载
• 除了下列操作符，其他操作符皆可被重载

1.  
   1. . 类成员运算符
   2. .* 成员指针运算符
   3. ::域解析运算符
   4. ?:条件表达式运算符

• 无法改变运算符的优先级

以下代码以友元的方式重载了流运算符<<，以类成员的方式重载了算术运算符+

#include <iostream>
#include <string>
using namespace std;

class A;
ostream& operator<<(ostream& os,A& a);

class A
{
private:
        string _name;
        int _age;

public:
       A(string name,int age=1);
       ~A();
       friend A& operator++(A& a);       //前缀自增
       friend A& operator++(A& a,int);   //后缀自增
       friend ostream& operator<<(ostream& os,A& a); //友元方式重载<<
       A& operator+(A& a);  //类成员方式重载+
};
A::A(string name,int age)
:_name(name),_age(age)
{}

A::~A()
{}
ostream& operator<<(ostream& os,A& a)
{
           os <<a._name <<" ";
           os <<a._age <<endl;
           return os;
}
A& operator++(A& a)
{
      a._name+="++";
      a._age+=10;
      return a;
}
A& operator++(A& a,int)   //如果返回的不是一个引用的话，cout<<将无法正确输出
{
      //如果定义为局部变量，由于这个变量位于一个活动记录中，而这个记录在函数返回
      //时就会被删除。因此这个引用所指向的内容随时会变成任意一个值，
      //静态局部变量保存在全局数据区，而不是保存在栈中，
      //每次的值保持到下一次调用，直到下次赋新值。
      //所以此处应定义为static
 static A temp=a;
      a._name+="++";
      a._age+=10;
      return temp;
}
A& A::operator+(A& a)
{
           _name=a._name+_name;
           _age=a._age+_age;
           return *this;
}

int main(int argc,char* argv[])
{
    A a("sunw");
    A b("ukong",2);
    b+a;
    cout <<a <<b;
    A c("tang",3);
    cout <<c++;
    cout <<c;
    system("pause");
    return 0;
}

• friend ostream& operator<<(ostream& os,A& a);

为了让非成员重载函数可以修改A类的私有成员，所以将它定义为A类的友元函数

当用cout输出类A的对象a时

cout <<a;   //由于"<<"已被重载，所以编译器能够解释这句的行为。若没有重载"<<"，编译器会报错

可以把它看做一个函数

operator<<(cout,a);

operator<<就是函数名，cout和a是它的参数

 

这里a是一个A类的对象。此时，"<<"左边的cout流将作为ostream的参数传进运算符重载函数中，而a将作为A类的对象参数传进

这里函数的返回还是一个ostream对象，这样写是为了支持如下语句

cout <<a<<b<<c<<endl;

 

也可以这样写

friend out operator<<(ostream& os,A& a);

但这样将只支持cout<<a这样的调用，若按cout<<a<<b<<c<<endl;这样的方式调用的话编译器将报错

 

• 而b+a;可看做 b.operator+(a);  operator+是函数名，a是参数

c=a+b;  这个语句的意思是，调用对象a的operator+函数，b为参数，最后将返回值赋给c，而a也可理解为运算符+的一个参数

 

 

 

如果在类外重载运算符+，可以写成如下语句

A& operator+(A& a,A& b);

 

 

 

相应的，如果要把流运算符<<重载定义在类内，可以写成

 

      ostream& A::operator<<(ostream& os)
{
           os <<this->_name <<" ";
           os <<this->_age <<endl;
           return os;
}

 

 

但是，它只支持如下的调用

a<<cout;

 

所以一般流操作符的重载都会定义为非类成员友元函数

 

 

假设对于一元操作符@（注意：这里只是假设，@并不是一个操作符）如下调用

@a;

若是类成员重载方式，则等价于a.operator@();

若是非类成员重载方式，则等价于operator@(a);

 

假设对于二元操作符@（注意：这里只是假设，@并不是一个操作符）如下调用

a@b;

若是类成员重载方式，则等价于a.operator@(b);

若是非类成员重载方式，则等价于operator@(a,b);