重载运算符的形式和注意事项

本是古典何须时尚 2022-05-16 09:37 183阅读 0赞

# 1 基本概念 #

运算符重载（函数重载）是C++多态的重要实现手段之一。通过运算符重载对运算符功能进行特殊定制，使其支持特定类型对象的运算，执行特定的功能，增强C++的扩展功能。

## 1.1 运算符重载的我们需要坚持四项基本原则 ##

（1）不可臆造运算符。

（2）运算符原有操作数的个数、优先级和结合性不能改变。

（3）操作数中至少一个是自定义类型。

（4）保持重载运算符的自然含义。

## 1.2 重载运算符的形式区别 ##

一般来说，C++运算符重载可采用成员函数和友元函数，二者都可以访问类的私有成员，至于该采用哪一种呢，首先看一下二者的区别。

（1）当重载为成员函数时，会隐含一个this指针；当重载为友元函数时，不存在隐含的this指针，需要在参数列表中显示地添加操作数。

（2）当重载为成员函数时，只允许右参数的隐式转换；当重载为友元函数时，能够接受左参数和右参数的隐式转换。

class CString
    {
    public:
        CString(char* str);
    private:
        char* m_pStr;
    };

因为CString的构造函数参数为一个char\*，所以如果采用友元形式的operator +(const CString&, const CString&)，那么char+CString和CString+char都能正常工作；而如果采用成员函数形式CString::operator+(const CString& rhs)，则只能接受CString+char，如果执行char+CString则会编译出错。我们往往习惯CString+char和char+CString都应该被接受。需要注意的是，隐式转换由于临时变量的增加往往效率不高。如果应用程序对效率要求较高，针对以上类，建议选择定义多个运算符的友元重载版本：

CString& operator +(const CString&, const CString&);
    CString& operator +(const char*, const CString&);
    CString& operator +(const CString&, const char*);

## 1.3 结论 ##

（1）一般而言，对于双目运算符，最好将其重载为友元函数；而对于单目运算符，则最好重载为成员函数。

但是也存在例外情况。有些双目运算符是不能重载为友元函数的，比如赋值运算符=、函数调用运算符()、下标运算符\[\]、指针运算符->等，因为这些运算符在语义上与this都有太多的关联。比如=表示“将自身赋值为…”，\[\]表示“自己的第几个元素”，如果将其重载为友元函数，则会出现语义上的不一致。

（2）还有一个需要特别说明的就是输出运算符<<。因为<<的第一个操作数一定是ostream类型，所以<<只能重载为友元函数，如下：

friend ostream& operator <<(ostream& os, const Complex& c);
    ostream& operator <<(ostream& os, const Complex& c)
    {
        os << c.m_Real << “+” << c.m_Imag << “i” << endl;
        return os;
    }

（3）所以，对于 =、\[\]、()、->以及所有的类型转换运算符只能作为非静态成员函数重载。如果允许第一操作数不是同类对象，而是其他数据类型，则只能作为非成员函数重载（如输入输出流运算符>>和<<就是这样的情况）。

重载为类的非成员函数的时候，通常我们都将其声明为友元函数，因为大多数时候重载运算符要访问类的私有数据，（当然也可以设置为非友元非类的成员函数，但是非友元又不是类的成员函数是没有办法直接访问类的私有数据的），如果不声明为类的友元函数，而是通过在此函数中调用类的公有函数来访问私有数据会降低性能。所以一般都会设置为类的友元函数，这样我们就可以在此非成员函数中访问类中的数据了。

（4）总结

一般情况下，将双目运算符重载为友元函数，这样就可以使用交换律，比较方便。单目运算符一般重载为成员函数，因为直接对类对象本身进行操作。

总之，如果运算符重载为成员函数，第一个参数必须是本类的对象，因为默认使用第一个参数的对象进行调用该成员函数。

# 2 实例 #

## 2.1 操作符重载实现为类成员函数 ##

重载的操作符在类体中被声明，声明方式如同普通成员函数一样，只不过他的名字包含关键字operator，以及紧跟其后的一个C++预定义的操作符。

（1）可以用如下的方式来声明一个预定义的==操作符:

#include<iostream>
    using namespace std;
    
    class Person
    {
    private:
        int age;
        public:
        Person( int a )
        {
           this->age = a;
        }
    	
        inline bool operator == ( const Person &ps ) const;
    };
    
    bool Person::operator==(const Person &ps) const
    {
        if( this->age==ps.age )
    	{
            return true;
        }
    	
        return false;
    }
     
    int main()
    {
        Person p1( 10 );
        Person p2( 20 );
        if( p1 == p2 )
        {
     	    cout<< "the age is equal!" <<endl;
        }
    	
    	return 0;
    }

## 2.2 操作符重载实现为非类成员函数(全局函数) ##

对于全局重载操作符，代表左操作数的参数必须被显式指定。

（1）例如：

#include<iostream>
    using namespace std;
    class Person
    {
    public:
        int age;
    public:
    	Person( int _age = 0 )
              :age(_age)
        {
            cout << "person(int _age )"<< endl;
        }
     
    	Person( Person& ps )
        {
            *this = ps;
        }
    };
    
    bool operator==( Person& p1, Person const & p2 )   // 全局重载操作符==
    {
    	if( p1.age == p2.age )
        {
            return true; 	 // 满足要求
        }
        return false;
    }
    
    int main()
    {
        Person rose;
        Person jack;
        rose.age = 18;
        jack.age = 23;
    	
        if( rose == jack )
        {
            cout << " is equal " << endl;
    	}
        cout << "not equal " << endl;
        return 0;
    }

# 3 注意事项 #

（1）需要返回结果的重载操作符首先要确定它的返回值是左值，还是右值，如果是左值最好返回引用，如果是右值那就直接返回值。

（2）+号等这样的操作符没有对象可以容纳改变后值，对于这样的情况最好返回数值，否则只能要操作符体内创建临时对象用于容纳改变后的值，如果在堆中创建临时对象返回指针或者引用，在操作符函数体外还需要释放它，如果返回的对象而不是引用或者指针，那么效率是比较低的。如果返回的是数值，最好在该类的构造函数中增加对该类型数值的转换函数，如：返回值是int类型，那么最好有一个int类型作为参数的构造函数。

（3）在增量运算符中，放上一个整数形参，就是后增量运行符，它是值返回，对于前增量没有形参，而且是引用返回。

class Test
    {
    public:
        Test(int x = 3)
        { 
            m_value = x;
        }
        
        Test& operator++();   // 前增量
        Test operator++(int); // 后增量
        
    private:
        int m_value;
    };
    
    Test& Test::operator++()
    {
        m_value++;     // 先增量
        return *this;  // 返回当前对象
    }
    
    Test Test::operator++(int)
    {
        Test temp(*this);   // 创建临时对象
        m_value++;          // 再增量
        return temp;        // 返回临时对象
    }

（4）因为强制转换是针对基本数据类型的，所以对类类型的转换需自定义。

（5）转换运行符重载声明形式：operator 类型名();它没有返回类型，因为类型名就代表了它的返回类型，所以返回类型显得多余。

（6）一般来说，转换运算符与转换构造函数（即带一个参数的构造函数）是互逆的，如有了构造函数Test(int)，那么最好有一个转换运算符int()。这样就不必提供对象参数重载运算符了，如Test a1(1);Test a2(2); Test a3; a3 = a1+a2；就不需要重载+号操作符了，因为对于a1+a2的运算，系统可能会先找有没有定义针对Test的+号操作符，如果没有，它就会找有没有针对Test类转换函数参数类型的+号操作符（因为可以将+号运行结果的类型通过转换函数转换为Test对象），因为Test类有个int类型的参数，对于int类型有+操作符，所以a1+a2真正执行的是Test(int(a1) + int(a2));即Test(3)；

（7）对于转换运算符，还有一个需要注意的地方就是，如果A类中有以B为参数的转换函数（构造函数），那B中不能有A的转换运算符，不然就存在转换的二义性，如：

class A{A(B&){…}}; class B{ operator A(){…}}; // 那么以下语句就会有问题：
     
    B b; A(b);  // A(b) 就可能是A的构造函数，也可以是B的转换运算符