C++入门--运算符重载

一、运算符重载

运算符重载（Operator Overloading）:让一个运算符可以有不同的功能。

已经熟知的运算符重载，如‘+’，可以对不同类型的(int,float)的数据进行加法操作；'<<’既是位移运算符，又可以配合 cout 向控制台输出数据。

C++允许程序员自己重载运算符。

以下代码定义了一个复数类，通过运算符重载，可以用+号实现复数的加法运算：

#include <iostream>
#include <string>

//多行注释：Ctrl+k+c
//取消注释：Ctrl+k+u

using namespace std;

class complex {
public:
    complex();
    complex(double real, double imag);
public:
    //声明运算符重载
    complex operator + (const complex & A) const;
    void display() const;
private:
    double m_real;  //实部
    double m_imag;   //虚部
};

complex::complex() :m_real(0.0), m_imag(0.0) {}
complex::complex(double real, double imag) :m_real(real), m_imag(imag) {}

//实现运算符重载
complex complex::operator+(const complex& A) const {
    complex B;
    B.m_real = this->m_real + A.m_real;
    B.m_imag = this->m_imag + A.m_imag;
    return B;
}

void complex::display() const {
    cout << m_real << "+" << m_imag << "i" << endl;
}

int main() {
    complex c1(4.5, 5.8);
    complex c2(2.4, 3.6);
    complex c3;
    c3 = c1 + c2;
    c3.display();

    return 0;
}

以上是以成员函数来实现运算符重载，通过this指针来访问本身的对象的成员。
运行结果：

 运算符重载其实就是定义一个函数，在函数体内实现想要的功能，当用到该运算符时，编译器会自动调用这个函数。即本质上是函数重载。

运算符重载的格式为：

返回值类型 operator 运算符名称 (形参表列){
    //TODO:
}

operator是关键字，专门用于定义重载运算符的函数，可将“operate 运算符名称”这一部分看做函数名。

上面的例子中，我们在 complex 类中重载了运算符 + ，该重载只对 complex 对象有效。当执行 c3 = c1 + c2; 语句时，编译器检测到 + 号左边（+号具有左结合性，所以先检测左边）是一个 complex 对象，就会调用成员函数 operator+()，也就是转换为下面的形式：

c3 = c1.operator+(c2);

c1是要调用函数的对象，c2是函数的实参。

在全局范围内重载运算符

运算符重载函数不仅可以作为类的成员函数，还可以作为全局函数。

#include <iostream>
using namespace std;

class complex{
public:
    complex();
    complex(double real, double imag);
public:
    void display() const;
    //声明为友元函数
    friend complex operator+(const complex &A, const complex &B);
private:
    double m_real;
    double m_imag;
};

complex operator+(const complex &A, const complex &B);

complex::complex(): m_real(0.0), m_imag(0.0){ }
complex::complex(double real, double imag): m_real(real), m_imag(imag){ }
void complex::display() const{
    cout<<m_real<<" + "<<m_imag<<"i"<<endl;
}

//在全局范围内重载+
complex operator+(const complex &A, const complex &B){
    complex C;
    C.m_real = A.m_real + B.m_real;
    C.m_imag = A.m_imag + B.m_imag;
    return C;
}

int main(){
    complex c1(4.3, 5.8);
    complex c2(2.4, 3.7);
    complex c3;
    c3 = c1 + c2;
    c3.display();
 
    return 0;
}

运算符重载函数不是complex类的成员函数，但是用到了类内的私有成员，所以必须将声明为友元函数。

当执行c3 = c1 + c2;语句时，编译器检测到+号两边都是 complex 对象，就会转换为类似下面的函数调用：

c3 = operator+(c1, c2);

小结：

运算符被重载后，原有的功能仍然保留，没有丧失或改变。通过运算符重载，扩大了C++已有运算符的功能，使之能用于对象。

1）实现一元运算符重载

用全局函数实现，前置++操作符  用成员函数实现 后置++操作符

#include <iostream>

using namespace std;

class complex {
   public:
    complex();
    complex(double real, double imag);
    friend complex& operator++(complex& c1);

   public:
    void display() const { cout << m_real << "+" << m_imag << "i" << endl; }

    //用成员函数实现重载后置++ 添加无用参数作为占位符
    complex operator++(int) {
        complex temp;
        this->m_real++;
        this->m_imag++;
        return temp;
    }

   private:
    double m_real;
    double m_imag;
};

complex::complex() : m_real(0.0), m_imag(0.0) {}
complex::complex(double real, double imag) : m_real(real), m_imag(imag) {}

//重载前置++
complex& operator++(complex& c1) {
    c1.m_real++;
    c1.m_imag++;
    return c1;
}

int main() {
    complex c1;
    ++c1;
    c1.display();

    c1++;
    c1.display();
}

2）实现<<运算符重载

用全局函数重载实现<<操作符 

#include <iostream>

using namespace std;

class complex {
   public:
    complex();
    complex(double real, double imag);

   public:
    void display() const { cout << m_real << "+" << m_imag << "i" << endl; }

    friend void operator<<(ostream& out, complex& c1);

   private:
    double m_real;
    double m_imag;
};

complex::complex() : m_real(0.0), m_imag(0.0) {}
complex::complex(double real, double imag) : m_real(real), m_imag(imag) {}

void operator<<(ostream& out, complex& c1) {
    out << c1.m_real << "+" << c1.m_imag << "i" << endl;
}

int main() {
    complex c1;
    cout << c1;
}

cout << c1, 可以正常打印，但是对于cout << c1 <<"aaa"; 就会报错，提示第二个<<的左操作符为void
确实，重载<<后返回的是void，所以应该返回ostream类，以支持链式编程

class complex{
...
friend ostream& operator<<(ostream& out, complex& c1);
...

}；

ostream& operator<<(ostream& out, complex& c1) {
    out << c1.m_real << "+" << c1.m_imag << "i" << endl;
    return out;
}

运算符重载的初衷是给类添加新的功能，方便类的运算，它作为类的成员函数是理所应当的，是首选的。
不过，类的成员函数不能对称地处理数据，程序员必须在（参与运算的）所有类型的内部都重载当前的运算符。
比如，cout << c1; 

cout 是 ostream 类的对象，要想达到这个目标，就必须以全局函数（友元函数）的形式重载<<，否则就要修改标准库中的类，这显然不是我们所期望的。
所以友元函数重载运算符常用于运算符左右操作数类型不同的情况。

 3）实现 [] , =, ==, != 运算符重载

函数返回值当左值，需要返回一个引用

通过一个数组类来实现

#ifndef ARRAY_H
#define ARRAY_H

#include <iostream>
using namespace std;

class Array {
   public:
    Array(int length);
    Array(const Array& obj);
    ~Array();

   public:
    void setData(int index, int value);
    int getData(int index);
    int length();

   private:
    int m_length;
    int* m_space;

   public:
    int& operator[](int i);
    Array& operator=(Array& a);
    bool operator==(Array& a);
};

#endif

#include "array.h"

Array::Array(int length) {
    if (length < 0) {
        length = 0;
    }
    m_length = length;
    m_space = new int[m_length];
}
Array::Array(const Array& obj) {
    this->m_length = obj.m_length;
    this->m_space = new int[m_length];
    for (int i = 0; i < this->m_length; i++) {
        this->m_space[i] = obj.m_space[i];
    }
}
Array::~Array() {
    if (m_space != nullptr) {
        delete[] m_space;
        m_length = 0;
    }
}
void Array::setData(int index, int value) { m_space[index] = value; }
int Array::getData(int index) { return m_space[index]; }
int Array::length() { return m_length; }

int& Array::operator[](int i) { return m_space[i]; }
Array& Array::operator=(Array& a) {
    // 1.释放原来的内存
    if (this->m_space != nullptr) {
        delete[] m_space;
        m_length = 0;
    }
    // 2.根据a的大小重新分配内存
    m_length = a.m_length;
    m_space = new int[m_length];
    // 3.拷贝数据
    for (int i = 0; i < m_length; i++) {
        m_space[i] = a.m_space[i];
    }
    return *this;
}

bool Array::operator==(Array& a) {
    if (m_length != a.m_length) {
        return false;
    }
    for (int i = 0; i < m_length; i++) {
        if (m_space[i] != a.m_space[i]) {
            return false;
        }
    }
    return true;
}

#include <iostream>

#include "array.h"

using namespace std;

int main() {
    Array a(10);
    Array a1(6);
    Array a2(20);
    a1 = a = a2;
    for (int i = 0; i < 10; i++) {
        a[i] = i;  //函数返回值当左值，需要返回一个引用
    }

    for (int i = 0; i < a.length(); i++) {
        cout << a[i] << " ";
    }

    cout << "a1:length=" << a1.length() << endl;

    if (a1 == a) {
        cout << "a == a1" << endl;
    }
}

二、运算符重载时要遵循的规则

1、常见可被重载的运算符：

+  -  *  /  %  ^  &  |  ~  !  =  <  >  +=  -=  *=  /=  %=  ^=  &=  |=  <<  >>  <<=  >>=  ==  !=  <=  >=  &&  ||  ++  --  ,  ->*  ->  ()  []  new  new[]  delete  delete[]

[]是下标运算符，()是函数调用运算符。自增自减运算符的前置和后置形式都可以重载。长度运算符sizeof、条件运算符: ?、成员选择符.和域解析运算符::不能被重载。

2、重载不能改变运算符的优先级与结合性

3、重载不会改变运算符的用法

4、运算符重载函数不能有默认的参数，否则就改变了运算符操作数的个数

5、运算符重载函数既可以是类的成员函数，也可以是全局函数

三、是以成员函数还是以全局函数的形式重载运算符

1）只能重载为成员函数：“=”、“（）”、“[ ]”、“->”等，与 this（自身）关联太多。

2）只能重载为友元函数：只能重载为友元函数：输出运算符 << ,第一个操作符一定是 ostream 。