运算符重载

4.5.1 加号运算符重载

作用：实现两个自定义数据类型相加的运算

#pragma once
#include <iostream>
#include <string>
using namespace std;
//加号运算符重载
//1. 成员函数重载
class Person {
public:
    //1.成员函数重载+号
    Person operator+(Person &p) {
        Person temp;
        temp.m_A = this->m_A + p.m_A;
        temp.m_B = this->m_B + p.m_B;
        return temp;
    }
    int m_A;
    int m_B;
};

//2. 全局函数重载
Person operator+(Person& m, Person& n) {
    Person temp;
    temp.m_A = m.m_A + n.m_A;
    temp.m_B = m.m_B + n.m_B;
    return temp;
}

//3.函数重载的版本
Person operator+(Person &p, int num) {
    Person temp;
    temp.m_A = p.m_A + num;
    temp.m_B = p.m_B + num;
    return temp;
}

void test01() {
    Person p1;
    p1.m_A = 10;
    p1.m_B = 20;
    Person p2;
    p2.m_A = 5;
    p2.m_B = 15;
    //成员函数重载本质
    Person p4 = p1.operator+(p2);    
    //全局函数重载本质
    Person p5 = operator+(p1, p2);     
    Person p3 = p1 + p2;    //可以简化成这样子

    //操作符重载也能做函数重载
    Person p6 = p1 + 10;        //Person + int

    cout << "p3.m_A :" << p3.m_A << endl;
    cout << "p3.m_B :" << p3.m_B << endl;
}
int main() {
    test01();
    system("pause");
}

• 可以成员函数重载，或者全局函数重载
• 也可以将运算符重载当成函数再进行重载（例如代码中，将Person + Person 重载成 Person + int）
• 对于内置的数据类型的运算符是不可能改变的，例如1+1就是2，不允许自定义运算规则。

4.5.2 左移运算符重载

#pragma once
#include <iostream>
#include <string>
using namespace std;
//左移运算符重载
class Person {
public:

    //利用成员函数重载 左移运算符  p.opeartor<<(cout)   简化版本  p << cout
    //通常不会利用成员函数重载<<运算符 ， 因为无法实现 cout 在 << 左侧
    /*void operator<< () {

    }*/

    int m_A;
    int m_B;
};
//只能利用全局函数重载左移运算符
ostream& operator<<(ostream &cout, Person &p) {     //本质 operator<< (cout, p)  简化成 cout << p
    cout << "p.m_A: " << p.m_A << " p.m_B: " << p.m_B;
    return cout;
}
void test01() {
    Person p;
    p.m_A = 10;
    p.m_B = 20;
    cout << p << endl;        //链式编程
}
int main() {
    test01();
    system("pause");
}

总结：

• 无法利用成员函数去重载左移运算符，void operator<< (cout) { };  如果这样写的话，其最后调用的本质为  Person.operator<<(cout)  先有<<再有cout --  就变成了<< cout。
• 只能利用全局函数去重载， cout是一种输出流(ostream)的类型
• cout << p << endl;    必须让( cout << p )整体也成为一个输出流，才能继续链式的使用<< endl，因此重载函数最后要返回ostream &

4.5.3 递增和递减运算符重载

作用：通过重载递增，递减运算符，实现自己的整型数据递增，递减。

重载递增运算符：

#pragma once
#include <iostream>
#include <string>
using namespace std;
//重载递增运算符
//自定义整型
class MyInteger {
public:
    friend ostream& operator<<(ostream& cout, const MyInteger& p);
    MyInteger() {
        m_Num = 0;
    }
    //重载前置++运算符
    MyInteger& operator++ () {     //返回引用是为了一直对同一个数据进行操作
        m_Num++;  //先进行++运算        //++m_Num也是可以的        
        return *this;        //再将自身进行返回
    }
    //重载后置++运算符
    MyInteger operator++(int) {   //这里为什么不用引用是因为，下面创建的temp是一个局部变量，作用域后就失效了，再返回它的引用肯定会出问题
        MyInteger temp = *this;   //记录当前本身的值，然后让本身的值+1，但是返回的是以前的值，达到先返回后++的效果
        m_Num++;
        return temp; 
    }
private:
    int m_Num;
};

//重载<<运算符
ostream& operator<<(ostream& cout, const MyInteger& p) {
    cout << p.m_Num << endl;
    return cout;
}
void test01() {
    MyInteger a;
    cout << ++a << endl;
    cout << a << endl;
}
void test02() {
    MyInteger b;
    cout << b++ << endl;
    cout << b << endl;
}
int main() {
    test01();
    test02();
    system("pause");
}

重载递减运算符：

#include <iostream>
using namespace std;
//重载递减运算符
class Decrement {
public:
    friend ostream& operator<<(ostream& cout, Decrement p);
    Decrement() {
        m_Num = 0;
    }

    //重载前置递减运算符
    Decrement& operator--() {
        --m_Num;
        return *this;
    }
    //重载后置递减运算符
    Decrement operator--(int) {
        Decrement temp = *this;
        m_Num--;
        return temp;
    }
private:
    int m_Num;
};

//重载<<运算符
ostream& operator<<(ostream& cout, Decrement p) {
    cout << p.m_Num << endl;
    return cout;
}
void test01() {
    Decrement p;
    cout << --p << endl;
    cout << p << endl;
}
void test02() {
    Decrement p2;
    cout << p2-- << endl;
    cout << p2 << endl;
}
int main() {
    test01();
    test02();
    return 0;
}

总结(这个有很多知识点，请认真看完)：

1. 在C++中，编译器根据后置自增运算符的函数签名来区分前置和后置版本。前置自增运算符不需要传入任何参数，只需对当前对象进行自增操作即可；在后置自增运算符中，会传入一个额外的整数参数（可以命名为任何合法标识符，但通常命名为int），此参数用于标识该运算符为后置版本。（规定即是如此，不必纠结）
2. 重载后置++运算符，MyInteger operator++(int) {} 这边不需要加&引用的原因是 -- 下面创建的temp是一个局部变量，超出作用域后就失效了，再返回它的引用肯定会报错。
3. cout << b++ << endl;   一开始这句代码报错(没有与这些操作数匹配的 "<<" 运算符)。可以从两个角度理解：

　　　　　　(1) 　　因为上面第二点说了，return的MyInteger是一个临时变量，在C++中临时变量是不能修改的，即默认为const变量。非const引用只能绑定与该引用同类型的变量，就是说  ostream& 　　　　　　                                  operator<<(ostream& cout, MyInteger& p) {}中 MyInterger& 这个参数很明显的是一个非const引用，它不能引用一个const对象，而重载函数中return的MyInterger是一个const对象，                                    因此引用失败。

　　　　　　(2)　　大家都知道，引用本质上是一种指针常量，即指向不能变，但是指向的值可以变。代码中，operator<<(ostream& cout, MyInteger& p) {}；我们想将MyInterger& p这个引用参数指向　　　　　　                                  MyInterger，如果此时MyInterger是一个局部变量的话，它的地址出了作用域就被释放了，那原本将p指向MyInterger这一过程就不再生效，即引用失败。

　　    因此，重载<<运算符函数可以写成  ostream& operator<<(ostream& cout, const Decrement& p) {} 　　或者  ostream& operator<<(ostream& cout, Decrement p) {}

　　  4.　前置递增返回引用，后置递增返回值。

　　  5.   不要使用链式的后置递增(a++)++ 或者递减(a--)--，这样肯定会报错。原生C++的连续后置递增/递减也会报错，因为第二次是对局部变量进行了违规操作。具体原因上面说的应该很清楚了。

　　  6.   测试会发现，原生C++的前置也会比后置要快，因为从源码也是像我给出的代码中所写的那样，前置直接返回对象就行了，而后置要先保存以下当前对象状态，再去返回。

 

4.5.4  赋值运算符重载

　　C++编译器默认至少给一个类添加4个函数：

　　　　1.默认构造函数（无参，函数体为空）

　　　　2.默认析构函数（无参，函数体为空）

　　　　3.默认拷贝构造函数，对属性值进行拷贝

　　　　4.默认赋值运算符 operator=，对属性值进行赋值

先给出一个浅拷贝带来的内存重复释放的案例：

class Person {
public:
    Person(int age) {
        m_Age = new int(age);    //创建在堆区
    }
    ~Person()
    {
        if (m_Age != NULL) {
            delete m_Age;
            m_Age = NULL;
        }
    }
    int* m_Age;
};
void test01() {
    Person p1(18);
    Person p2(20);
    p2 = p1;    //赋值操作
    cout << "p1的年龄为：" << *(p1.m_Age) << endl;
    cout << "p2的年龄为：" << *(p2.m_Age) << endl;
}

　　　　 如果用系统默认的p2 = p1赋值，p1和p2指向的堆区内存其实是同一块，那么在析构函数就会产生重复释放的问题。解决方案：

利用深拷贝重载赋值运算的代码：

#pragma once
#include <iostream>
#include <string>
using namespace std;
//赋值运算符重载
class Person {
public:
    Person(int age) {
        m_Age = new int(age);    //创建在堆区
    }
    ~Person()
    {
        if (m_Age != NULL) {
            delete m_Age;
            m_Age = NULL;
        }
    }
    //重载赋值运算符
    Person& operator=(Person &p) {
        //编译器提供的是浅拷贝  -- m_Age = p.m_Age

        //应该先判断是否有属性在堆区，如果有，应该先释放干净
        if (p.m_Age != NULL) {
            delete m_Age;
            m_Age = NULL;
        }
        m_Age = new int(*p.m_Age);
        return *this;    //解引用 不是指针了，相当于一个变量了
        //return this 返回的是地址
        //return *this 返回的是对象
    }
    int* m_Age;
};
void test01() {
    Person p1(10);
    Person p2(20);
    Person p3(30);
    p1 = p2;    //赋值操作
    cout << "p1的年龄为：" << *(p1.m_Age) << endl;
    cout << "p2的年龄为：" << *(p2.m_Age) << endl;

    p3 = p2 = p1;   //链式赋值操作
    cout << "p1: " << *p1.m_Age << " p2: " << *p2.m_Age << " p3: " << *p3.m_Age << endl;
}
int main() {
    test01();
    system("pause");
}

 

4.5.5  关系运算符重载

此部分比较简单

#include <iostream>
using namespace std;
//赋值运算符重载
class Person{
public:
    Person(string name, int age){
        this->m_Name = name;
        this->m_Age = age;
    }
    
    bool operator==(Person& p){
        if (this->m_Name == p.m_Name && this->m_Age == p.m_Age) {
            return true;
        } else {
            return false;
        }
    }
    string m_Name;
    int m_Age;
}; 
void test01(){
    Person p1("张艺", 100);
    Person p2("张艺", 100);
    
    if (p1 == p2) 
        cout << "p1 == p2" << endl;
    else
        cout << "p1 != p2" << endl;
}
int main() {
    test01();
    return 0;
}

 

4.5.5  函数调用运算符重载

• 函数调用运算符 () 也可以重载
• 由于重载后使用的方式非常像函数的调用，因此称为仿函数
• 仿函数没有固定写法，非常灵活

#pragma once
#include <iostream>
using namespace std;
//函数调用运算符重载
class Person {
public:
    void AddFunction(int a, int b) {    //加法仿函数
        cout << a + b << endl;
    }
    
    void Print(string test) {        //打印输出仿函数
        cout << test << endl;
    }
    
    void Compare(int a, int b) {    //对比仿函数
        cout << max(a,b) << endl;
    }
    //............可以看出函数调用运算符重载非常灵活，可以根据具体需求修改
};
void test01() {
    Person p1;
    //类比正常的函数调用 void AddFunction(int a, int b) 
    //因为很像正常函数调用，所以被称为仿函数
    p1.AddFunction(10,20);    
    p1.Print("hhhhhhhhhhhhhh");
    p1.Compare(100, 200);
}
int main() {
    test01();
    system("pause");
}