1.类的定义

2.类的构造函数

1.函数名与类名相同
2.无返回值
3.对象实例化时编译器会自己调用构造函数
4.构造函数可以重载
5.没有显示定义时，编译器会自动调用一个无参的默认构造函数，一旦写显示则不生成
6.对于内置类型构造函数不做处理，对于自定义类型则会处理。

3.析构函数

1.在对象销毁时会自动调用析构函数对对象中的资源进行清理和管理。
2.析构函数名是在类名前加~。
3.生命周期结束编译器会自动调用。
4.析构函数只有一个。

4.拷贝构造函数

1.拷贝构造函数是构造函数重载的一种形式。

2.若未定义拷贝构造则编译器会调用默认的拷贝构造，则为浅拷贝只是拷贝了大小。
3.浅拷贝只是拷贝了字节序，而空间不是独立的，在析构的时候容易出现一份空间被同时释放2次。

5.运算符重载

在c++针对自定义类型没法正常比较，而进行将运算符重载让自定义类型可以比较

定义一个日期类：

class Date

{

public:

	// 获取某年某月的天数

	int GetMonthDay(int year, int month) {
		int monthday[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
		if (month == 2) {
			if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
				monthday[month] = 29;
			}
		}
		return monthday[month];
	}
	
	// 全缺省的构造函数

	Date(int year = 1900, int month = 1, int day = 1) {

		_year = year;
		_month = month;
		_day = day;

	}
	void print() {
		cout << _year << "/" << _month << "/" << _day << endl;
	}

	// 拷贝构造函数

  // d2(d1)

	//Date(const Date& d);



	// 赋值运算符重载

  
	Date& operator=(const Date& d){
if(*this!=d){
_day=d._day;
_month=d._month;
_year=d._year;
}
}






	// 日期+=天数

	Date& operator+=(int day) {
		_day += day;
		while (_day > GetMonthDay(_year, _month)) {
			_day = _day - GetMonthDay(_year, _month);
			_month++;
			if (_month == 13) {
				_month = 1;
				_year++;
			}
		}
		return *this;
	}


	// 日期+天数

	Date operator+(int day) {
		Date temp(*this);
		temp+= day;
		return temp;
	}


	// 日期-天数

	Date operator-(int day) {
	
		Date temp(*this);
		temp -= day;
		return temp;
	
	}


	 日期-=天数

	Date& operator-=(int day) {
		_day -= day;
		while (_day <=0) {
		
			_month--;
			if (_month == 0) {
				_month = 12;
				_year--;
			}
			_day += GetMonthDay(_year, _month);
		}
		return *this;
	}


	// 前置++

	Date& operator++() {
		*this += 1;
		return *this;
	}

	 后置++

   Date operator++(int){
	   Date temp(*this);
	   temp += 1;
	   return temp;
   
   }


	 后置--

   Date operator--(int) {
	   Date temp(*this);
	   temp -= 1;
	   return temp;

   }


	 前置--
   Date& operator--() {
   *this -= 1;
   return *this;	

}


	// >运算符重载

   bool operator>(const Date& d) {
	   return !(*this <= d);
   }


	 ==运算符重载

   bool operator==(const Date& d) {
   
	   return _year == d._year && _month == d._month && _day == d._day;
   }


	 >=运算符重载

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

	}



	 <运算符重载

	bool operator < (const Date& d){
		return !(*this >= d);
}

	 <=运算符重载

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

}

	 !=运算符重载

	bool operator != (const Date& d) {
	
		return !(*this == d);
	}


	 日期-日期 返回天数

   int operator-(const Date& d) {
	   Date d1 = *this;
	   Date d2 = d;
	   int flag = 1;
	   if (*this < d) {
		   d1 = d;
		   d2 = *this;
		   flag = -1;
	   }
	   int n = 0;
	   while (d1 != d2) {
		   ++d2;
		   ++n;
	   }
	   return n * flag;
   }

public:

	int _year;

	int _month;

	int _day;

};