【原创】关于操作符重载的一些个人理解

 

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

 

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

 

• 不能重载用于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)   

{

      //如果定义为局部变量，由于这个变量位于一个活动记录中，而这个记录在函数返回

      //时就会被删除。因此这个引用所指向的内容随时会变成任意一个值，

      //静态局部变量保存在全局数据区，而不是保存在栈中，

      //每次的值保持到下一次调用，直到下次赋新值。

      //所以此处应定义为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);

 

 

转载于:https://www.cnblogs.com/mx113/articles/1604013.html