• C++初阶 | [三] 类和对象（中）

    摘要：类的6个默认成员函数，日期类

    如果一个类中什么成员都没有，简称为空类。然而，空类并不是什么成员都没有，任何类在什么都不写时，编译器会自动生成6个默认成员函数。默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

    d830f19069b64fedaf2db4eaf7195e58.png

    (ps.下文中标题右上角有数字标识的为6个默认成员函数的内容，以示区分) 

    1. 构造函数_Constructor¹

    构造函数：创建对象？❌ → 初始化 ✔

    features

    1. 函数名同类名相同
    2. 没有返回值（void）
    3. 对象实例化时编译器自动调用80ed5ff83b004172babc0c305b56a511.gif
    4. 可以实现重载
    5. 构造函数不写编译器会默认生成

    注意 warning：

    • 无参和全缺省会存在歧义，调用的时候不明确，建议实现全缺省构造函数。1f07bc9e33f04cf19bada572c98efdb7.png
    • 调用无参构造函数时，不要加括号，这样写同样会引起歧义，编译器分不清是对象还是函数声明 （ e.g.Date d2();  函数声明——Type function_name(parameter list(可为空))。
    • 构造函数不可以显式调用！

    默认构造函数：可以不用传参的构造函数（包括自己没有显式写构造函数而编译器自动生成的，默认构造函数有且只有一个）即无参或全缺省构造函数。

    自动生成的构造函数

    1. 自己不写编译器才会自动生成，写了编译器就不会再自动生成其他构造函数。
    2. 自动生成的构造函数对 内置类型 不做处理（对于自定义类型会因具体的编译器而异，语法上规定不做处理，但可能有的编译器会处理），针对这个内置类型不处理的问题，C++11支持在声明处给缺省值，其他地方都没有给初始化值就会用缺省值初始化。（注意：所有的指针都是内置类型，自定义类型的指针也是内置类型！）b6efd991cb4d47c9b168ce90f5b30f7f.png
    3. 对于 自定义类型 会自动调用其自己的默认构造函数。3e9749743fb945fb8dcbfbb74ac73635.png

    sum.真正便捷的是自动调用 

    2. 析构函数_Destructor²

    析构函数：销毁对象?❌(出作用域生命结束编译器自动销毁) → 完成对象中的资源清理工作 ✔

    features

    1. 函数名为：~类名
    2. 没有返回值（void），没有参数
    3. 有且只有一个，不可重载（都没有参数肯定无法构成函数重载）
    4. 对象生命周期结束自动调用，调用顺序遵循栈后进先出的原则，即后定义的先析构
    5. 同构造函数一样，自己不写编译器会自动生成

    什么情况下需要自己写析构函数？

    10367a0783aa4f84aa40190502265599.png

    3. 拷贝构造_Copy Constructor³

    （注：拷贝构造函数也是构造函数）

    值拷贝/浅拷贝

    值拷贝：将数据内容完全一样地拷贝一份。但在有些场景中，值拷贝会导致一些问题，如下图所示。

    如何解决两次调用析构函数的问题？

    1. 传值传参 → 传引用传参
    2. 实现拷贝构造函数实现深拷贝，如下图（传值传参时，对于自定义类型会调用拷贝构造函数）

    features

    1. 拷贝构造是构造函数的一个函数重载——函数名为类名，没有返回值。
    2. 拷贝构造参数必须传引用传参（这里的引用推荐加 const 以免将要被拷贝的对象被修改）。否则会导致无穷调用：调用拷贝构造函数 → 传值传参 → 值拷贝 → 调用拷贝构造 →…（示例如下图）

     正确的拷贝构造函数示例：

    1. class Date
    2. {
    3. public:
    4. 	Date(const int year = 1, const int month = 1, const int day = 1)//全缺省构造函数
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10.  
    11. 	Date(const Date& d)//copy constructor
    12. 	{
    13. 		_year = d._year;
    14. 		_month = d._month;
    15. 		_day = d._day;
    16. 	}
    17. private:
    18. 	int _year;
    19. 	int _month;
    20. 	int _day;
    21. };

    自动生成的默认拷贝构造

    1. 对于 内置类型 值拷贝（例如对于上述日期类不用自己写拷贝构造，值拷贝已经能够满足需求）
    2. 对于 自定义类型 自动调用拷贝构造函数

    4.操作符重载_operator

    1. class Date
    2. {
    3. public:
    4. 	Date(const int year = 1, const int month = 1, const int day = 1)//全缺省构造函数
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10.  
    11. 	bool operator<(const Date& d)//操作符重载
    12. 	{
    13. 		if (_year < d._year)
    14. 			return true;
    15. 		else if (_year == d._day && _month < d._month)
    16. 			return true;
    17. 		else if (_year == d._day && _month == d._month && _day < d._day)
    18. 			return true;
    19. 		else
    20. 			return false;
    21. 	}
    22. private:
    23. 	int _year;
    24. 	int _month;
    25. 	int _day;
    26. };
    27.  
    28. int main()
    29. {
    30. 	Date d1(2022, 2, 3);
    31. 	Date d2(2022, 1, 4);
    32.  
    33. 	cout << (d1 < d2)<
    34.  
    35. 	return 0;
    36. }

    注：上述代码中 d1  (编译器会自动转化为这样显式的调用，所以这与调用其他成员函数是一样的)，隐藏的参数 this指针 指向该重载操作符的左操作数 d1，传递的参数 d2 为右操作数。

    Rules

    1. 不能创造原本没有的操作符。（e.g.operator@）
    2. 参数中必须有一个自定义类型。
    3. 不能改变操作符原本的含义。
    4. 对于成员函数，第一个参数为 this 指针。即 this 指针所指向的对象一定是操作符的左操作数。
    5. 5个不能重载的操作符：::     ?:    .*   sizeof    .

    A major design goal of C++ is to let programmers define their own types that are as easy to use as the built-in types.

    ——《C++ Primer》

    操作符重载使得使用自定义类型就像使用内置类型一样便捷。 

    5.class Date

    1）成员函数声明和定义分离：

    类内声明，内外定义。

    1. 缺省值应在函数声明时给出，定义处不能再次定义缺省值，会引发重定义错误。
    2. 定义成员函数要指明类域（在返回值类型之后，函数名之前）——Type classname::function_name(parameter list)

    2）constructor：

    • 注意检查日期是否合法（传参可能传递非法日期 ）→ 年份没有限制，月份必须在 [1,12] 的区间内，日期受到年份(闰年)和月份的限制。

    （下述代码补充说明：GetMonthDay 函数中的 array 用 static 修饰是因为考虑到会频繁调用该函数，导致频繁开辟 array 空间，所以选择将 array 的数据放置在静态区，减少重复开空间，warning：不要对该数组里的数据进行修改！数据存储在静态区，每次调用该函数，修改的行为会被不断累积！！出于这样的考虑，array 可以加 const 保护）

    1. int GetMonthDay(const int year, const int month)
    2. {
    3. 	static int array[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    4. 	if (month == 2)
    5. 	{
    6. 		if (((year % 100 != 0) && (year % 4 == 0)) || (year % 400 == 0))
    7. 			///++array[2];//error!!!!!!!!!!!!!
    8.             return 29;
    9. 	}
    10. 	return array[month];
    11. }
    12.  
    13. Date::Date(const int year, const int month, const int day)
    14. {
    15. 	if (month <= 12 && day <= GetMonthDay(month))
    16. 	{
    17. 		_year = year;
    18. 		_month = month;
    19. 		_day = day;
    20. 	}
    21. 	else
    22. 	{
    23. 		_year = _month = _day = 0;
    24. 		cout << "日期非法" << endl;
    25. 	}
    26. }

    3）赋值重载_operator=⁴

    ①赋值与拷贝构造的区别：

    赋值重载：将一个变量中的数据 赋 给另一个变量

    拷贝构造：用一个已经存在的对象来创建一个新的对象（构造函数主要是完成初始化工作，定义一个自定义类型的变量时会自动调用构造函数！）

    ②连续赋值

    赋值的结果返回Date对象（推荐传引用返回）

    ③ 自己给自己赋值

    自己给自己赋值，即 this 指针与传引用传参的参数表示的是同一个存储空间，所以不用继续进行赋值直接返回。综合上述所说，示例代码如下：

    1. const Date& Date::operator=(const Date& d)
    2. {
    3. 	if (this == &d)
    4. 		return *this;
    5.  
    6. 	_year = d._year;
    7. 	_month = d._month;
    8. 	_day = d._day;
    9. 	return d;
    10. }

    ④自动生成默认赋值重载函数 

    同构造函数和析构函数一样，自己不写会自动生成。自动生成的默认赋值重载函数会完成值拷贝。对于日期类，值拷贝已经可以满足需求，因此可以不用自己写赋值重载函数。

    4）其他常用操作符重载：

    ①+= 与 +

    1. 复用的问题：①operator+ 复用 operator+= 两次调用拷贝构造；②operator+= 复用 operator+ 四次调用拷贝构造，一次赋值。所以选择operator+ 复用 operator+= 更好。
    2.  += 负数：注意传参可能为负值的情况

    示例代码：

    1. Date& Date::operator+=(int days)
    2. {
    3. 	if (days < 0)
    4. 		days = -days;
    5.  
    6. 	_day += days;
    7. 	int _month_max_day = GetMonthDay(_year, _month);
    8. 	while (_day > _month_max_day)
    9. 	{
    10. 		_day -= _month_max_day;
    11.  
    12. 		//处理月份
    13. 		++_month;
    14. 		if (_month > 12)
    15. 		{
    16. 			++_year;
    17. 			_month = 1;
    18. 		}
    19.  
    20. 		//更新月最大天数
    21. 		_month_max_day = GetMonthDay(_year, _month);
    22.  
    23. 	}
    24. 	return *this;
    25. }
    26.  
    27. Date Date::operator+(const int days) const
    28. {
    29. 	Date tmp(*this);
    30. 	tmp += days;
    31. 	return tmp;
    32. }

    ②前置++ 与 后置++

    后置++ 的操作符重载中，语法规定通过参数 int 与前置++构成函数重载，int 只是用来占位，具体传什么内容由编译器处理。例如如下代码的函数声明：（再次提醒只是返回值不同不能构成函数重载）

    1. Date& operator++();//前置++
    2. Date operator++(int);//后置++

    5）日期 - 日期 运算

    • 方式一：直接算
    • 方式二：让 小日期++ 直到 等于 大日期，++多少次就相差多少天（其中要用到比较大小的操作符，关于这些操作符的重载在本文第4部分——操作符重载——有一处示例，实现其中一个操作符，其他可以复用，思路简单，在此不多做赘述。以下提供一个实现日期相减的函数示例） 
      1. int Date::operator-(const Date& d) const
      2. {
      3. 	int cout = 0, flag = 1;
      4. 	Date Max_date = *this;
      5. 	Date Min_date = d;
      6. 	if (d > *this)
      7. 	{
      8. 		flag = -1;
      9. 		Max_date = d;
      10. 		Min_date = *this;
      11. 	}
      12. 	while (Min_date < Max_date)
      13. 	{
      14. 		++cout;
      15. 		++Min_date;
      16. 	}
      17. 	return cout*flag;
      18. }

    6. const 对象

    在 C++ 入门一文中在介绍常引用(const 引用)时，讨论了关于权限放大的问题，同样，对于 const对象 来说，它们无法调用 非const成员函数——因为会导致权限放大的问题。

     由上图不难看出，一个函数 const 版本和 非const版本 可以构成函数重载——参数类型不同，this指针的类型分别是 const Type* const 和 Type* const (例如，对于operator[]的操作符重载就很有必要实现 const 和 非const 两个版本)

    • 建议：不做修改的成员函数都加 const 修饰，注意互相复用的函数之间会相互影响！

    7. 取地址重载⁵ 及 const 对象取地址⁶

    这两个默认成员函数一般不用重新定义 ，编译器默认会生成。这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

    1. class Date
    2. {
    3. public:
    4. 	const Date* operator&()const
    5. 	{
    6. 		return nullptr;
    7. 	}
    8.  
    9. private:
    10. 	int _year;
    11. 	int _month;
    12. 	int _day;
    13. };

     8. 补充：流插入和流提取操作符重载

     以上，我们可以了解到，流提取 >> 的左操作数为 cin —— 一个类型为 istream 的对象，右操作数为一个内置类型的变量，同理，流插入 << 的左操作数为 cout —— 一个类型为 ostream 的对象，右操作数为一个内置类型的变量。

    接下来，我们尝试对日期类的对象实现流插入和流提取的操作符重载（以流提取 >> 为例，流插入同理）：因为日期类的成员变量私有，在类外无法访问，所以我们尝试在类内实现。同时，考虑到连续流插入/流提取，返回值类型应为ostream/istream。如下代码。

    1. class Date
    2. {
    3. public:  
    4.     ostream& operator<<(ostream& out)
    5.     {
    6. 	    out << _year << "/" << _month << "/" << _day << endl;
    7. 	    return out;
    8.     }
    9. private:
    10. 	int _year;
    11. 	int _month;
    12. 	int _day;
    13. };

    在上述代码中， 可以看到，第一个参数为 隐藏的this指针 ，第二个参数为 ostream对象的引用。则调用该函数即为：d(Type:Date)<，显然，这样的实现是符合该操作符原本的使用习惯的，在类内实现第一个参数必为 隐藏的this指针，所以考虑在类外实现该函数，为了能够访问内部成员变量，需要用到友元声明（详见类和对象下）。

    1. class Date
    2. {
    3. public:
    4. 	friend ostream& operator<<(ostream& out, Date d);
    5.  
    6. private:
    7. 	int _year;
    8. 	int _month;
    9. 	int _day;
    10. };
    11.  
    12.  
    13. ostream& operator<<(ostream& out, Date d)
    14. {
    15. 	out << d._year << "/" << d._month << "/" << d._day << endl;
    16. 	return out;
    17. }

    cin/cout 的意义：针对自定义类型可以实现重载（scanf/printf 不能很好地支持自定义类型）；能够自动识别类型（例如对于 printf 函数如果数据类型改变，相应地也要改变打印格式）

    END

  • 相关阅读:
    Debian系列-系统安装及Qt基础开发环境配置
    efcore如何优雅的实现按年分库按月分表
    【进程概念④】：进程地址空间(虚拟内存与物理内存)
    桂林电子科技大学计算机考研资料汇总
    linux服务器slab缓存回收方案设计
    CVE-2021-31805_Struts2-062远程代码执行漏洞复现
    你有一份斗破苍穹词库，请查收
    openwrt开启SSH远程访问与开启WEB远程访问——三种方法
    《代码随想录》三刷，与诸君共勉，秋招见！
    医学心脏数据集分割建模实战
  • 原文地址：https://blog.csdn.net/fantastic_13_7/article/details/134326913