类和对象(2

*续上文中的运算符重载
4 重载++运算符时,有前置和后置的++,运算符重载的函数名都是operator++, 无法很好区分
所以c++规定,后置++重载时,增加一个int形参 与前置++做区分
5 重载<<和>>时需要重载为全局函数, 因为重载为成员函数时, this指针默认抢占了第一个形参位, 第一个形参位是左侧运算对象,
调用时变成了对象<<cout不符合使用习惯和可读性
重载为全局函数吧ostream\istream 放在第一个形参位就可以了,此时第二个形参位就是当前类的类对象

取地址运算符重载

const成员函数
将const修饰的成员函数称之为 const成员函数,const修饰成员函数放到成员函数参数列表的后面

const实际修饰该陈元函数隐含的this指针, 表面在该成员函数中不能对类的任何成员进行修改
const修饰Data类的print成员函数,printf隐含的指针由data* const this 变为const data* const this

取地址运算符重载(一般情况用不上)

取地址运算符重载分为普通…和const…,一般这两个函数编译器自动生成就够用了
不需要显示实现 存放也特殊场景
比如我们不想让别人取到当前类对象的地址,就可以自己实现一份 随便返回一个地址

日期类的实现
data.h

#pragma once
#include <iostream>
using namespace std;
#include <assert.h>

class Data
{
	//友元声明   可以让类外的函数访问类中的私域
	//流插入
	friend ostream& operator<<(ostream& out, const Data& d);
	//流提取
	friend istream& operator>>(istream& in, Data& d);//d不能加const因为需要改变
public:
	Data(int year = 1999, int month = 1, int day = 1);
	void Print() const;

	//查看日期是否违法
	bool CheckData() const;
	//求每月对应天数
	int MonthDays(int year, int month) const
	{
		assert(month > 0 && month < 13);
		static int days[13] = { -1,31,28,31,30,31,30,31,31,30,31,30,31 };
		
		if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
		{
			return 29;
		}
		
		return days[month];
	}

	Data& operator+=(int day);
	Data operator+(int day) const;

	Data& operator-=(int day);
	Data operator-(int day) const;

	bool operator<(const Data& d) const;
	bool operator<=(const Data& d) const;
	bool operator>(const Data& d) const;
	bool operator>=(const Data& d) const;
	bool operator==(const Data& d) const;
	bool operator!=(const Data& d) const;

	//++d1(前置++同的较多)
	Data& operator++();
	//d1++
	Data operator++(int);

	//--d1
	Data& operator--();
	//d1--
	Data operator--(int);

	int operator-(const Data& d) const;


private:
	int _year;
	int _month;
	int _day;
};
//流插入(从左往右插入)  定义为全局函数
ostream& operator<<(ostream& out,const Data& d);
//流提取
istream& operator>>(istream& in,  Data& d);

data.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"data.h"
bool Data::CheckData() const
{
	if (_month < 1 || _month>12
		|| _day<1 || _day>MonthDays(_year, _month))
	{
		return false;
	}
	else
	{
		return true;
	}
}
Data::Data(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
	if (!CheckData())
	{
		cout << "非法日期";
		Print();
	}
	
}
void Data::Print() const
{
	cout << _year << '/' << _month << '/' << _day << endl;
}

 Data& Data::operator+=(int day)
{
	 if (day < 0)
	 {
		 return *this -= - day;
	 }
	 _day += day;
	 while (_day > MonthDays(_year, _month))
	 {
		 _day -= MonthDays(_year, _month);
		 _month++;

		 if (_month == 13)
		 {
			 _year++;
			 _month = 1;
		 }
	 }
	 return *this;
}

 Data Data::operator+(int day) const
 {
	 Data tmp = *this;
	 tmp += day;

	 return tmp;
 }

Data& Data::operator-=(int day)
 {
	_day -= day;
	while (_day <=0 )
	{
		--_month;
		if (_month == 0)
		{
			_year--;
			_month = 12;
		}
		_day += MonthDays(_year, _month);

	}
	return *this;
 }
Data Data::operator-(int day) const
{
	Data tmp = *this;
	tmp -= day;

	return tmp;
}

//也可以实现 +\- 去附用+=\-= 不过效率更低

bool Data::operator<(const Data& d) const
{
	if (_year < d._year)
	{
		return true;
	}
	else if (_year ==d._year)
	{
		if (_month < d._month)
		{
			return true;
		}
		else if (_month == d._month)
		{
			return _day < d._day;
		}
	}

	return false;
}
bool Data::operator<=(const Data& d) const
{
	return *this < d
		|| *this == d;
}
bool Data::operator>(const Data& d) const
{
	return !(*this <= d);
}
bool Data::operator>=(const Data& d) const
{
	return !(*this < d);

}
bool Data::operator==(const Data& d) const
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}
bool Data::operator!=(const Data& d) const
{
	return !(*this == d);
}

//++d1(前置++同的较多)
Data& Data::operator++()
{
	*this += 1;
	return *this;
}
//d1++
Data Data::operator++(int)
{
	Data tmp = *this;
	*this += 1;
	return tmp;
}

//--d1
Data& Data::operator--()
{
	*this -= 1;
	return *this;
}
//d1--
Data Data::operator--(int)
{
	Data tmp = *this;
	*this -= 1;
	return tmp;
}

int Data::operator-(const Data& d) const
{
	int flag = 1;
	Data max = *this;
	Data min = d;
	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}

	int n = 0;
	while (min != max)
	{
		++min;
		++n;
	}
	return n * flag;
}


//流插入
ostream& operator<<(ostream& out,const Data& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;

	return out;
}
//流提取
istream& operator>>(istream& in, Data& d)
{
	while (1)
	{
		cout << "请输入对应的年月日:";
		in >> d._year >> d._month >> d._day;

		if (!d.CheckData())
		{
			cout << "日期非法,请重新输入日期:"<<endl;
			d.Print();
			cout<<endl;
		}
	}
	

	return in;
}