C++入门：类和对象(中)

class Date
{
public:
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};

十：友元

在默认的情况下，一个对象的成员变量只能在类的内部访问，但如果我们想在其它地方访问类的成员变量，该怎么办呢？这个就需要友元了。

注意：友元可以更加灵活，但是破坏了封装，应该尽量少用。

(1)友元函数

class A
{
public:
	//关键字friend，在类中进行函数声明即可。
	friend void print(A& a);
	A(int a = 0)
		:_a(a)
	{}
private:
	int _a;
};
 
//想让非成员函数访问类成员变量
void print(A& a)
{
	a._a++;
	cout << a._a << endl;
}
int main()
{
	A a1(20);
	print(a1);
}

(2)友元类

class A
{
public:
	//利用关键字friend，A是B的友元，B可以访问A，A不可以访问B
	//A把B当朋友，B不一定把A当朋友
	friend class B;
	A(int a = 0)
		:_a(a)
	{}
private:
	int _a;
};
 
class B
{
public:
	
	B(int b = 0)
		:_b(b)
	{}
	void print()
	{
		//在B类中访问A类的对象
		cout << "A:>" << a._a << "B:>"<< _b << endl;
	}
private:
	int _b;
	A a;
};

十一：实现一个比较完整的日期类

(1)先讲几个比较重要的点

⭐获取月天数

// 获取某年某月的天数
//这个很容易理解，后面经常会用到这个函数
int	Date::GetMonthDay(int year, int month) const
{
	//会多次调用这个函数，所以直接设计成静态的数组
	static int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
	int day = days[month];
	if (month == 2
		&& ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
	{
		day += 1;
	}
	return day;
}

⭐实现比较运算符重载的原则

现在写好了一个>比较的重载和==比较的重载，要实现<的重载，有人可能会选择直接拷贝>比较的代码然后更改比较逻辑，这样的做法会让代码变得非常冗余。

---

像这样的比较关系，我们只需要写好>(或者<)比较和==比较，其它的比较直接复用这两个重载，然后逻辑取反即可。

例如：<的判断可以写成 !((A>B) || (A == B))，括号里面的条件判断>=，>=的逻辑取反不就是<吗？其它的情况以此类推即可。

⭐输入输出重载

cout是ostream这个类的实例化全局对象，cout << a(int)实际是去调用这个对象的成员函数，这个成员函数有一个参数是int类型，cout << d(double)，这个也是一个成员函数，但是有一个参数是double类型，可以和前面int对应的函数构成函数重载，不过ostream只重载了内置类型。

至于连续打印的实现，cout << a(int) << d(double)，实际上先和a结合调用int对应的成员函数，然后返回cout的引用，再和d结合去调用double对应的成员函数。

---

cin是istream这个类的实例化全局对象，它能自动识别类型、连续输入的原理和cout类似，不同的是它需要更改变量的值，所以传递的时候是传引用而不是传值。

---

那如果我们直接把输入输出重载为成员函数会怎么样呢？

代码：

class Date
{
public:
	const Date(int year = 1900, int month = 1, int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
	ostream& operator<<(ostream& out)const
	{
		//<<实现内置类型重载的时候类型是没有用const修饰的
		//这里不能加const修饰，不然就找不到这个成员函数了
		out << _year << "." << _month << "." << _day << endl;
		return out;
	}
private:
	int _year;
	int _month;
	int _day;
};
 
int main()
{
	const Date d1;
	const Date d2(2022,11,11);
 
	cout << d1 << d2 << endl;
	//这个先看ostream这个类里面有没有实现这个重载
	//没有看全局有没有第一个参数为ostraem&，第二个参数为Date&的全局函数
	//都没有找到说明没有这个函数，编译报错
}

---

为解决上面的问题，我们可以把这个重载设计成全局函数，这个全局函数需要访问对象的成员变量，我们需要声明这个全局函数是类的友元函数。

class Date
{
public:
	const Date(int year = 1900, int month = 1, int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
	//声明，表明这个函数是友元函数
	friend ostream& operator<<(ostream& out,const Date& d);
private:
	int _year;
	int _month;
	int _day;
};
 
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "." << d._month << "." << d._day << endl;
	return out;
}
 
int main()
{
	const Date d1;
	const Date d2(2022,11,11);
 
	cout << d1 << d2 << endl;
}

输入和打印是同理的。

⭐前置++(--)和后置++(--)的区分

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 前置++：返回+1之后的结果
	// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
	Date& operator++()
	{
		_day += 1;
		return *this;
	}
	// 后置++：
	// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
	// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
	// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this + 1
	//而temp是临时对象，因此只能以值的方式返回，不能返回引用(之前讲过)
	Date operator++(int)
	{
		Date temp(*this);
		_day += 1;
		return temp;
	}
private:
	int _year;
	int _month;
	int _day;
};
 
int main()
{
	Date d;
	Date d1(2022, 1, 13);
	d = d1++; // d: 2022,1,13   d1:2022,1,14
	d = ++d1; // d: 2022,1,15   d1:2022,1,15
	return 0;
}

(2)日期类实现(分文件)

大家可以先对照声明尝试自己写一下，大部分的逻辑都比较简单。

⭐Date.h(函数声明)

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <assert.h>
using namespace std;
 
class Date
{
public:
	//两个友元函数
	friend ostream& operator<<(ostream& out,const Date& d);
	friend istream& operator>>(istream& in,Date& d);
	// 获取某年某月的天数
	int GetMonthDay(int year, int month)const;
 
	// 全缺省的构造函数
	Date(int year = 1900, int month = 1, int day = 1);
 
	// 拷贝构造函数
	// d2(d1)
	Date(const Date& d)
		:_year(d._year)
		,_month(d._month)
		,_day(d._day)
	{
	}
 
	// 赋值运算符重载
	// d2 = d3 -> d2.operator=(&d2, d3)
	//不传引用返回会多构造一个
	Date& operator=(const Date& d);
	// 析构函数(日期类可以不写，这里是为了方便观察)
	~Date()
	{
		//cout << "析构" << endl;
	}
	// 日期+=天数
	Date& operator+=(int day);
 
	// 日期+天数
	Date operator+(int day) const;
 
	// 日期-天数
	Date operator-(int day) const;
 
	// 日期-=天数
	Date& operator-=(int day);
 
	// 前置++
	Date& operator++();
 
	// 后置++,这个int参数只是为了区分，传什么值又编译器自行处理
	Date operator++(int);
 
	// 后置--
	Date operator--(int);
 
	// 前置--
	Date& operator--();
 
	// >运算符重载
	bool operator>(const Date& d)const;
 
	// ==运算符重载
	bool operator==(const Date& d) const;
 
	// >=运算符重载
	bool operator >= (const Date& d) const;
 
	// <运算符重载
	bool operator < (const Date& d) const;
 
	// <=运算符重载
	bool operator <= (const Date& d) const;
 
	// !=运算符重载
	bool operator != (const Date& d) const;
 
	// 日期-日期 返回天数
	int operator-(const Date& d) const;
 
	//进行日期检查，合法返回1，否则返回0
	int CheckDate() const;
 
	//打印
	void print()
	{
		cout << _year << "|" << _month << "|" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
 
//某一天是星期几
int GetWeek(Date& d);

⭐Date.cpp(函数实现)

​
#define _CRT_SECURE_NO_WARNINGS 1
#include "Date.h"
 
//打印重载
ostream& operator<<(ostream& out,const Date& d)
{
	cout << d._year << "." << d._month << "." << d._day << endl;
	return out;
}
 
//输入重载
istream& operator>>(istream& in,Date& d)
{
	cin >> d._year >> d._month >> d._day;
	//输入完检查一下是否合法
	assert(d.CheckDate());
	return in;
}
 
// 全缺省的构造函数
Date::Date(int year, int month, int day)
	:_year(year)
	, _month(month)
	, _day(day)
{
	//检查一下是否合法
	assert(CheckDate());
}
 
// 获取某年某月的天数
int	Date::GetMonthDay(int year, int month) const
{
	//会多次调用这个函数，所以直接设计成静态的数组
	static int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
	int day = days[month];
	if (month == 2
		&& ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
	{
		day += 1;
	}
	return day;
}
 
// 赋值运算符重载
// d2 = d3 -> d2.operator=(&d2, d3)
//不传引用返回会多构造一个
Date& Date::operator=(const Date& d)
{
	if (this != &d)
	{
		_day = d._day;
		_month = d._month;
		_year = d._year;
	}
	return *this;
}
 
// 日期+=天数
Date& Date::operator+=(int day)
{
	if (day < 0)
	{
		return *this -= -day;
	}
 
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		++_month;
		if (_month == 13)
		{
			++_year;
			_month = 1;
		}
	}
 
	return *this;
}
 
// 日期+天数
Date Date::operator+(int day) const
{
	Date tmp(*this);
	tmp += day;
	return tmp;
}
 
// 日期-=天数
Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		return *this += -day;
	}
 
	_day -= day;
	//减到0要变成下个月的最后一天
	while (_day <= 0)
	{
		_month--;
		//如果减到0，要变成下一年的12月
		if (_month <= 0)
		{
			_month = 12;
			_year--;
		}
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}
 
// 日期-天数
Date Date::operator-(int day) const
{
	Date tmp(*this);
	tmp -= day;
	return tmp;
}
 
// 前置++
Date& Date::operator++()
{
	*this += 1;
	return *this;
}
 
// 后置++,这个int参数只是为了构成函数重载，传什么值编译器自行处理
Date Date::operator++(int)
{
	Date tmp(*this);
	*this += 1;
	return tmp;
}
 
// 后置--
Date Date::operator--(int)
{
	Date tmp(*this);
	*this -= 1;
	return tmp;
}
 
// 前置--
Date& Date::operator--()
{
	*this -= 1;
	return *this;
}
 
// >运算符重载
bool Date::operator>(const Date& d) const
{
	if (_year > d._year)
	{
		return true;
	}
	else if ((_year == d._year) && (_month > d._month))
	{
		return true;
	}
	else if ((_year == d._year) && (_month == d._month) && (_day > d._day))
	{
		return true;
	}
	//前面三种情况都是大于，最后一定是小于
	else
	{
		return false;
	}
}
 
// ==运算符重载
bool Date::operator==(const Date& d) const
{
	return (_year == d._year)
		&& (_month == d._month)
		&& (_day == d._day);
}
 
// >=运算符重载
bool Date::operator >= (const Date& d) const
{
	return (*this > d) || (*this == d);
}
 
// <运算符重载
bool Date::operator < (const Date& d) const
{
	return !((*this > d) || (*this == d));
}
 
// <=运算符重载
bool Date::operator <= (const Date& d) const
{
	return !(*this > d);
}
 
// !=运算符重载
bool Date::operator != (const Date& d) const
{
	return !(*this == d);
}
 
// 日期-日期 返回天数
int Date::operator-(const Date& d) const
{
	Date max = *this;
	Date min = d;
	int n = 0;
	//一开始默认前面大于后面
	int flag = 1;
	if (*this < d)
	{
		max = d;
		min = *this;
		//如果后面大于前面，最后结果为负数
		flag = -1;
	}
 
	while (max > min)
	{
		min++;
		n++;
	}
	return n * flag;
}
 
int GetWeek(Date& d)
{
	Date tmp(1, 1, 1);
	int week = 0; //0 - 周一
	int n = d - tmp;
	week += n;
	return week % 7;
}
 
//合法返回1，否则返回0
int Date::CheckDate() const
{
	return _month > 0 && _month < 13 && (_day > 0 && _day <= GetMonthDay(_year, _month));
}
 
​

⭐test.cpp(测试)

#include "Date.h"
 
void text1()
{
	//  =
	/*Date d1;
	Date d2(3000, 11, 11);
	Date d3;
	d3 = d1 = d2;
	d1.print();
	d2.print();
	d3.print();*/
 
 
	//  +=
	/*Date d1(2022,12,1);
	d1 += 50;
	d1.print();
	d1 += 500;
	d1.print();
	d1 += 5000;
	d1.print();*/
 
	// + 
	//Date d1(2022, 11, 1);
	//Date d2 = d1 + 50;
	//d1.print();
	//d2.print();
 
 
	// -
	/*Date d1(2022, 12, 20);
	Date d2 = d1 - 20;
	d1.print();
	d2.print();*/
 
	// -=
	//Date d1(2022, 12, 20);
	//d1 -= d1 -= 20;
 
	// 前置++
	/*Date d1(2022, 11, 30);
	Date d2 = ++d1;*/
 
	// 后置++
	/*Date d1(2022, 11, 1);
	Date d2 = d1++;*/
 
	//前置--
	/*Date d1(2022, 11, 1);
	Date d2 = --d1;*/
 
	// 后置--
	/*Date d1(2022, 11, 1);
	Date d2 = d1--;*/
 
 
}
void text2()
{
	Date d1(2022, 12, 11);
	Date d2(2023, 12, 12);
	//cin >> d1 >> d2;
	cout << d1 << d2 << endl;
	// >
	/*Date d1(2022, 12, 20);
	Date d2(2023, 12, 20);
	cout << (d2 > d1) << endl;*/
	
	// ==
	/*Date d1(2023, 11, 20);
	Date d2(2023, 12, 20);
	cout << (d2 == d1) << endl; */
	
	// >=
	/*Date d1(2022, 12, 20);
	Date d2(2023, 12, 20);
	cout << (d2 >= d1) << endl;*/ 
 
 
	// <
	/*Date d1(2022, 12, 20);
	Date d2(2022, 12, 20);
	cout << (d2 < d1) << endl; */
 
 
	// <=
	/*Date d1(2022, 12, 20);
	Date d2(2023, 12, 20);
	cout << (d2 <= d1) << endl; */
 
 
	// !=
	/*Date d1(2022, 12, 20);
	Date d2(2022, 12, 21);
	cout << (d2 != d1) << endl; */
 
 
	// -(日期-日期 == 天数)
	/*Date d1(2022, 12, 20);
	Date d2(2023, 12, 30);
	cout << (d2 - d1) << endl; */
 
}
 
void menu()
{
	cout << "*****************************" << endl;
	cout << "1.日期加/减天数   2.日期-日期" << endl;
	cout << "3.算星期几        -1.退出    " << endl;
	cout << "*****************************" << endl;
 
}
 
//用来计算某一天是星期几，日期间的加减
void text3()
{
	int input = 0;
	int day = 0;
	Date d1;
	Date d2 = d1;
	//用下标来一一对应，0下标代表星期一
	const char* WeekArr[] = { "周一","周二","周三","周四","周五","周六","周日" };
	do
	{
		menu();
		cout << "请输入:>";
		cin >> input;
		if (input == 1)
		{
			cout << "请输入一个日期(空格隔开):>";
			cin >> d1;
			cout << "请输入天数:>";
			cin >> day;
			cout << d1 + day << endl;
		}
		else if (input == 2)
		{
			cout << "请输入两个日期(空格隔开):>";
			cin >> d1;
			cin >> d2;
			cout << d1 - d2 << endl;
		}
		else if (input == 3)
		{
			cout << "请输入一个日期(空格隔开):>";
			cin >> d1;
			cout << WeekArr[GetWeek(d1)] << endl;
		}
		else if (input != -1)
		{
			cout << "非法输入" << endl;
		}
	} while (input != -1);
}
 
 
int main()
{
	//text1();
	//text2();
	text3();
	return 0;
}