C++自学笔记核心编程篇（三）运算符重载

布逆呲没来

已于 2022-10-07 21:20:28 修改

阅读量133

点赞数

分类专栏： c++笔记文章标签： c++

于 2022-10-07 21:19:31 首次发布

本文链接：https://blog.csdn.net/qq_54549527/article/details/127084640

版权

c++笔记专栏收录该内容

18 篇文章 0 订阅

订阅专栏

4.5 运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。

4.5.1 加号运算符重载

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

对于内置数据类型，编译器知道如何进行运算，例如：
```
int a = 10;
int b = 10;
int c = a + b;
```

对于自定义数据类型

class Person{
public:
    int m_A;
    int m_B;
};

成员函数重载+号

class Person{
public:
    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;
};
//Person p3 = p1.operator+(p2);
//可简化为
Person p3 = p1 + p2;

通过全局函数重载+号

Person operator+ (Person &p1, Person &p2){
    Person temp;
    temp.m_A = p1.m_A + p2.m_A;
    temp.m_B = p1.m_B + p2.m_B;
    return temp;
}
//Person p3 = operator+ (p1, p2);
//简化为
Person p3 = p1 + p2;

运算符重载也可以发生函数重载

Person operator+ (Person &p1, int num){
    Person temp;
    temp.m_A = p1.m_A + num;
    temp.m_B = p1.m_B + num;
    return temp;
}
Person p3 = p1 + 10;

注：1.对于内置的数据类型的表达式的运算符是不可能改变的；
2.不要滥用运算符重载

4.5.2 左移运算符重载

作用：可以输出自定义数据类型

只能利用全局函数重载左移运算符

//重载左运算符
#include<iostream>
using namespace std;
class Person{
    friend ostream & operator<<(ostream &cout,Person &p);
public:
    Person(int a, int b){
        m_A = a;
        m_B = b;
    }
private:
    int m_A;
    int m_B;
};

//本质  operator<<(cout, p)  简化 cout << p
ostream & operator<<(ostream &cout,Person &p){
    cout << "m_A " << p.m_A << "   m_B" << p.m_B;
    return cout;
}
void test01(){
    Person p(10, 10);
    cout << p << endl;
}
int main(){
    test01();
    system("pause");
    return 0;
}

总结：重载左移运算符配合友元可以实现输出自定义数据类型

4.5.3 递增运算符重载

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

内置数据类型

int a = 10;
cout << ++a << endl; //11
cout << a << endl;   //11

int b = 10;
cout << b++ << endl;  //10
cout << b << endl;    //11

自定义数据类型

#include <iostream>
using namespace std;
class MyInteger{
    friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
    MyInteger(){
        m_Num = 0;
    }
    //重载前置++运算符
    MyInteger& operator++(){
        m_Num++;
        return *this;
    }
    //重载后置++运算符  int 代表占位参数，可以用于区分前置和后置递增
    void operator++(int){
        //先 记录当时结果
        MyInteger temp = *this;
        //后 递增
        m_Num++;
        //最后将记录结果做返回
        return temp;
    }
private:
    int m_Num;
};
ostream& operator<<(ostream& cout, MyInteger myint){
    cout << myint.m_Num;
    return cout;
}
void test01(){
    MyInteger myint;
    cout << ++(++myint) << endl;
    cout << myint << endl;
}
void test02(){
    MyInteger myint;
    cout << myint++ << endl;
    cout << myint << endl;
}
int main(){
//    test01();
    test02();
    system("pause");
    return 0;
}

4.5.4 赋值运算符重载

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

默认构造函数（无参，函数体为空）
默认析构函数（无参，函数体为空）
默认拷贝构造函数，对属性进行值拷贝
赋值运算符operator=，对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题。

#include <iostream>
using namespace std;
//赋值运算符重载
class Person{
public:
    Person(int age){
        m_Age = new int(age); //new 一个int 返回int* 给m_Age
    }
    ~Person(){
        if(m_Age != NULL){
            delete m_Age;
            m_Age = NULL;
        }
    }
    //重载 赋值运算符
    Person& operator=(Person &p){
        //编译器是提供浅拷贝
        //m_Age = p.m_Age;
        //应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
        if(m_Age != NULL){
            delete m_Age;
            m_Age = NULL;
        }
        m_Age = new int(*p.m_Age); //深拷贝
        return *this;
    }
    int *m_Age;
};
void test01(){
    Person p1(18);
    Person p2(20);
    Person p3(30);

    p3 = p2 = p1;
    cout << "p1的年龄为： "<< *p1.m_Age << endl;
    cout << "p2的年龄为： "<< *p2.m_Age << endl;
    cout << "p3的年龄为： "<< *p2.m_Age << endl;
}
int main(){
    test01();
    system("pause");
    return 0;
}

4.5.5 关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作。

#include <iostream>
#include <string>
using namespace std;
class Person{
public:
    Person(string name, int age){
        m_Name = name;
        m_Age = age;
    }
    //重载 == 号
    bool operator == (Person &p){  //或者!=
        if(this->m_Name == p.m_Name && this->m_Age == p.m_Age){
            return true;         //retuen false;
        }
        return false;            //return true;
    }
    string m_Name;
    int m_Age;
};
void test01(){
    Person p1("Tom", 18);
    Person p2("Jerry", 18);
    if(p1 == p2){
        cout << "p1和p2是相等的！" << endl;
    } else{
        cout << "p1和p2是不相等的！" << endl;
    }

}
int main(){
    test01();
    system("pause");
    return 0;
}

4.5.6 函数调用运算符重载

函数调用运算符（）也可以重载
由于重载后使用的方式非常像函数的调用，因此称为仿函数

仿函数没有固定写法，非常灵活

#include <iostream>
using namespace std;
#include <string>
//函数调用运算符重载
//打印输出类
class MyPrint{
public:
    //重载函数调用运算符
    void operator()(string test){
        cout << test << endl;
    }
};
void MyPrint02(string test){
    cout << test << endl;
}
void test01(){
    MyPrint myPrint;
    myPrint("hello world"); //由于使用起来非常类似于函数调用，因此称为仿函数
    MyPrint02("hello world");
}
//仿函数非常灵活，没有固定的写法
//加法类
class MyAdd{
public:
    int operator()(int num1, int num2){
        return num1 + num2;
    }
};
void test02(){
    MyAdd myAdd;
    int ret = myAdd(100, 100);
    cout << "ret = " << ret << endl;
    //匿名函数对象  当前行执行完立即被释放
    cout << MyAdd()(100, 100) << endl;  //MyAdd()为匿名函数对象
}
int main(){
//    test01();
    test02();
    system("pause");
    return 0;
}