【C++基础】----运算符重载（01）

一方面，在C++中，运算符重载( operator overloading)允许把标准运算符(如+  -  *  /  % 等)应用于自定义数据类型的对象。

这样可以直观自然地看出自定义数据类型间的运算，并且提高程序的可读性。

另一方面，运算符重载仅仅是一种语法上的方便。默认运算符的本质就是函数的调用，而运算符重载就是另一种调用。

同时，虽然很多时候使用运算符重载可以提高程序的可读性，但我们不应该过于依赖，甚至是滥用它。只有在所涉及的代码更容易表达，尤其是更容易被读懂时才有必要重载。

例：

<pre name="code" class="cpp">#include <iostream>using namespace std ;class Complex{        int real_ ;        int imag_ ;public :        Complex(int real , int imag) : real_(real) , imag_(imag) { }        Complex() : real_(0) , imag_(0) { }        Complex Add(const Complex& other){                real_ += other.real_ ;                imag_ += other.imag_ ;                return *this ;        }        ~Complex() {};        void Display() const {                cout << real_ << " + " << imag_ << "i" << endl ;        }};int main(void) {        Complex c1(3 , 5) ;        Complex c2(4 , 6) ;        c1.Add(c2) ;        c1.Display() ;        return 0 ;}

我们在不使用运算符重载的情况下，实现了两个复数相加的操作。

但是缺点非常明显，这样的方式非常不直观，如果我们希望 Complex c3 = c1 + c2 ;

这样直观的表现的话，编译器就会告诉我们，类的对象不能直接参与运算。

但如果我们有了运算符重载这个利器的话，上面的问题就会迎刃而解。

1. 成员函数重载

成员函数声明的格式 ：

返回值类型 operator运算符 (参数列表) ;

成员函数定义的格式 ：

返回值类型 类名::operator运算符 (参数列表)  : {

//需要实现的功能

}

例：以成员函数实现上面代码的功能

Complex operator+ (const Complex& other) ;

运算符“+”是一个二元运算符，运算时需要其左边和右边的对象，而成员函数必须由类的一个实例来调用，如使用c1调用operator+时，编译器已经知道c1的存在，只需要输入另一个对象即可。真实的情况就是成员函数重载运算符时，首先会默认地调用隐式指针this，之后才调用参数列表中显式的对象作为参数，因此在成员函数重载时，只需要一个参数。

下面我们来实现这个新的功能

#include <iostream>using namespace std ;class Complex{        int real_ ;        int imag_ ;public :        Complex(int real , int imag) : real_(real) , imag_(imag) { }        Complex() : real_(0) , imag_(0) { }        Complex operator+(const Complex& other){                int r = real_ + other.real_ ;                int i = imag_ + other.imag_ ;                return Complex(r, i) ;        }        ~Complex() {};        void Display() const {                cout << real_ << " + " << imag_ << "i" << endl ;        }};int main(void) {        Complex c1(3 , 5) ;        Complex c2(4 , 6) ;        Complex c3 = c1 + c2 ;        c3.Display() ;        return 0 ;}

2. 友元函数重载

C++中的函数一共有两种形式，成员函数和顶层函数，我们现在来讨论顶层函数如何去实现。

首先，普通的顶层函数有一个致命的缺陷，就是无法访问类的私有成员。因此我们只有通过友元函数来实现运算符重载。

友元函数声明原型：

friend 函数原型 operator运算符（参数列表） ;

友元函数定义原型：

friend 函数类型 类名::operator运算符（参数列表） ;

#include <iostream>using namespace std ;class Complex {        int real_ ;        int imag_ ;public :        Complex(int real , int imag) : real_(real) , imag_(imag) { }        Complex() : real_(0) , imag_(0) { }        friend Complex operator+(const Complex& left , const Complex& right) ;        void Display() {                cout << real_ << " + " << imag_ << "i" << endl ;        }        ~Complex() {} ;};Complex operator+(const Complex& left , const Complex& right) {        int r = left.real_ + right.real_ ;        int i = left.imag_ + right.imag_ ;        return Complex(r , i) ;}int main(void) {        Complex c1(3 , 5) , c2(4 , 6) ;        Complex c3 = c1 + c2 ;        c3.Display() ;        return 0 ;}

这就是用友元函数实现的运算符重载。

3. 运算符重载的规则

①. 运算符重载不允许发明新的运算符；

②. 不能改变原有运算符操作对象的个数，即单目不得变双目等；

③. 运算符被重载后，其优先级和结合性不得发生改变

④. 不得被重载的运算符：作用于运算符 ::

条件运算符  ? :

直接成员运算符 .

类成员一直引用  ->

sizeof运算符 sizeof