运算符重载

1.什么是运算符重载？

我们已经知道函数重载就是根据不同的参数列表，实现一些类似的新的功能。也就是同一个函数名多个用处。

运算符也可以进行重载，比如+，-，*，/都可以重载。甚至如 << (左移)，在输出操作中与流对象cout配合使用实现输入操作。 >> (右移), 在输入操作中与流对象cin配合使用实现输入操作。（舍友提问我了，要如何重载<< 和 >>，所以总结一下哈）

在C++中，用户不能直接用C++提供的运算符来实现用户自定义类的运算，所以用户必须根据自己的需要对C++提供的运算符进行重载，满足自己的需要。

2.运算符重载的方法

运算符重载的方法是定义一个重载运算符函数，在需要执行被重载的运算符时，系统自动调用该函数。所以运算符重载实际上时函数的重载。
重载运算符的函数格式如下：
函数类型 operatro 运算符名称（形参列表）
{对运算符重载的处理，满足自己的需要}
例：实现一个复数类，并重载+运算符

class Complex
{
public: 
    Complex(double real,double imag)//构造函数
        :_real(real)
        ,_imag(imag)
        {}
    
   ~Complex()//析构函数
    {}
    Complex operator+(Complex c2)//对+运算符重载，按照复数加法计算规则
    {
        return Complex(_real+c2._real, _imag+c2._imag);
    }
    void print()
    {
        cout << "实部:" << _real
        << " , " << "虚部:" << _imag
        <<endl; 
    }
    
private:
    double _real;
    double _imag;
};

int main()
{
    Complex c1(10.15, 7.18);
    Complex c2(7.18, 10.15);
    Complex c3 = c1 + c2;
    c3.print();
    return 0;
}

在上面的函数中，虽然我们吧+运算符重载成复数间的运算，但是注意，运算符在被重载后，其原有的功能仍然继续保留。

3.运算符重载的规则

1.C++不允许用户自己定义新的运算符，只能对已有的运算符进行重载。
2.C++中除了以下的五个运算符，剩下的都可以重载

. (成员访问运算符)

.* (成员指针访问运算符)

:: (作用域解析符)

sizeof (长度运算符)

? : (三目条件运算符)

3、重载不能改变运算符运算对象的个数（即操作数的个数）
4、重载不改变运算符的优先级别
5、重载不改变运算符的结合性
6、重载的运算符必须和用户自定义的自定义类型的对象一起使用，其参数至少应该有一个是类对象(或类的引用)，防止用户修改用于标准类型数据的运算符的性质，比如下面这样
int operator+(int a,int b)
{ return a-b;}会产生二义性。
7、用于类对象的运算符一般必须重载，但有两个例外，运算符“=”和“&”不必用户重载，类默认生成的。
8、一般将单目运算符声明为类的成员函数，双目运算符声明成类的友元函数。

4.自增（++）运算，自减（- -）运算符的重载

自增和自减都需要你的对象引用是int型才可以。

//i++重载实现代码为：                                    
int operator++(int)                                  
{
    int temp = *this;                                     
    ++*this;                                             
    return temp;                                    
}//返回一个int型的对象本身

// ++i实现代码为：
int& operator++()
{
    *this += 1;
    return *this;
}//返回一个int型的对象引用

//i--实现代码为：
int operator--(int)                                  
{
    int temp = *this;                                     
    --*this;                                             
    return temp;                                    
}

// --i实现代码为：
int& operator--()
{
    *this -= 1;
    return *this;
}

5.重载流插入运算符（<<）和流提取运算符（>>）

跟着上面的复数例子，实现对复数对象的输出。

    ostream& operator<<(ostream & os)       //“<<”的重载
    {
        os << "(" << _real << "," << _imag << "i" << ")" ;
        return os ;
    }
    int main()
{
    Complex c1(10.15, 7.18);
    Complex c2(7.18, 10.15);
    Complex c3 = c1 + c2;
    c3.print();
    c1 << cout; //语句一 (10.15, 7.18i)
    cout << c1; //语句二 error
    return 0;
}

注意，如果我们这么来重载流插入运算符，那么只能语句一这种不能连续输出和不符合正常<<用法的问题，为什么会这样？因为这是一个类成员函数，它的第一个参数应该是隐含的this指针。因为cout 是输出流ostream类的对象。其中os就是cout。


要解决这种问题，我们一般将流插入运算符重载函数声明为类的友元函数，将ostream类对象和Complex类对象进行传参：

	friend ostream & operator<<(ostream & os, Complex & c)       //“<<”的重载
    {
        os << "(" << c._real << "," << c._imag << "i" << ")" ;
        return os ;
    }
    friend istream & operator>>(istream & is, Complex & c)      //">>"的重载
    {
        is >> c._real >>c._imag;
        return is;
    }

istream& operator>>(istream &,自定义类 &);

ostream& operator<<(ostream &,自定义类 &);