• 【C++初阶】日期类实现、const成员函数、取地址及const取地址操作符重载

    🌟hello，各位读者大大们你们好呀🌟

    🍭🍭系列专栏：【C++学习与应用】

    ✒️✒️本篇内容：日期类的代码实现、const成员函数的概念和作用、取地址及const取地址操作符重载

    🚢🚢作者简介：计算机海洋的新进船长一枚，请多多指教( •̀֊•́ ) ̖́-

    📡📡同期文章：【C++初阶】简析构造函数、析构函数

                               【C++初阶】简析拷贝构造、赋值运算符重载

    目录

    一、引言

    二、日期类

    1. 获取某年某月的天数

    2.全缺省的构造函数

    3.拷贝构造函数

    4.赋值运算符重载

    5.析构函数 

    6.日期+天数

    7.日期+=天数

    8.日期-天数

    9.日期-=天数

    10.前置++

    11.后置++

    12.前置--

    13.后置--

    14.>运算符重载

    15.==运算符重载

    16.>=运算符重载 

    17.<运算符重载

    18.<=运算符重载

    19.!=运算符重载

    20.日期-日期 返回天数

    三、const成员函数

    四、取地址及const取地址操作符重载

    一、引言

    之前我们学习了赋值运算符重载的相关知识，今天就让我们一起通过日期类实现，用代码来实践一下赋值运算符重载，深入了解部分代码细节。

    学习完日期类的实现后，我们再进入下一块知识：const成员，取地址及const取地址操作符重载，领会C++设立const成员语法的意义。

    二、日期类

    日期类计划主要用代码讲解，以下讲解的函数主要为类的成员函数

    1. 获取某年某月的天数

    1.     // 获取某年某月的天数
    2.     int GetMonthDay(int year, int month)
    3. 	{
    4. 		static int monthDayArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    5. 		if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
    6. 		{
    7. 			return 29;
    8. 		}
    9. 		else
    10. 		{
    11. 			return monthDayArray[month];
    12. 		}
    13. 	}

    2.全缺省的构造函数

    1. 	// 全缺省的构造函数
    2. 	Date(int year = 1900, int month = 1, int day = 1)
    3. 	{
    4. 		_year = year;
    5. 		_month = month;
    6. 		_day = day;
    7.  
    8. 		// 检查日期是否合法
    9. 		if (!(year >= 1
    10. 			&& (month >= 1 && month <= 12)
    11. 			&& (day >= 1 && day <= GetMonthDay(year, month))))
    12. 		{
    13. 			cout << "非法日期" << endl;
    14. 		}
    15. 	}

    3.拷贝构造函数

    1. 	// 拷贝构造函数
    2.     // d2(d1)
    3. 	Date(const Date& d)
    4. 	{
    5. 		_year = d._year;
    6. 		_month = d._month;
    7. 		_day = d._day;
    8. 	}

    4.赋值运算符重载

    1. 	// 赋值运算符重载
    2. 	// d2 = d3 -> d2.operator=(&d2, d3)
    3. 	Date& operator=(const Date& d)
    4. 	{
    5. 		if (this != &d)
    6. 		{
    7. 			_year = d._year;
    8. 			_month = d._month;
    9. 			_day = d._day;
    10. 		}
    11.  
    12. 		return *this;
    13. 	}

    5.析构函数 

    由于是日期类，对象都是内置类型，我们可以使用编译器默认生成的析构函数

    6.日期+天数

    1. 	// 日期+天数
    2. 	//	Date Date::operator+(int day) const - 声明定义分离写法
    3. 	Date operator+(int day)
    4. 	{
    5. 		Date ret(*this);
    6. 		ret += day;
    7. 		return ret;
    8. 	}

    7.日期+=天数

    1. 	// 日期+=天数
    2. 	//	Date& Date::operator+=(int day) - 声明定义分离写法
    3. 	Date& operator+=(int day)
    4. 	{
    5. 		if (day < 0)
    6. 		{
    7. 			//return *this -= -day;
    8. 			return *this -= abs(day);//abs求绝对值
    9. 		}
    10.  
    11. 		_day += day;
    12.  
    13. 		while (_day > GetMonthDay(_year, _month))//day>某年某月的天数
    14. 		{
    15. 			_day -= GetMonthDay(_year, _month);
    16. 			_month++;
    17.  
    18. 			if (_month == 13)//超过12月，加1年，月回1
    19. 			{
    20. 				++_year;
    21. 				_month = 1;
    22. 			}
    23. 		}
    24.  
    25. 		return *this;
    26. 	}

    8.日期-天数

    1. 	// 日期-天数
    2. 	//	Date Date::operator-(int day) const - 声明定义分离写法
    3. 	Date operator-(int day)
    4. 	{
    5. 		Date ret(*this);
    6. 		ret -= day;
    7.  
    8. 		return ret;
    9. 	}

    9.日期-=天数

    1. 	// 日期-=天数
    2. 	//	Date& Date::operator-=(int day) - 声明定义分离写法
    3. 	Date& operator-=(int day)
    4. 	{
    5. 		if (day < 0)
    6. 		{
    7. 			//return *this -= -day;
    8. 			return *this += abs(day);
    9. 		}
    10.  
    11. 		_day -= day;
    12.  
    13. 		while (_day <= 0)
    14. 		{
    15. 			--_month;
    16. 			if (_month == 0)
    17. 			{
    18. 				--_year;
    19. 				_month = 12;
    20. 			}
    21.  
    22. 			_day += GetMonthDay(_year, _month);
    23. 		}
    24.  
    25. 		return *this;
    26. 	}

    10.前置++

    1. 	// 前置++
    2. 	//	Date& Date::operator++() - 声明定义分离写法
    3. 	Date& operator++()
    4. 	{
    5. 		*this += 1;
    6. 		return *this;
    7. 	}

    11.后置++

    1. 	// 后置++
    2. 	//	Date Date::operator++(int) - 声明定义分离写法
    3. 	Date operator++(int)
    4. 	{
    5. 		Date tmp(*this);
    6.  
    7. 		*this += 1;
    8.  
    9. 		return tmp;
    10. 	}

    12.前置--

    1. 	// 前置--
    2. 	//	Date& Date::operator--() - 声明定义分离写法
    3. 	Date& operator--()
    4. 	{
    5. 		*this -= 1;
    6. 		return *this;
    7. 	}

    13.后置--

    1.     // 后置--
    2. 	//	Date Date::operator--(int) - 声明定义分离写法
    3. 	Date operator--(int)
    4. 	{
    5. 		Date tmp = *this;
    6. 		*this -= 1;
    7.  
    8. 		return tmp;
    9. 	}

    14.>运算符重载

    1. 	// >运算符重载
    2. 	//	bool Date::operator>(const Date& d) const - 声明定义分离写法
    3. 	bool operator>(const Date& d)
    4. 	{
    5. 		if (_year > d._year)
    6. 		{
    7. 			return true;
    8. 		}
    9. 		else if (_year == d._year && _month > d._month)
    10. 		{
    11. 			return true;
    12. 		}
    13. 		else if (_year == d._year && _month == d._month && _day > d._day)
    14. 		{
    15. 			return true;
    16. 		}
    17.  
    18. 		return false;
    19. 	}

    15.==运算符重载

    1. 	// ==运算符重载
    2. 	bool operator==(const Date& d) - 声明定义分离写法
    3. 	{
    4. 		return _year == d._year
    5. 			&& _month == d._month
    6. 			&& _day == d._day;
    7. 	}

    16.>=运算符重载 

    1. 	// >=运算符重载
    2. 	//	bool Date::operator>=(const Date& d) const - 声明定义分离写法
    3. 	bool operator >= (const Date& d)
    4. 	{
    5. 		return *this > d || *this == d;
    6. 	}

    17.<运算符重载

    1. 	// <运算符重载
    2. 	//	bool Date::operator<(const Date& d) const - 声明定义分离写法
    3. 	bool operator < (const Date& d)
    4. 	{
    5. 		return !(*this >= d);
    6. 	}

    18.<=运算符重载

    1. 	// <=运算符重载
    2. 	//	bool Date::operator<=(const Date& d) const - 声明定义分离写法
    3. 	bool operator <= (const Date& d)
    4. 	{
    5. 		return !(*this > d);
    6. 	}

    19.!=运算符重载

    1. 	// !=运算符重载
    2. 	//	bool Date::operator!=(const Date& d) const - 声明定义分离写法
    3. 	bool operator != (const Date& d)
    4. 	{
    5. 		return !(*this == d);
    6. 	}

    20.日期-日期 返回天数

    1. 	// 日期-日期 返回天数
    2. 	//int Date::operator-(const Date& d) const - 声明定义分离写法
    3. 	int operator-(const Date& d)
    4. 	{
    5. 		Date max = *this;
    6. 		Date min = d;
    7. 		int flag = 1;
    8.  
    9. 		if (*this < d)
    10. 			//if (d > *this)
    11. 		{
    12. 			max = d;
    13. 			min = *this;
    14. 			flag = -1;
    15. 		}
    16.  
    17. 		int n = 0;
    18. 		while (min != max)
    19. 		{
    20. 			++n;
    21. 			++min;
    22. 		}
    23.  
    24. 		return n * flag;
    25. 	}

    三、const成员函数

    用const修饰的“成员函数”称之为const成员函数，const修饰类的成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

    在下图中，左图和右图代表的含义实际上是相同的，我们可以将右图看为是作图的展开

    下面我们一起看一段代码 

    1. class Date
    2. {
    3. public:
    4. 	Date(int year, int month, int day)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10. 	void Print()
    11. 	{
    12. 		cout << "Print()" << endl;
    13. 		cout << "year:" << _year << endl;
    14. 		cout << "month:" << _month << endl;
    15. 		cout << "day:" << _day << endl << endl;
    16. 	}
    17. 	void Print() const
    18. 	{
    19. 		cout << "Print()const" << endl;
    20. 		cout << "year:" << _year << endl;
    21. 		cout << "month:" << _month << endl;
    22. 		cout << "day:" << _day << endl << endl;
    23. 	}
    24. private:
    25. 	int _year; // 年
    26. 	int _month; // 月
    27. 	int _day; // 日
    28. };
    29.  
    30. int main()
    31. {
    32. 	Date d1(2022, 1, 13);
    33. 	d1.Print();
    34.  
    35. 	const Date d2(2022, 1, 13);
    36. 	d2.Print();
    37. 	return 0;
    38. }

    它的输出结果如下

    通过结果我们可以知，d2.Print() 和 d1.Print() 调用的函数并不相同，因为在定义 Date d2时，在前面加上了const ，因此调用的函数不能更改 d2，否则就造成了权限放大，编译器报错，所以编译器会默认调用 void Print() const 函数。

    接下来我们思考一个问题，不要 void Print() 函数可不可以呢？答案是当然可以，默认允许更改->不能更改，实际上时权限的缩小

    光说不练假把式，我们直接编译一下

     从编译结果得证：调用类函数允许权限缩小和平移，不允许权限缩小

    接下来我们再看一组练习强化理解一下：

    1. const对象可以调用非const成员函数吗？

    2. 非const对象可以调用const成员函数吗？

    3. const成员函数内可以调用其它的非const成员函数吗？

    4. 非const成员函数内可以调用其它的const成员函数吗？

    答案：

    1、const对象不能调用非const成员函数，const对象可以调用const成员函数
    2、非const对象可以调用const成员函数，非const对象可以调用非const成员函数
    3、const成员函数不能调用非const成员函数
    4、非const成员函数可以调用非const成员函数

    因此，当我们在使用成员函数需要某些限制时，const成员的作用就凸显出来了。

    四、取地址及const取地址操作符重载

    之前我们就介绍过，类里面有6个默认函数，前四个（构造、析构、拷贝、赋值重载）我们都在前面的博客详细解说过了，今天我们就继续来谈谈最后两个默认函数，取地址及const取地址操作符重载。

    事实上，取地址及const取地址操作符重载，这两种默认函数需要我们显式实现的情况少之又少，编译器已经基本帮我们准备好了。所以我们简单了解一下即可。

    1. class Date
    2. {
    3. public:
    4. 	Date* operator&()    //取地址操作符重载
    5. 	{
    6. 		return this;
    7. 	}
    8.  
    9. 	const Date* operator&()const    //const取地址操作符重载
    10. 	{
    11. 		return this;
    12. 	}
    13. private:
    14. 	int _year; // 年
    15. 	int _month; // 月
    16. 	int _day; // 日
    17. };

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

    🌹🌹今天的内容大概就讲到这里啦，博主后续会继续向大家介绍更多实用有趣的工具，干货满满，如果觉得博主写的还不错的话，希望各位小伙伴不要吝啬手中的三连哦！你们的支持是博主坚持创作的动力！💪💪

  • 相关阅读:
    《大数据之路：阿里巴巴大数据实践》-第1篇 数据技术篇 -第3章数据同步
    【D3.js】1.15-反转 SVG 元素
    可制造性评估（DFM）
    windows设置右键打开 vscode的方法（简易版）
    C语言_指针进阶（下）
    图像修复：使用pytorch实现context encoders
    Spring系列-细说bean标签的parent属性使用
    原型和原型链
    【Android知识笔记】性能优化专题（三）
    nginx 负载均衡
  • 原文地址：https://blog.csdn.net/Captain_ldx/article/details/127334021