手册   游戏   WEB   字典   单词   在线工具  

[C++] 运算符重载, 友元 ------ 类和对象练习 ------ 日期类的实现

1. 前言

阅读本文的预备知识:

构造函数, 拷贝构造, 拷贝构造

类访问限定符

类的实例化

this 指针

引用返回

目录:

运算符重载

友元函数, 友元类, 内部类

日期类

在我们快速入门了 C++ 以后, 首当其冲的便是学习 C++ 基于面向对象的特性.

我们将事物抽象成一个类, 再通过 "类" 这张图纸实例化出一个个具体的对象, 在封装的特点下管理对象的数据与方法

2. 运算符重载

我们的加减乘除等算术运算符和 > <== 等关系运算符以及 = 赋值运算符天然能够操作 int,float 等内置类型数据; 但是对于自定义类型的数据, 比如说我们的类, 由于类之间的运算, 比较等操作会根据具体一个类的属性的变化而变化, 所以运算符的默认用法已经满足不了我们的需求了

于是, 我们需要自定义运算符在类层面上的用法, 就有了运算符重载

我们是这样重载一个运算符的:

返回值 operator 运算符 (参数){

// 实现

}

注意:

重载之后的运算符的用法, 参数位于运算符左右的位置应与常见用法一致

第一个参数是默认没写的 this 指针

运算符重载可以在类里面声明和定义, 但是这样做的话第一个参数就一定是 this 指针了; 我们在重载

流插入 <<, 流提取 >>

时需要注意

运算符还能在类外面重载, 但是这样的话如果想访问私有成员变量, 需要定义友元函数或是定义一个公有函数拿到私有成员变量; 我们在重载

流插入 <<, 流提取 >>

时需要注意

声明定义分离, 定义的时候用加域操作符::

  1. Date& Date::operator+=(int day) {
  2. 	// 实现
  3. }

有五个操作符不能重载

  1. .*
  2. ?:
  3. ::
  4. sizeof
  5. .

3. 友元

3.1 友元函数

全局函数不在类内部, 无法访问私有成员函数, 怎么办?

我有一个朋友

我要访问你, 在你内部声明: 我是你的友元

友元函数可以直接访问类的私有成员, 它是定义在类外部的普通函数, 不属于任何类, 但需要在类的内部声明, 声明时需要加 friend 关键字.

这样就把全局函数变成了一个类的友元, 该函数可肆无忌惮访问类的私有成员变量了

  1. friend ostream& operator<<(ostream& out, const Date& d);
  2. friend istream& operator>>(istream& in, Date& d);

说明:

友元函数可访问类的私有和保护成员, 但

不是类的成员函数

友元函数

不能用 const 修饰

友元函数可以

在类定义的任何地方声明

, 不受类访问限定符限制, 我喜欢写在类的开头

一个函数可以是多个类的友元函数

友元函数的调用与普通函数的调用和原理相同

3.2 友元类

那么友元类, 就是一个类能肆无忌惮访问其他类的私有成员变量

注意:

友元关系是单向的, 不具有交换性:

你把我当朋友, 我不一定把你当朋友

比如上述 Time 类和 Date 类, 在 Time 类中声明 Date 类为其友元类, 那么可以在 Date 类中直接访问 Time

类的私有成员变量, 但想在 Time 类中访问 Date 类中私有的成员变量则不行.

友元关系不能传递

如果 B 是 A 的友元, C 是 B 的友元, 则不能说明 C 时 A 的友元.

friend class Date;

3.3 内部类

至于内部类, 即类里面再定义一个类; 此时这个内部类是一个独立的类, 它不属于外部类, 更不能通过

外部类的对象去调用内部类

内部类就是外部类的友元类. 注意友元类的定义, 内部类可以通过外部类的对象参数来访问外部类中

的所有成员. 但是外部类不是内部类的友元.

注意:

内部类可以定义在外部类的 public,protected,private 都是可以的.

注意内部类可以直接访问外部类中的 static, 枚举成员, 不需要外部类的对象 / 类名.

sizeof(外部类)= 外部类, 和内部类没有任何关系.

  1. class A {
  2. private:
  3. 	static int k;
  4. 	int h;
  5. public:
  6. 	class B {
  7. 	public:
  8. 		void foo(const A& a) {
  9. 			cout <<k << endl;//OK
  10. 			cout << a.h << endl;//OK
  11. 		}
  12. 	};
  13. };
  14. int A::k = 1;
  15. int main() {
  16. 	A::B b;
  17. 	b.foo(A());
  18. 	return 0;
  19. }

4. 日期类

  1. Date.h
  2. #pragma once
  3. #include <iostream>
  4. using namespace std;
  5. class Date {
  6. 	friend void Print(const Date& d);
  7. 	friend ostream& operator<<(ostream& out, const Date& d);
  8. 	friend istream& operator>>(istream& in, Date& d);
  9. public:
  10. 	// Get the days of a specific month, using an array to reflect the days
  11. 	int GetDay(int year, int month) {
  12. 		static int dayOfmonth[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
  13. 		if (month == 2 && (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))) {
  14. 			return 29;
  15. 		}
  16. 		else {
  17. 			return dayOfmonth[month];
  18. 		}
  19. 	}
  20. 	// constructor
  21. 	Date(int year = 0, int month = 1, int day = 1) {
  22. 		_year = year;
  23. 		_month = month;
  24. 		_day = day;
  25. 	}
  26. 	// destructor
  27. 	~Date() {
  28. 		_year = 0;
  29. 		_month = 1;
  30. 		_day = 1;
  31. 	}
  32. 	// copy constructor
  33. 	Date(const Date& tmp) {
  34. 		_year = tmp._year;
  35. 		_month = tmp._month;
  36. 		_day = tmp._day;
  37. 	}
  38. 	// Print the date
  39. 	void Print() {
  40. 		if (_year <0 || _month <= 0 || _month> 12 || _day <= 0 || _day> GetDay(_year, _month)) {
  41. 			cout <<_year << '/' << _month << '/' << _day << "------illegal date!" << endl;;
  42. 		}
  43. 		else {
  44. 			cout << _year << '/' << _month << '/' << _day << endl;
  45. 		}
  46. 	}
  47. 	// reload functions
  48. 	// =
  49. 	Date& operator=(const Date& date);
  50. 	// 8 assignment
  51. 	// +=
  52. 	Date& operator+=(int day);
  53. 	// +
  54. 	Date operator+(int day);
  55. 	// -=
  56. 	Date& operator-=(int day);
  57. 	// -
  58. 	Date operator-(int day);
  59. 	// 前置 ++
  60. 	Date& operator++();
  61. 	// 后置 ++
  62. 	Date operator++(int);
  63. 	// 前置 --
  64. 	Date& operator--();
  65. 	// 后置 --
  66. 	Date operator--(int);
  67. 	// 6 comparable operators
  68. 	// ==
  69. 	bool operator==(const Date& d);
  70. 	//>
  71. 	bool operator>(const Date& d);
  72. 	// <	bool operator<(const Date& d);
  73. 	//>=
  74. 	bool operator>=(const Date& d);
  75. 	// <=
  76. 	bool operator<=(const Date& d);
  77. 	// !=
  78. 	bool operator!=(const Date& d);
  79. 	// date minus date -> days intervals
  80. 	int operator-(const Date& d);
  81. private:
  82. 	int _year;
  83. 	int _month;
  84. 	int _day;
  85. };
  86. Date.cpp
  87. #define _CRT_SECURE_NO_WARNINGS 1
  88. 	#include "Date.h"
  89. 	Date& Date::operator=(const Date& date) {
  90. 		if (this != &date) {
  91. 			_year = date._year;
  92. 			_month = date._month;
  93. 			_day = date._day;
  94. 		}
  95. 		return *this;
  96. 	}
  97. 	Date& Date::operator+=(int day) {
  98. 		_day += day;
  99. 		while (_day> GetDay(_year, _month)) {
  100. 			_day -= GetDay(_year, _month);
  101. 			_month++;
  102. 			if (_month == 13) {
  103. 				_year++;
  104. 				_month = 1;
  105. 			}
  106. 		}
  107. 		return *this;
  108. 	}
  109. 	Date Date::operator+(int day) {
  110. 		Date tmp(*this);
  111. 		tmp += day;
  112. 		return tmp;
  113. 	}
  114. 	// -=
  115. 	// method 1
  116. 	//Date& Date::operator-=(int day) {
  117. 	//	while (_day <day) {
  118. 	//		day -= _day;
  119. 	//		_month--;
  120. 	//		if (_month == 0) {
  121. 	//			_year--;
  122. 	//			_month = 12;
  123. 	//		}
  124. 	//		_day = GetDay(_year, _month);
  125. 	//	}
  126. 	//	_day -= day;
  127. 	//	return *this;
  128. 	//}
  129. 	// method 2
  130. 	//Date& Date::operator-=(int day) {
  131. 	//	if (day> _day) {
  132. 	//		day -= _day;
  133. 	//		_month--;
  134. 	//		if (_month == 0) {
  135. 	//			_month = 12;
  136. 	//			_year--;
  137. 	//		}
  138. 	//	}
  139. 	//	while (day> GetDay(_year, _month)) {
  140. 	//		day -= GetDay(_year, _month);
  141. 	//		_month--;
  142. 	//		if (_month == 0) {
  143. 	//			_month = 12;
  144. 	//			_year--;
  145. 	//		}
  146. 	//	}
  147. 	//	_day = GetDay(_year, _month) - day;
  148. 	//	return *this;
  149. 	//}
  150. 	// best method
  151. 	Date& Date::operator-=(int day) {
  152. 		_day -= day;
  153. 		while (_day <= 0) {
  154. 			_month--;
  155. 			if (_month == 0) {
  156. 				_year--;
  157. 				_month = 12;
  158. 			}
  159. 			_day += GetDay(_year, _month);
  160. 		}
  161. 		return *this;
  162. 	}
  163. 	// -
  164. 	Date Date::operator-(int day) {
  165. 		Date tmp(*this);
  166. 		tmp -= day;
  167. 		return tmp;
  168. 	}
  169. 	// 前置 ++
  170. 	Date& Date::operator++() {
  171. 		*this += 1;
  172. 		return *this;
  173. 	}
  174. 	// 后置 ++
  175. 	Date Date::operator++(int) {
  176. 		Date tmp = *this;
  177. 		*this += 1;
  178. 		return tmp;
  179. 	}
  180. 	// 前置 --
  181. 	Date& Date::operator--() {
  182. 		*this -= 1;
  183. 		return *this;
  184. 	}
  185. 	// 后置 --
  186. 	Date Date::operator--(int) {
  187. 		Date tmp = *this;
  188. 		*this -= 1;
  189. 		return tmp;
  190. 	}
  191. 	// ==
  192. 	bool Date::operator==(const Date& d) {
  193. 		return _year == d._year && _month == d._month && _day == d._month;
  194. 	}
  195. 	//>
  196. 	bool Date::operator>(const Date& d) {
  197. 		if (_year> d._year) {
  198. 			return true;
  199. 		}
  200. 		else if (_year == d._year && _month> d._month) {
  201. 			return true;
  202. 		}
  203. 		else if (_year == d._year && _month == d._month && _day> d._day) {
  204. 			return true;
  205. 		}
  206. 		else {
  207. 			return false;
  208. 		}
  209. 	}
  210. 	// <	bool Date::operator<(const Date& d) {
  211. 		return !(*this> d || *this == d);
  212. 	}
  213. 	//>=
  214. 	bool Date::operator>=(const Date& d) {
  215. 		return (*this> d || *this == d);
  216. 	}
  217. 	// <=
  218. 	bool Date::operator<=(const Date& d) {
  219. 		return !(*this> d);
  220. 	}
  221. 	// !=
  222. 	bool Date::operator!=(const Date& d) {
  223. 		return !(*this == d);
  224. 	}
  225. 	// date minus date -> days intervals
  226. 	int Date::operator-(const Date& d) {
  227. 		int i = 0;
  228. 		int flag = 1;
  229. 		Date max = *this;
  230. 		Date min = d;
  231. 		if (max <min) {
  232. 			max = d;
  233. 			min = *this;
  234. 			flag = -1;
  235. 		}
  236. 		while (max> min) {
  237. 			min++;
  238. 			i++;
  239. 		}
  240. 		return i * flag;
  241. 	}
  242. 	// 流插入
  243. 	ostream& operator<<(ostream& out, const Date& d) {
  244. 		out <<d._year << "/" << d._month << "/" << d._day;
  245. 		return out;
  246. 	}
  247. 	 // 流提取
  248. 	istream& operator>>(istream& in, Date& d) {
  249. 		in>> d._year;
  250. 		in>> d._month;
  251. 		in>> d._day;
  252. 		return in;
  253. 	}

流插入, 流提取看上面最后两段代码, 和 Date.h 开头的友元函数声明

  1. test.cpp
  2. #define _CRT_SECURE_NO_WARNINGS 1
  3. #include "Date.h"
  4. void Print(const Date& d) {
  5. 	cout <<d._year << "/" << d._month << "/" << d._day << endl;
  6. }
  7. void Test1() {
  8. 	Date d1(2000, 1, 1);
  9. 	d1.Print();
  10. 	d1 += 100;
  11. 	d1.Print();
  12. 	d1 += 500;
  13. 	d1.Print();
  14. 	d1 -= 500;
  15. 	d1.Print();
  16. 	d1 -= 100;
  17. 	d1.Print();
  18. }
  19. void Test2() {
  20. 	Date d1(2000, 1, 1);
  21. 	Print(d1);
  22. 	Print(d1++);
  23. 	Print(d1);
  24. 	Print(++d1);
  25. 	Print(d1);
  26. 	Print(d1--);
  27. 	Print(d1);
  28. 	Print(--d1);
  29. 	Print(d1);
  30. }
  31. void Test3() {
  32. 	Date d1(2000, 1, 2);
  33. 	Date d2(2000, 1, 1);
  34. 	cout << "d1==d2:" << (d1 == d2) << endl;
  35. 	cout << "d1>d2:" <<(d1> d2) <<endl;
  36. 	cout << "d1<d2:" << (d1 < d2) << endl;
  37. 	cout << "d1>=d2:" <<(d1>= d2) <<endl;
  38. 	cout << "d1<=d2:" << (d1 <= d2) << endl;
  39. 	cout << "d1!=d2:" << (d1 != d2) << endl;
  40. }
  41. void Test4() {
  42. 	Date d1(2022, 1, 14);
  43. 	Date d2(2022, 2, 20);
  44. 	cout << "2022/1/14 - 2022/2/20 =" << d1 - d2 << endl;
  45. 	cout << "2022/2/20 - 2022/1/14 =" << d2 - d1 << endl;
  46. }
  47. void Test5() {
  48. 	Date d1;
  49. 	cout << d1 << endl;
  50. 	cout << "请输入:>";
  51. 	cin>> d1;
  52. 	cout << d1 << endl;
  53. }
  54. int main() {
  55. 	Test5();
  56. 	return 0;
  57. }

来源: https://blog.csdn.net/m0_52640673/article/details/122504181


与本文相关文章

  1. C++ 运算符重载详解
  2. C# 运算符重载使用范例
  3. Python 学习之路 32 - 运算符重载
  4. 重载运算符>> <<完成对结构体的数日输出
  5. 重载运算符问题
  6. 3.1 什么是运算符重载
  7. 赋值函数 (运算符重载)(2)
  8. C++运算符重载
暂无,快来抢沙发吧！
更多





黑ICP备17005318号-1