一. 运算符重载
在讲解赋值运算符重载之前，我们需要先了解何为运算符重载。
1.1 概念引入
对于内置类型，我们可以直接使用运算符，比如：int a = 0; a+=1;
但是C++规定，类类型对象(即d1，d2之类的)使用运算符时，需要通过运算符重载的形式给运算符指定新的含义。（简单理解来说，就是类它并不知道+,-,*,/是什么意思，需要我们来定义）
1.2 运算符重载的定义与特性
- 运算符重载：是具有特名字的函数
- C++规定：类类型对象 使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
- 名字：运算符重载函数的名字是由operator和后面要定义的运算符共同构成。和其他函数的格式一样，它也具有：返回类型，参数列表，函数体。
- 参数：运算符是几元运算符，则函数就有几个参数（即重载运算符函数的参数个数=该运算符作用的运算对象数量）。
一元运算符有一个参数，而元运算符有两个参数。（一元：解引用*，++，- -，二元：+，-，*乘，/）
函数的第一个参数是：二元运算符的左侧运算对象；第二个参数：右侧。
还有一个问题是：若运算符重载函数里的变量是类里面的私有成员变量，那如何使用呢？
1.提供对应的getxxx函数
2.友元（后面说）
3.重载为成员函数
- this：如果这个运算符重载函数是在类里面，是成员函数，那么第一个参数是隐式的this指针，也就是左侧运算对象传给了隐式的this指针。因此运算符重载作为成员函数时，参数比运算对象少一个。
class Data
{
public:
Data(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
bool operator<(const Data& d) //this访问的是d1,d是d2的别名
{
if (_year < d._year)
return true;
else if (_year == d._year && _month < d._month)
return true;
else if (_year == d._year && _month == d._month && _day < d._day)
return true;
//其余情况均不符合，返回false
return false;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Data d1(2024, 10, 19);
Data d2(2024, 10, 2);
bool ret1 = d1 < d2;
std::cout << ret1 << std::endl;
Data d3(2024, 10, 1);
Data d4(2024, 10, 2);
bool ret2 = d3.operator<(d4);
std::cout << ret2 << std::endl;
return 0;
}
- 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致。
- 不能通过连接语法中没有的符号来创建新的操作符：比如operator@。
.*(对象调用成员函数指针)，::(域作用限定符)，sizeof，?:(三目)，.(对象的时候用的)注意以上5个运算符不能重载。
class A
{
public:
void func()
{
std::cout << "A::func()" << std::endl;
}
};
int main()
{
//void(*pf)();
//pf = func;
void(A:: * pf)();
pf = &A::func;
//1.func是成员函数，记得加类域
//2.c++规定：要取成员函数的地址，要加取地址操作符
//成员函数有隐式的this指针
return 0;
}
class A
{
public:
void func()
{
std::cout << "A::func()" << std::endl;
}
};
typedef void(A::* PF)();
int main()
{
//void(A:: * pf)();
//pf = &A::func;
PF pf = &A::func;
return 0;
}
class A
{
public:
void func()
{
std::cout << "A::func()" << std::endl;
}
};
typedef void(A::* PF)();
int main()
{
PF pf = &A::func;
//定义一个A类型的对象
A obj;
(obj.*pf)();
return 0;
}
- 有意义，再定义运算符重载函数。比如：日期+日期—>没有意义。日期-日期---->两个日期相隔的天数。
- 重载++运算符时，前置++和后置++的函数名都是operator++，不能很好的区分。C++规定，后置++ 重载时，增加一个int形参，跟前置++构成函数重载，方便区分
class Data
{
public:
//使用时：d1.operator++; （&d1传给this指针） 或者d1++;
Data operator++() //前置++ ，返回++以后的值
{
}
//使用时：d1.operator++(0); （&d1传给this指针,i是几都可以） 或者d1++;
Data operator++(int i) //后置++，返回++以前的值
{
}
private:
int _year;
int _month;
int _day;
};
int main()
{
return 0;
}
++先不实现，先实现+=。大家想一下，如果+=（data+=n就是data=data+n)都实现了，那n=1的时候，不就是++嘛。
隐式的this指针，实参和形参的位置都不可以使用，但是在类里面允许被使用。（比如：this是d1的地址，那我们需要返回this，只能是
return *this；
class Data
{
public:
Data(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
Data operator+=(int day)
{
}
//使用时：d1.operator++; （&d1传给this指针） 或者++d1;
Data& operator++() //前置++ ，返回++以后的值
{
*this += 1;
return *this; //*this是d1，出了作用域还在，返回值可以是Data&
}
//使用时：d1.operator++(0); （&d1传给this指针,i是几都可以） 或者d1++;
Data operator++(int i) //后置++，返回++以前的值
{
Data tmp = *this;
*this += 1;
return tmp; //出了作用域，tmp就不在了，返回Data
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Data d1(2024, 2, 23);
Data d2(2024, 6, 20);
return 0;
}
- 重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调⽤时就变成了 对象<<cout，不符合使用习惯和可读性。重载为全局函数把ostream/istream放到第一个形参位置就可以了，第二个形参位置当类类型对象。
二. 赋值运算符重载
2.1 概念
赋值运算符重载是一个默认成员函数，：完成（两个已经存在的对象）直接的拷贝赋值，而拷贝构造是：（一个已经存在的对象）拷贝初始化给（另一个要创建的对象）。
2.2 赋值运算符重载的特性
- 赋值运算符重载是一个运算符重载，规定必须重载为成员函数。
- 赋值运算重载的参数建议写成const 当前类类型引用，否则会传值传参会有拷贝。
- 赋值运算符重载有返回值，且建议写成当前类类型引用（函数名前面的那个），引用返回可以提高效率，有返回值目的是为了支持连续赋值场景。[ 赋值运算符的结合性是从右往左的，
int i,j,k; i=j=k=1;先将1赋值给k，k=1，然后k会作为赋值表达式的返回值，这个返回值又作为j= 的右操作数，j=1…，d1=d2=d3;亦是同理。 ]
class Data
{
public:
Data(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
// 返回值 类型
Data& operator=(const Data& d) //&d1传给this指针，d2传给别名d
{
//d1=d2,即将d2的值赋给d1
_year = d._year;
_month = d._month;
_day = d._day;
//返回谁呢？d1=d2=d3;先d2=d3，将d2的值返回，当作右操作数，d1=返回值
return *this;
}
void Print()
{
std::cout << _year << "/" << _month << "/" << _day << std::endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Data d1(2022, 3, 11);
Data d2(2028, 5, 24);
Data d3(2026, 6, 20);
d1 = d2=d3; //d1.operator(d2);
d1.Print();
return 0;
}
4. 没有显式实现赋值运算符重载的时候，编译器会自动生成一个默认赋值运算符重载。对内置类型成员变量会完成值拷贝/浅拷贝，对自定义类型成员变量会调用他的拷贝构造。
我们写的日期类，他里面的成员变量_year，_month，_day 都是int类型，内置类型。浅拷贝即可完成，我们不写赋值运算符重载也可以的。
d1=d1，这个倒也可以实现，但总是不太正常，我们可以加个判断
为什么不是if(*this!=d) 呢？因为*this是Data类型，d也是Data类型，只有内置类型才可以直接随便用运算符，类类型对象 使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
6. 总结：
(1)构造函数：一般需要自己写，自己传参定义初始化
(2)析构函数：如果构造的时候有资源申请(malloc或fopen之类的)，就需要显示写析构函数
(3)拷贝构造和赋值重载，若显示写了析构，就表示需要显示实现深拷贝，那拷贝构造和赋值重载也需要显示写。
