学习：类和对象——运算符重载
什么是运算符重载？
运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型
对于个人而言，学到这里的感受就是，多了一种能够自定义方式来进行运算的方式吧，通过类似语法糖的效果operator+来自动实现相应的操作
+号运算符重载：
作用：实现两个自定义数据类型相加的运算
在+号运算符重载里面，我们可以通过两种方式来定义，一种是成员函数来实现，还有一种全局函数来实现
同样的调用方法也有两种，以下代码有体现
示例代码：
#include<iostream>
#include<string>
using namespace std;
class Person{
public:
//成员函数实现 + 号运算符重载
//Person operator+(Person& p1) {
// Person temp;
// temp.age = this->age + p1.age;
// return temp;
//}
public:
int age;
};
//全局函数 实现+号运算符重载
Person operator+(Person& p1, int val) {
Person temp;
temp.age = p1.age + val;
return temp;
}
int main() {
Person p1;
p1.age = 20;
//Person p2 = p1.operator+(p1); //调用方式有两种，这是第一种
Person p2 = p1 + 10;//这是第二种调用方式
cout << p2.age << endl;
system("pause");
return 0;
}
总结1：对于内置的数据类型的表达式的的运算符是不可能改变的
总结2：不要滥用运算符重载
左移运算符重载
通过左移运算符重载，我们可以实现输出自定义数据类型，比如 cout << 对象 << endl,实际输出的是 cout << 对象.a << endl
#include<iostream>
#include<string>
using namespace std;
class Person {
friend ostream& operator<<(ostream& cout, Person& p); //因为a,b是私有成员变量，所以我们利用friend友元进行修饰，让其能够访问到我们的私有变量
public:
Person(int a, int b) {
this->a = a;
this->b = b;
}
//void operator<<(cout) {} //在类中定义的话无法实现 cout << p这种形式到时候调用的时候只能是p.operator<<(p),简化版只能是 p << cout,所以我们只在全局区定义函数
private:
int a;
int b;
};
ostream& operator<<(ostream& cout,Person& p) { // 都不需要生成一个新的内存空间，所以都进行传参引用
cout << p.a << "," << p.b << endl;
return cout; // 这里返回的是ostream类型 是为了进行后面 << 继续拼接的输出，链式操作
}
int main() {
Person p1(1, 2);
cout << p1 << "hello world " <<endl; //通过p1 直接可以输出对象p1的成员变量
system("pause");
return 0;
}
递减运算符重载：
作用： 通过重载递减运算符，实现自己的整型数据
#include<iostream>
#include<string>
using namespace std;
class Num {
//创建友元函数,因为这里a是私有变量
friend ostream & operator<<(ostream& cout, Num n);
public:
Num(int a) {
this->a = a;
}
Num & operator--() {// 定义前置--运算符重载
a--;
return *this;
}
Num operator--(int) { //定义后置--运算符重载 这时候int这种占位参数就体现出来了，区别前置还是后置不要问为什么，因为有个傲娇的编译器
Num temp = *this;
this->a--;
return temp;
}
private:
int a;
};
//重载一个左移运算符
ostream & operator<<(ostream& cout, Num n) {
cout << n.a;
return cout;
}
int main() {
Num n1(1);
cout << --n1 << endl;
cout << n1-- << endl;
system("pause");
return 0;
}
赋值运算符重载：
c++编译器至少给一个类添加4个函数
1、默认构造函数(无参，函数体为空)
2、默认析构函数(无参，函数体为空)
3、默认拷贝构造函数，对属性进行值拷贝
4、赋值运算符 operator=, 对属性进行值拷贝
如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题
#include<iostream>
#include<string>
using namespace std;
class Person {
public:
Person(int height) {
this->height= new int(height);
}
Person & operator=(Person & p) {
if (this->height != NULL) {
delete this->height;
this->height = NULL;
}
this->height = new int(*p.height);
return *this;
}
~Person() {
if (this->height != NULL) {
delete this->height;
this->height = NULL;
}
}
public:
int * height;
};
int main() {
Person p1(180);
Person p2(170);
p2 = p1;
cout << *p1.height << endl;
cout << *p2.height << endl;
system("pause");
return 0;
}
关系运算符重载：
作用：重载关系运算符，可以让两个自定义类型对象进行对比操作
还是一样的，就是返回个类型应该来说是个布尔值，因为是==比较
#include<iostream>
#include<string>
using namespace std;
class Person {
public:
Person(int age) {
this->age = age;
}
bool operator==(Person& p) {
if (this->age == p.age) {
return true;
}
else {
return false;
}
}
bool operator!=(Person& p) {
if (this->age == p.age) {
return false;
}
else {
return true;
}
}
public:
string name;
int age;
};
int main() {
Person p1(18);
Person p2(18);
if (p1 == p2) {
cout << "相等" << endl;
}else{
cout << "不相等" << endl;
}
system("pause");
return 0;
}
函数调用运算符重载：
1、函数调用运算符 () 也可以重载
2、由于重载后使用的方式非常像函数的调用，因此称为仿函数，仿函数没有固定写法，非常灵活
自己总结下这个知识点：
1、第一点是函数调用运算符重载，也就是跟之前的一样加个()就好了
2、第二点是匿名对象类，也可以我们后面不需要再继续用到，所以就不需要进行储存操作，一次性调用就可以了
体现代码：
#include<iostream>
#include<string>
using namespace std;
class Printer{
public:
void operator()(string name) {
cout << name << endl;
}
};
int main() {
Printer p1;
p1("adexx"); //一种方式来调用
Printer()("adexx");//使用匿名类来进行调用
system("pause");
return 0;
}
