欢迎来到CILMY23的博客
本篇主题为： 类成员函数-----赋值运算符重载，为什么默认实现可能不够？
个人主页：CILMY23-CSDN博客
系列专栏：Python | C++ | C语言 | 数据结构与算法 | 贪心算法 | Linux
感谢观看，支持的可以给个一键三连，点赞关注+收藏。
目录
一、为什么默认实现可能不够？
假设我们有一个学生类，在实际应用中，我们肯定是需要排序的，或者是按照对应信息查询学生。
通常我们是按照学号或者姓名排序,但是我们现在要看学生的入学时间，按入学时间先后排序。
class Student
{
public:
void Init(const char* name,int year,int month,int day)
{
strcpy(_name, name);
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << "学生姓名：" << _name << endl;
cout << "学生入学时间："
<< _year << "/"
<< _month << "/"
<< _day
<< endl;
}
//private:
char _name[20];
int _year;
int _month;
int _day;
};
int main()
{
Student stu1;
stu1.Init("zhangsan", 2023, 9, 9);
Student stu2;
stu2.Init("wangming", 2022, 9, 15);
stu1.Print();
stu2.Print();
return 0;
}我们初始化了两个学生对象，分别是 zhangsan 和 wangming，当然我们不可能简单的通过一个运算符进行比对，例如，对内置类型进行比较的时候用到的＞， ＝， ＜这些，并不能简单应用到自定义类型上。因此我们必须自己写一个函数来进行比对。
bool student_compare(const Student& s1, const Student& s2)
{
if (s1._year < s2._year)
{
return true;
}
else if (s1._year == s2._year)
{
if (s1._month < s2._month)
{
return true;
}
else if (s1._month == s2._month)
{
if (s1._day < s2._day)
{
return s1._day < s2._day;
}
}
}
return false;
}简单测试一下：
cout << student_compare(stu1, stu2) << endl;
cout << student_compare(stu2, stu1) << endl;
我们可以看到结果如下：
这样实现虽然没什么问题，但有几个情况
1. 类的成员无法管理，不能用 private 限定访问
2. 函数名容易起冲突，并且存在不规范，难起名的问题
3.比较依赖程序员的代码水平
所以C++引入了运算符重载，来增加代码的可读性。
二、运算符重载
2.1 运算符重载的概念
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其 返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字 operator 后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意这里的运算符重载和函数重载是不一样的。 运算符重载是重新定义了运算符的行为。
例如：
bool operator<(const Student& s1, const Student& s2)
{
if (s1._year < s2._year)
{
return true;
}
else if (s1._year == s2._year)
{
if (s1._month < s2._month)
{
return true;
}
else if (s1._month == s2._month)
{
if (s1._day < s2._day)
{
return s1._day < s2._day;
}
}
}
return false;
}我们可以如下调用：
cout << operator<(stu1, stu2) << endl;
cout << operator<(stu2, stu1) << endl;也可以如下调用：
cout << (stu1 < stu2) << endl;
cout << (stu2 < stu1) << endl;注意: 这里的括号并不能去掉，因为流运算符优先级高于我们的重载，所以要加括号。这里的（stu1 < stu2）等同于 (operator<(stu1, stu2)) 。
2.2 运算符重载的特点
- 不能通过连接其他符号来创建新的操作符（只能C/C++语言存在的）：比如 operator@
- 重载操作符必须有一个类类型参数（自定义类型参数）
- 用于内置类型的运算符，其含义不能改变，例如：内置的整型 +，不能改变其含义。
- 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的 this 指针，简单理解就是有几个操作数就有几个参数。（这个在第三大点的第二小点出现的情况）
2.3 运算符有哪些可以重载
运算符重载还是要根据具体的需求来重载，不是所有的运算符都需要重载，就好比方说，日期类的乘法和除法运算符没必要重载，学生类的算术运算符和逻辑运算符一般也不需要重载。但是，在C++里有五种的运算符是不能重载的
它们分别是：注意第一个不是 * ，* 是可以重载的，.* 是不可以的。
- .* ：成员指针运算符
- :: ：作用域解析运算符
- sizeof：大小运算符
- ?: ：条件运算符
- . ：成员访问运算符
很多情况我们没见过 .* ，（我参考的是链接）
来看以下代码：
class Testpm
{
public:
void m_func1()
{
cout << "m_func1\n";
}
int m_num;
};
void (Testpm::* pmfn)() = &Testpm::m_func1;
// 定义指向类成员函数的指针 pmfn，Testpm::* 表示这是一个指向 Testpm 类的成员函数的指针
int Testpm::* pmd = &Testpm::m_num;
//定义指向类成员变量的指针 pmd，Testpm::* 表示这是一个指向 Testpm 类的成员变量的指针
int main()
{
Testpm ATestpm;
//对象实例化
Testpm* pTestpm = new Testpm;
//Testpm*: 这表示 pTestpm 是一个指向 Testpm 类型的指针。
//new Testpm: 这是使用 new 运算符创建 Testpm 类的一个实例。
//new 运算符动态地分配内存来存储对象，并返回指向该对象的指针。
//在这里，我们创建了一个 Testpm 类的对象，并将其地址赋值给 pTestpm 指针。
// 访问类对象成员函数
(ATestpm.*pmfn)();
//通过实例对象调用成员函数
//pmfn是指针，它被解引用以获取成员函数的地址。
(pTestpm->*pmfn)();
//x-> == (*x).
//(pTestpm->*pmfn)(); == ((*pTestpm).*pmfn)
//通过指针对象调用成员函数。由于 * 的优先级低于函数调用，所以需要使用括号
// 访问成员变量
ATestpm.*pmd = 1;
//通过实例对象访问成员变量
pTestpm->*pmd = 2;
//通过指针对象访问成员变量
cout << ATestpm.*pmd << endl
// 输出实例对象的成员变量
<< pTestpm->*pmd << endl;
// 输出指针对象的成员变量
delete pTestpm;
}我在其中加了许多注释，希望对大家有帮助，如果有想共同探讨的地方，可以在评论区留言。
2.4 赋值运算符重载
在这里我们插入一个赋值运算符的用法，注意这里要和拷贝构造区分开，拷贝构造是同类型一个存在的对象进行初始化要创建的对象，赋值重载是将已经存在的对象，一个拷贝赋值给另一个
赋值运算符重载格式：
参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值检测是否自己给自己赋值
返回*this ：要符合连续赋值的含义
例如：将其写在学生类当中，我们在 main函数中就可以用，那这个赋值是不支持连续赋值的。
void operator=(const Student& s)
{
strcpy(_name, s._name);
_year = s._year;
_month = s._month;
_day = s._day;
}
int main()
{
Student stu1;
stu1.Init("zhangsan", 2023, 9, 9);
Student stu2;
stu2.Init("wangming", 2022, 9, 15);
stu1 = stu2;
stu1.Print();
return 0;
}例如：要支持连续赋值，我们就得有返回值，注意，这里是传值返回会生成拷贝，所以可以用引用来提高效率。
Student& operator=(const Student& s)
{
strcpy(_name, s._name);
_year = s._year;
_month = s._month;
_day = s._day;
return *this;
}但是还存在问题，如果是自己给自己赋值呢？那我们就需要增加一个判断。
Student& operator=(const Student& s)
{
if (this != &s)
{
strcpy(_name, s._name);
_year = s._year;
_month = s._month;
_day = s._day;
}
return *this;
}三、如何解决private限定访问情况？
3.1 使用成员函数来获取成员变量
如果想要获取成员变量的值，我们可以通过使用 GetYear()、GetMonth() 和 GetDay() 这些公有的访问函数，来获取成员变量的值，注意，在这些公有的访问函数背后我们写上了 const，const成员函数是一种特殊类型的成员函数，在之后的学习我们也会涉及到。
class Student
{
public:
void Init(const char* name,int year,int month,int day)
{
strcpy(_name, name);
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << "学生姓名：" << _name << endl;
cout << "学生入学时间："
<< _year << "/"
<< _month << "/"
<< _day
<< endl;
}
int GetYear() const
{
return _year;
}
int GetMonth() const
{
return _month;
}
int GetDay() const
{
return _day;
}
private:
char _name[20];
int _year;
int _month;
int _day;
};
bool student_compare(const Student& s1, const Student& s2)
{
if (s1.GetYear() < s2.GetYear())
{
return true;
}
else if (s1.GetYear() == s2.GetYear())
{
if (s1.GetMonth() < s2.GetMonth())
{
return true;
}
else if (s1.GetMonth() == s2.GetMonth())
{
if (s1.GetDay() < s2.GetDay())
{
return s1.GetDay() < s2.GetDay();
}
}
}
return false;
}3.2 运算符重载作为类成员函数
作为类成员函数的时候，一定要注意隐含的 this 指针
class Student
{
public:
void Init(const char* name,int year,int month,int day)
{
strcpy(_name, name);
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << "学生姓名：" << _name << endl;
cout << "学生入学时间："
<< _year << "/"
<< _month << "/"
<< _day
<< endl;
}
bool student_compare(const Student& s1)
{
if (_year < s1._year)
{
return true;
}
else if (_year == s1._year)
{
if (_month < s1._month)
{
return true;
}
else if (_month == s1._month)
{
if (_day < s1._day)
{
return _day < s1._day;
}
}
}
return false;
}
private:
char _name[20];
int _year;
int _month;
int _day;
};
int main()
{
Student stu1;
stu1.Init("zhangsan", 2023, 9, 9);
Student stu2;
stu2.Init("wangming", 2022, 9, 15);
cout << stu1.student_compare(stu2) << endl;
cout << stu2.student_compare(stu1) << endl;
return 0;
}我们在调用的情况往往是 stu1.student_compare（stu2），stu1 对象会传给隐含的 this 指针，从而在传参数的时候，只用把stu2/stu1写于括号内即可。
3.3 友元
通过将 student_compare 声明为 Student 类的友元函数，它就可以直接访问 Student 类的私有成员 _year、_month 和 _day，从而解决了私有成员访问限定的问题。
class Student
{
public:
void Init(const char* name,int year,int month,int day)
{
strcpy(_name, name);
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << "学生姓名：" << _name << endl;
cout << "学生入学时间："
<< _year << "/"
<< _month << "/"
<< _day
<< endl;
}
//友元声明
friend bool student_compare(const Student& s1, const Student& s2);
private:
char _name[20];
int _year;
int _month;
int _day;
};总结：
- 运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表
- 运算符重载不能通过连接其他符号来创建新的操作符
- 运算符重载还是要根据具体的需求来重载，不是所有的运算符都需要重载
- 不能重载内置类型的运算符行为
- 赋值运算符要支持连续赋值
- .* :: sizeof ?: . 这5个运算符不能重载
- 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的 this 指针
参考：
指向成员的指针运算符：“.*”和“->*” | Microsoft Learn
感谢各位同伴的支持，本期C++篇就讲解到这啦，如果你觉得写的不错的话，可以给个一键三连，点赞关注+收藏，若有不足，欢迎各位在评论区讨论。
7737
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
