• 类与对象（下篇）

    1.日期类的完整实现

    1. //Date.h
    2. #pragma once
    3.  
    4. #include
    5. #include 
    6. using namespace std;
    7.  
    8.  
    9. // 一个到底可以重载哪些运算符？-》哪些运算符对这个类型有意义
    10. class Date
    11. {
    12. 	// 友元函数 -- 这个函数内部可以使用Date对象访问私有保护成员
    13. 	friend ostream& operator<<(ostream& out, const Date& d);
    14. 	friend istream& operator>>(istream& in, Date& d);
    15. public:
    16. 	// 获取某年某月的天数
    17. 	// 会频繁调用，所以直接放在类里面定义作为inline
    18. 	int GetMonthDay(int year, int month)
    19. 	{
    20. 		static int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    21. 		int day = days[month];
    22. 		if (month == 2
    23. 			&& ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
    24. 		{
    25. 			day += 1;
    26. 		}
    27.  
    28. 		return day;
    29. 	}
    30.  
    31. 	bool CheckDate()
    32. 	{
    33. 		if (_year >= 1
    34. 			&& _month > 0 && _month < 13
    35. 			&& _day > 0 && _day <= GetMonthDay(_year, _month))
    36. 		{
    37. 			return true;
    38. 		}
    39. 		else
    40. 		{
    41. 			return false;
    42. 		}
    43. 	}
    44.  
    45. 	// 构造会频繁调用，所以直接放在类里面定义作为inline
    46. 	Date(int year = 1, int month = 1, int day = 1)
    47. 	{
    48. 		_year = year;
    49. 		_month = month;
    50. 		_day = day;
    51.  
    52. 		/*if (!CheckDate())
    53. 		{
    54. 			Print();
    55. 			cout << "刚构造的日期非法" << endl;
    56. 		}*/
    57.  
    58. 		assert(CheckDate());
    59. 	}
    60.  
    61. 	void Print() const;
    62.  
    63. 	bool operator==(const Date& d) const;
    64. 	bool operator!=(const Date& d) const;
    65. 	bool operator>(const Date& d) const;
    66. 	bool operator>=(const Date& d) const;
    67. 	bool operator<(const Date& d) const;
    68. 	bool operator<=(const Date& d) const;
    69.  
    70. 	Date operator+(int day) const;
    71. 	Date& operator+=(int day);
    72.  
    73. 	// ++d1;
    74. 	// d1++;
    75. 	// 直接按特性重载，无法区分
    76. 	// 特殊处理，使用重载区分，后置++重载增加一个int参数跟前置构成函数重载进行区分
    77. 	Date& operator++(); // 前置
    78. 	Date operator++(int); // 后置
    79.  
    80. 	// d1 - 100
    81. 	Date operator-(int day) const;
    82. 	Date& operator-=(int day);
    83.  
    84. 	Date& operator--(); // 前置
    85. 	Date operator--(int); // 后置
    86.  
    87. 	// d1 - d2
    88. 	int operator-(const Date& d) const;
    89.  
    90. 	//void operator<<(ostream& out);
    91. private:
    92. 	int _year;
    93. 	int _month;
    94. 	int _day;
    95. };
    96.  
    97. // 流插入重载
    98. inline ostream& operator<<(ostream& out, const Date& d)
    99. {
    100. 	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
    101. 	return out;
    102. }
    103.  
    104. // 流提取重载
    105. inline istream& operator>>(istream& in, Date& d)
    106. {
    107. 	in >> d._year >> d._month >> d._day;
    108. 	assert(d.CheckDate());
    109.  
    110. 	return in;
    111. }
    1. //Date.cpp
    2. #include "Date.h"
    3.  
    4. // const int* const ptr;
    5.  
    6. // void Date::Print(const Date* const this)
    7. void Date::Print() const
    8. {
    9. 	//_year = 1;
    10. 	cout << _year << "/" << _month << "/" << _day << endl;
    11. }
    12.  
    13. // 任何一个类，只需要写一个> == 或者 < ==重载 剩下比较运算符重载复用即可
    14. bool Date::operator== (const Date& d) const
    15. {
    16. 	return _year == d._year
    17. 		&& _month == d._month
    18. 		&& _day == d._day;
    19. }
    20.  
    21. // d1 != d2
    22. bool Date::operator!=(const Date& d) const
    23. {
    24. 	return !(*this == d);
    25. }
    26.  
    27. // d1 > d2
    28. bool Date::operator>(const Date& d) const
    29. {
    30. 	if ((_year > d._year)
    31. 		|| (_year == d._year && _month > d._month)
    32. 		|| (_year == d._year && _month == d._month && _day > d._day))
    33. 	{
    34. 		return true;
    35. 	}
    36. 	else
    37. 	{
    38. 		return false;
    39. 	}
    40. }
    41.  
    42. bool Date::operator>=(const Date& d) const
    43. {
    44. 	return (*this > d) || (*this == d);
    45. }
    46.  
    47. bool Date::operator<(const Date& d) const
    48. {
    49. 	return !(*this >= d);
    50. }
    51.  
    52. bool Date::operator<=(const Date& d) const
    53. {
    54. 	return !(*this > d);
    55. }
    56.  
    57. // d1 + 100
    58. Date Date::operator+(int day) const
    59. {
    60. 	//Date ret(*this);
    61. 	Date ret = *this;
    62. 	ret += day;
    63.  
    64. 	return ret;
    65. }
    66.  
    67. // d2 += d1 += 100
    68. Date& Date::operator+=(int day)
    69. {
    70. 	if (day < 0)
    71. 	{
    72. 		return *this -= -day;
    73. 	}
    74.  
    75. 	_day += day;
    76. 	while (_day > GetMonthDay(_year, _month))
    77. 	{
    78. 		_day -= GetMonthDay(_year, _month);
    79. 		++_month;
    80. 		if (_month == 13)
    81. 		{
    82. 			_year++;
    83. 			_month = 1;
    84. 		}
    85. 	}
    86.  
    87. 	return *this;
    88. }
    89.  
    90. //Date Date::operator+(int day)
    91. //{
    92. //	Date ret = *this;
    93. //	// ...
    94. //	ret._day += day;
    95. //	while (ret._day > GetMonthDay(ret._year, ret._month))
    96. //	{
    97. //		//...
    98. //	}
    99. //
    100. //	return ret;
    101. //}
    102. //
    103.  d1 += 100
    104. //Date& Date::operator+=(int day)
    105. //{
    106. //	*this = *this + day;
    107. //
    108. //	return *this;
    109. //}
    110.  
    111. Date& Date::operator++() // 前置
    112. {
    113. 	//*this += 1;
    114. 	//return *this;
    115.  
    116. 	return *this += 1;
    117. }
    118.  
    119. Date Date::operator++(int) // 后置
    120. {
    121. 	Date tmp(*this);
    122. 	*this += 1;
    123.  
    124. 	return tmp;
    125. }
    126.  
    127. Date Date::operator-(int day) const
    128. {
    129. 	Date ret = *this;
    130. 	ret -= day;
    131. 	return ret;
    132. }
    133.  
    134. Date& Date::operator-=(int day)
    135. {
    136. 	if (day < 0)
    137. 	{
    138. 		return *this += -day;
    139. 	}
    140.  
    141. 	_day -= day;
    142. 	while (_day <= 0)
    143. 	{
    144. 		--_month;
    145. 		if (_month == 0)
    146. 		{
    147. 			--_year;
    148. 			_month = 12;
    149. 		}
    150.  
    151. 		_day += GetMonthDay(_year, _month);
    152. 	}
    153.  
    154. 	return *this;
    155. }
    156.  
    157. Date& Date::operator--() // 前置
    158. {
    159. 	return *this -= 1;
    160. }
    161.  
    162. Date Date::operator--(int) // 后置
    163. {
    164. 	Date tmp(*this);
    165. 	*this -= 1;
    166. 	return tmp;
    167. }
    168.  
    169. // d1 - d2
    170. int Date::operator-(const Date& d) const
    171. {
    172. 	int flag = 1;
    173. 	Date max = *this;
    174. 	Date min = d;
    175. 	if (*this < d)
    176. 	{
    177. 		max = d;
    178. 		min = *this;
    179. 		flag = -1;
    180. 	}
    181.  
    182. 	int n = 0;
    183. 	while (min != max)
    184. 	{
    185. 		++min;
    186. 		++n;
    187. 	}
    188.  
    189. 	return n * flag;
    190. }
    191.  
    192. //void Date::operator<<(ostream& out)
    193. //{
    194. //	out << _year << "-" << _month << "-" << _day << endl;
    195. //}
    1. //Test.cpp
    2.  
    3. #include "Date.h"
    4.  
    5. //class A
    6. //{
    7. //public:
    8. //	A(int a = 0)
    9. //	{
    10. //      _a = a;
    11. //		cout << "A(int a = 0)->" <<_a<< endl;
    12. //	}
    13. //
    14. //	~A()
    15. //	{
    16. //		cout << "~A()->" <<_a<
    17. //	}
    18. //private:
    19. //	int _a;
    20. //};
    21. //
    22. //A aa3(3);
    23. //
    24. //void f()
    25. //{
    26. //	static int i = 0;
    27. //	static A aa0(0);
    28. //	A aa1(1);
    29. //	A aa2(2);
    30. //	static A aa4(4);
    31. //}
    32. //
    33.  构造顺序：3 0 1 2 4 1 2
    34.  析构顺序：~2 ~1 ~2 ~1 ~4 ~0 ~3
    35. //int main()
    36. //{
    37. //	f();
    38. //	f();
    39. //
    40. //	return 0;
    41. //}
    42.  
    43.  
    44. //class A
    45. //{
    46. //public:
    47. //	A(int a = 0)
    48. //	{
    49. //		_a = a;
    50. //		cout << "A(int a = 0)->" << _a << endl;
    51. //	}
    52. //
    53. //	// A aa2(aa1);
    54. //	A(const A& aa)
    55. //	{
    56. //		_a = aa._a;
    57. //		cout << "A(const A& aa)->" << _a << endl;
    58. //	}
    59. //
    60. //	~A()
    61. //	{
    62. //		cout << "~A()->" << _a << endl;
    63. //	}
    64. //private:
    65. //	int _a;
    66. //};
    67. //
    68. //void func1(A aa)
    69. //{
    70. //
    71. //}
    72. //
    73. //void func2(A& aa)
    74. //{
    75. //
    76. //}
    77. //
    78. //A func3()
    79. //{
    80. //	static A aa(3);
    81. //	return aa;
    82. //}
    83. //
    84. //A& func4()
    85. //{
    86. //	static A aa(4);
    87. //	return aa;
    88. //}
    89. //
    90. //int main()
    91. //{
    92. //	//A aa1(1);
    93. //	//A aa2(aa1);
    94. //
    95. //	//func1(aa1);
    96. //	//func2(aa1);
    97. //	func3();
    98. //	cout << endl << endl;
    99. //	func4();
    100. //
    101. //	//int i = 0;
    102. //	//int& j = i;
    103. //	//cout << typeid(j).name() << endl;
    104. //
    105. //	return 0;
    106. //}
    107.  
    108. //#pragma once
    109. //
    110. //class Time
    111. //{
    112. //public:
    113. //	Time()
    114. //	{
    115. //		_hour = 1;
    116. //		_minute = 1;
    117. //		_second = 1;
    118. //	}
    119. //
    120. //	Time& operator=(const Time& t)
    121. //	{
    122. //		cout << "Time& operator=(const Time& t)" << endl;
    123. //		if (this != &t)
    124. //		{
    125. //			_hour = t._hour;
    126. //			_minute = t._minute;
    127. //			_second = t._second;
    128. //		}
    129. //
    130. //		return *this;
    131. //	}
    132. //private:
    133. //	int _hour;
    134. //	int _minute;
    135. //	int _second;
    136. //};
    137. //
    138. //class Date
    139. //{
    140. //public:
    141. //	// 构造会频繁调用，所以直接放在类里面定义作为inline
    142. //	Date(int year = 1, int month = 1, int day = 1)
    143. //	{
    144. //		_year = year;
    145. //		_month = month;
    146. //		_day = day;
    147. //	}
    148. //
    149. //	Date(const Date& d)
    150. //	{
    151. //		cout << "Date(const Date& d)" << endl;
    152. //		_year = d._year;
    153. //		_month = d._month;
    154. //		_day = d._day;
    155. //	}
    156. //
    157. //	// d1 = d3;
    158. //	// d2 = d2;
    159. //	//Date& operator=(const Date& d)
    160. //	Date operator=(const Date d)
    161. //	//{
    162. //	//	if (this != &d)
    163. //	//	{
    164. //	//		_year = d._year;
    165. //	//		_month = d._month;
    166. //	//		_day = d._day;
    167. //	//	}
    168. //
    169. //	//	return *this;
    170. //	//}
    171. //
    172. //private:
    173. //	int _year;
    174. //	int _month;
    175. //	int _day;
    176. //
    177. //	// 自定义类型
    178. //	Time _t;
    179. //};
    180. //
    181.  
    182. //
    183.  这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
    184. //typedef int DataType;
    185. //class Stack
    186. //{
    187. //public:
    188. //	Stack(size_t capacity = 10)
    189. //	{
    190. //		_array = (DataType*)malloc(capacity * sizeof(DataType));
    191. //		if (nullptr == _array)
    192. //		{
    193. //			perror("malloc申请空间失败");
    194. //			return;
    195. //		}
    196. //
    197. //		_size = 0;
    198. //		_capacity = capacity;
    199. //	}
    200. //
    201. //	void Push(const DataType& data)
    202. //	{
    203. //		// CheckCapacity();
    204. //		_array[_size] = data;
    205. //		_size++;
    206. //	}
    207. //
    208. //	~Stack()
    209. //	{
    210. //		if (_array)
    211. //		{
    212. //			free(_array);
    213. //			_array = nullptr;
    214. //			_capacity = 0;
    215. //			_size = 0;
    216. //		}
    217. //	}
    218. //
    219. //private:
    220. //	DataType *_array;
    221. //	size_t _size;
    222. //	size_t _capacity;
    223. //};
    224. //
    225.  躺赢 -- 构造、拷贝构造、赋值重载、析构默认生成都可以用
    226. //class MyQueue
    227. //{
    228. //private:
    229. //	Stack _st1;
    230. //	Stack _st2;
    231. //};
    232. //
    233. //void Test()
    234. //{
    235. //	Date d1(2022, 7, 24);
    236. //	Date d2(d1);
    237. //
    238. //	Date d3(2022, 8, 24);
    239. //	d2 = d1 = d3; // d1.operator=(&d1, d3)
    240. //	d2 = d2;
    241. //
    242. //	Stack st1;
    243. //	Stack st2;
    244. //	st2.Push(1);
    245. //	st2.Push(2);
    246. //	st1 = st2; // 实现深拷贝赋值解决
    247. //
    248. //	int i = 0, j = 1, k = 2;
    249. //	k = i = j = 10;
    250. //}
    251.  
    252. void TestDate1()
    253. {
    254. 	Date d1(2022, 7, 24);
    255. 	Date d2(2022, 7, 25);
    256. 	Date d3(2021, 7, 25);
    257.  
    258. 	cout << (d1 < d2) << endl;
    259. 	cout << (d1 < d3) << endl;
    260. 	cout << (d1 == d3) << endl;
    261. 	cout << (d1 > d3) << endl;
    262. }
    263.  
    264. void TestDate2()
    265. {
    266. 	//Date d1(2022, 7, 24);
    267. 	//d1 += 4;
    268. 	//d1.Print();
    269.  
    270. 	//d1 += 40; // 跨月
    271. 	//d1.Print();
    272.  
    273. 	//d1 += 400;// 跨年
    274. 	//d1.Print();
    275.  
    276. 	//d1 += 4000; // 跨闰年
    277. 	//d1.Print();
    278.  
    279. 	Date d1(2022, 7, 24);
    280. 	/*Date d2 = d1 + 4;
    281. 	d2.Print();*/
    282. 	(d1 + 4).Print();
    283. 	(d1 + 40).Print();// 跨月
    284. 	(d1 + 400).Print();// 跨年
    285. 	(d1 + 4000).Print(); // 跨闰年
    286. 	(d1 + 40000).Print();
    287.  
    288. 	Date ret1 = ++d1; // d1.operator++(&d1)
    289. 	Date ret2 = d1++; // d1.operator++(&d2, 0)
    290. }
    291.  
    292. void TestDate3()
    293. {
    294. 	Date d1(2022, 7, 25);
    295. 	(d1 - 4).Print();
    296. 	(d1 - 40).Print();// 跨月
    297. 	(d1 - 400).Print();// 跨年
    298. 	(d1 - 4000).Print(); // 跨闰年
    299. 	(d1 - 40000).Print();
    300.  
    301. 	Date d2(2022, 7, 25);
    302. 	Date d3(2023, 2, 15);
    303. 	cout << d2 - d3 << endl;
    304. 	cout << d3 - d2 << endl;
    305.  
    306. 	Date d4(2000, 2, 15);
    307. 	cout << d2 - d4 << endl;
    308. 	cout << d4 - d2 << endl;
    309. }
    310.  
    311. void TestDate4()
    312. {
    313. 	/*Date d1(2022, 7, 32);
    314. 	d1.Print();
    316. 	Date d2(2022, 2, 29);
    317. 	d2.Print();
    319. 	d2++;
    320. 	d2.Print();*/
    321.  
    322. 	Date d1(2022, 7, 25);
    323. 	Date d2(2022, 7, 26);
    324. 	cout << d1 << d2;
    325.  
    326. 	cin >> d1 >> d2;
    327. 	cout << d1 << d2;
    328.  
    329.  
    330.  
    331. 	//d1.operator<<(cout);
    332. 	//d1 << cout;
    333.  
    334. 	//cout << (d1 + 100);
    335. 	//(d1 + 100).Print();
    336. 	//(d1 + -100).Print();
    337. }
    338.  
    339. void TestDate5()
    340. {
    341. 	const char* WeeDayToStr[] = { "周一", "周二", "周三", "周四", "周五", "周六", "周天" };
    342. 	Date d1, d2;
    343. 	int day = 0;
    344. 	int option = 0;
    345. 	do {
    346. 		cout << "*******************************" << endl;
    347. 		cout << " 1、日期加/减天数 2、日期减日期" << endl;
    348. 		cout << " 3、日期->周几   -1、退出" << endl;
    349. 		cout << "*******************************" << endl;
    350.  
    351. 		cout << "请选择:>";
    352. 		cin >> option;
    353. 		if (option == 1)
    354. 		{
    355. 			cout << "请依次输入日期及天数(减天数就输入负数)：";
    356. 			cin >> d1 >> day;
    357. 			cout << "日期加减天数后的日期：" << d1 + day << endl;
    358. 		}
    359. 		else if (option == 2)
    360. 		{
    361. 			cout << "请依次输入两个日期：";
    362. 			cin >> d1 >> d2;
    363. 			cout << "相差的天数：" << d1 - d2 << endl;
    364. 		}
    365. 		else if (option == 3)
    366. 		{
    367. 			cout << "请输入日期：";
    368. 			cin >> d1;
    369. 			Date start(1, 1, 1);
    370. 			int n = d1 - start;
    371. 			int weekDay = 0; // 周一
    372. 			weekDay += n;
    373. 			//weekDay += 9;
    374. 			//cout << "周" << weekDay % 7 + 1 << endl;
    375. 			cout << WeeDayToStr[weekDay % 7] << endl;
    376. 		}
    377. 		else
    378. 		{
    379. 			cout << "无此选项，请重新选择" << endl;
    380. 		}
    381. 	} while (option != -1);
    382. }
    383.  
    384. void TestDate6()
    385. {
    386. 	Date d1(2022, 7, 25);
    387. 	const Date d2(2022, 7, 25);
    388. 	d1.Print();
    389. 	d2.Print();
    390.  
    391. 	d1 < d2;
    392. 	d2 < d1;
    393. }
    394.  
    395. //int main()
    396. //{
    397. //	//TestDate6();
    398. //
    399. //	//int i = 0;
    400. //	//double d = 1.1;
    401. //	//cout << i; // cout.operator<<(i);
    402. //	//cout << d; // cout.operator<<(d);
    403. //
    404. //	return 0;
    405. //}
    406.  
    407. class A
    408. {
    409. public:
    410. 	// 他们是默认成员函数，我们不写编译器会自动生成，自动生成就够用了，所以一般是不需要我们自己写的
    411. 	// 特殊场景：不想让别人取到这个类型对象的地址
    412. 	A* operator&()
    413. 	{
    414. 		return nullptr;
    415. 	}
    416.  
    417. 	const A* operator&()const
    418. 	{
    419. 		return nullptr;
    420. 	}
    421.  
    422. 	void Print() const
    423. 	{
    424. 		//_year = 1;
    425. 		cout << _year << "/" << _month << "/" << _day << endl;
    426. 	}
    427.  
    428. 	/*void Print()
    429. 	{
    430. 	_year = 1;
    431. 	cout << _year << "/" << _month << "/" << _day << endl;
    432. 	}*/
    433. private:
    434. 	int _year;   // 年
    435. 	int _month; // 月
    436. 	int _day;   // 日
    437. };
    438.  
    439. int main()
    440. {
    441. 	A d1;
    442. 	const A d2;
    443. 	d1.Print();
    444. 	d2.Print();
    445.  
    446. 	cout << &d1 << endl;
    447. 	cout << &d2 << endl;
    448.  
    449. 	return 0;
    450. }

    2.const成员

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

    3.取地址及const取地址操作符重载 

          这两个默认成员函数一般不用重新定义 ，编译器默认会生成。 
    1. class Date
    2. { 
    3. public :
    4.  Date* operator&()
    5.  {
    6.  return this ;
    7.  }
    8.  
    9.  const Date* operator&()const
    10.  {
    11.  return this ;
    12.  }
    13. private :
    14.  int _year ; // 年
    15.  int _month ; // 月
    16.  int _day ; // 日
    17. };
          这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要 重载，比如想让别人获取到指定的内容！

    4. 再谈构造函数

    4.1 构造函数体赋值

          在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。 
    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. private:
    11.  int _year;
    12.  int _month;
    13.  int _day;
    14. };
          虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化， 构造函数体中的语句只能将其称为赋初值 ，而不能称作初始化。因为 初始化只能初始化一次，而构造函数体 内可以多次赋值 。

    4.2 初始化列表

         初始化列表：以一个 冒号开始 ，接着是一个以 逗号分隔的数据成员列表 ，每个 " 成员变量 " 后面跟一个 放在括 号中的初始值或表达式。 
    1. class Date
    2. {
    3. public:
    4. 	Date(int year, int month, int day)
    5. 		: _year(year)
    6. 		, _month(month)
    7. 		, _day(day)
    8. 	{}
    9.  
    10. private:
    11. 	int _year;
    12. 	int _month;
    13. 	int _day;
    14. };
       【注意】
    1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)。
    2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
      • 引用成员变量
      • const 成员变量
      • 自定义类型成员 ( 且该类没有默认构造函数时 )
    3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
    4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

    4.3 explicit关键字

          构造函数不仅可以构造与初始化对象， 对于单个参数或者除第一个参数无默认值其余均有默认值的构造函 数，还具有类型转换的作用 。 
    1. class Date
    2. {
    3. public:
    4. 	// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
    5. 	// explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
    6. 	explicit Date(int year)
    7. 		:_year(year)
    8. 	{}
    9. 	/*
    10. 	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转
    11.    换作用
    12. 	// explicit修饰构造函数，禁止类型转换
    13. 	explicit Date(int year, int month = 1, int day = 1)
    14. 	: _year(year)
    15. 	, _month(month)
    16. 	, _day(day)
    17. 	{}
    18. 	*/
    19. 	Date& operator=(const Date& d)
    20. 	{
    21. 		if (this != &d)
    22. 		{
    23. 			_year = d._year;
    24. 			_month = d._month;
    25. 			_day = d._day;
    26. 		}
    27. 		return *this;
    28. 	}
    29. private:
    30. 	int _year;
    31. 	int _month;
    32. 	int _day;
    33. };
    34. void Test()
    35. {
    36. 	Date d1(2022);
    37. 	// 用一个整形变量给日期类型对象赋值
    38. 	// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
    39. 	d1 = 2023;
    40. 	// 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
    41. }
         上述代码可读性不是很好， 用 explicit 修饰构造函数，将会禁止构造函数的隐式转换 。

    5. static成员

    5.1 概念

          声明为 static 的类成员 称为 类的静态成员 ，用 static 修饰的 成员变量 ，称之为 静态成员变量 ；用 static 修饰 的 成员函数 ，称之为 静态成员函数 。 静态成员变量一定要在类外进行初始化。 
    1. class A
    2. {
    3. public:
    4. 	A() 
    5. 	{ 
    6. 		++_scount;
    7. 	}
    8. 	A(const A& t) 
    9. 	{ 
    10. 		++_scount;
    11. 	}
    12. 	~A()
    13. 	{ 
    14. 		--_scount;
    15. 	}
    16.  
    17. 	//静态成员函数 -- 没有this指针
    18. 	static int GetACount() 
    19. 	{ 
    20. 		return _scount;
    21. 	}
    22.  
    23.  
    24. private:
    25. 	static int _scount; //声明
    26. };
    27.  
    28. //类外面定义初始化
    29. int A::_scount = 0;
    30.  
    31.  
    32. void TestA()
    33. {
    34. 	cout << A::GetACount() << endl;
    35. 	A a1, a2;
    36. 	A a3(a1);
    37. 	cout << A::GetACount() << endl;
    38. }

    5.2 特性

    • 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区；
    • 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明 ；
    • 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问 ；
    • 静态成员函数没有隐藏的this指针，不能访问任何非静态成员 ；
    • 静态成员也是类的成员，受public、protected、private 访问限定符的限制。

    6. 友元

          友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
          友元分为： 友元函数 和 友元类。

    6.1 友元函数

         问题：现在尝试去重载 operator<< ，然后发现没办法将 operator<< 重载成成员函数。 因为 cout 的输出流对 象和隐含的 this 指针在抢占第一个参数的位置 。 this 指针默认是第一个参数也就是左操作数了。但是实际使用中cout 需要是第一个形参对象，才能正常使用。所以要将 operator<< 重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>> 同理。 
    1. class Date
    2. {
    3. public:
    4. 	Date(int year, int month, int day)
    5. 		: _year(year)
    6. 		, _month(month)
    7. 		, _day(day)
    8. 	{}
    9. 	// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
    10. 	// 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
    11. 	ostream& operator<<(ostream& _cout)
    12. 	{
    13. 		_cout << _year << "-" << _month << "-" << _day << endl;
    14. 		return _cout;
    15. 	}
    16. private:
    17. 	int _year;
    18. 	int _month;
    19. 	int _day;
    20. };
         友元函数 可以 直接访问 类的 私有 成员，它是 定义在类外部 的 普通函数 ，不属于任何类，但需要在类的内部声明，声明时需要加friend 关键字。 
    1. class Date
    2. {
    3. 	friend ostream& operator<<(ostream& _cout, const Date& d);
    4. 	friend istream& operator>>(istream& _cin, Date& d);
    5. public:
    6. 	Date(int year = 1900, int month = 1, int day = 1)
    7. 		: _year(year)
    8. 		, _month(month)
    9. 		, _day(day)
    10. 	{}
    11. private:
    12. 	int _year;
    13. 	int _month;
    14. 	int _day;
    15. };
    16. ostream& operator<<(ostream& _cout, const Date& d) {
    17. 	_cout << d._year << "-" << d._month << "-" << d._day;
    18. 	return _cout;
    19. }
    20. istream& operator>>(istream& _cin, Date& d) {
    21. 	_cin >> d._year;
    22. 	_cin >> d._month;
    23. 	_cin >> d._day;
    24. 	return _cin;
    25. }
    26. int main()
    27. {
    28. 	Date d;
    29. 	cin >> d;
    30. 	cout << d << endl;
    31. 	return 0;
    32. }
    • 友元函数 可访问类的私有和保护成员，但 不是类的成员函数；
    • 友元函数 不能用 const 修饰；
    • 友元函数 可以在类定义的任何地方声明， 不受类访问限定符限制 ；
    • 一个函数可以是多个类的友元函数；
    • 友元函数的调用与普通函数的调用原理相同。

    6.2 友元类

        友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

    • 友元关系是单向的，不具有交换性。比如上述Time 类和 Date 类，在 Time 类中声明 Date 类为其友元类，那么可以在 Date 类中直接访问 Time类的私有成员变量，但想在Time 类中访问 Date 类中私有的成员变量则不行。
    • 友元关系不能传递 。如果B 是 A 的友元， C 是 B 的友元，则不能说明 C 时 A 的友元。
    • 友元关系不能继承。

    7. 内部类

         概念： 如果一个类定义在另一个类的内部，这个内部类就叫做内部类 。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
         
          注意： 内部类就是外部类的友元类 ，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
          特性：
    • 内部类可以定义在外部类的public、protected、private都是可以的。
    • 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
    • sizeof(外部类)=外部类，和内部类没有任何关系。

    8.练习题

           求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

    1. int i = 1;
    2. int sum = 0;
    3. class Sum
    4. {
    5. public:
    6. 	Sum()
    7. 	{
    8. 		sum += i;
    9. 		++i;
    10. 	}
    11. };
    12.  
    13. class Solution {
    14. public:
    15. 	int Sum_Solution(int n) {
    16. 		Sum a[n];//调用n次sum的构造函数
    17. 		return sum;
    18. 	}
    19. };

                根据输入的日期，计算是这一年的第几天。保证年份为4位数且日期合法。 

    1. #include 
    2. using namespace std;
    3. int main()
    4. {
    5. 	int year, month, day;
    6. 	cin >> year >> month >> day;
    7. 	//2012 12 31
    8. 	int monthDays1_N[13] = { 0,31,59,90,120,151,181,212,243,273,304,334,365 };
    9. 	//[1,month-1]
    10.  
    11. 	int n = monthDays1_N[month - 1] + day;
    12.  
    13. 	if (month > 2 &&( (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
    14. 		n += 1;
    15.  
    16. 	return 0;
    17. }

  • 相关阅读:
    【C++心愿便利店】No.6---C++之拷贝构造函数
    便携式电热水壶外贸出口欧洲CE认证准备资料
    【Spring进阶系列丨第二篇】Spring中的两大核心技术IoC（控制反转）与DI（依赖注入）
    【消息中间件】默认的RocketMQ消息消费者是如何启动的？
    shell脚本中加入这条可以执行完一个脚本回到这个目录下
    ConcurrentHashMap 源码解析
    学习java的第三十三天。。。(XML解析)
    linux查看用户相关信息的命令
    中文编程工具开发语言开发的实际案例：触摸屏点餐软件应用场景实例
    【C语言】【结构体的内存对齐】计算结构体内存大小，有图解
  • 原文地址：https://blog.csdn.net/zhao19971014/article/details/126413787