2021-08-02

//// C++ 面向对象2-4 8.2.cpp : 此文件包含 “main” 函数。程序执行将在此处开始并结束。
////
//
//#include
//
//int main()
//{
// std::cout << “Hello World!\n”;
//}
//
//// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
//// 调试程序: F5 或调试 >“开始调试”菜单
//
//// 入门使用技巧:
//// 1. 使用解决方案资源管理器窗口添加/管理文件
//// 2. 使用团队资源管理器窗口连接到源代码管理
//// 3. 使用输出窗口查看生成输出和其他消息
//// 4. 使用错误列表窗口查看错误
//// 5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//// 6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件

//运算符重载 修改运算符的功能，或者是改变运算符的作用
//
//#include
//#include<stdio.h>
//using namespace std;
//class Date
//{
//public:
// //这里使用的是全缺省构造函数。
// Date(int y = 1,int m = 1,int d = 1)
// {
// _y = y;
// _m = m;
// _d = d;
//
// }
// //bool isEqual(const Date& d)
// //{
// // return _y == d._y
// // && _m == d._m
// // && _d == d._d;
// //
// //}
// //这里是运算符重载函数是可以当做成员函数，但是成员函数的参数必须比对象的个数少一个。成员函数都会有一个隐含的this指针
// //运算符重载函数作为成员函数时，参数列表中显示定义的参数个数
// //需要比实际的参数少一个。但是如果是非成员函数时候，参数必须写全。
// //bool operator==(const Date& d)
// //{
// // return _y == d._y
// // && _m == d._m
// // && _d == d._d;
// //}
//
// ////赋值运算符重载
// ////判断对象是否是同一个对象。不能根据内容来判断是否是同一个对象。只能是通过指针来进行表示。
// //void operator=(const Date& d)
// //{
// // _y = d._y
// // && _m == d._m
// // && _d == d._d;
// // cout << “operator=” << endl;
// //}
// //如果需要进行里连续赋值，则返回值类型不能为空
// //返回值类型为当前类类型
// //因为现在这里是日期类所以说是返回值类型为日期类。
// Date& operator=(const Date& d)
// {
// if (this != &d)
// {
// _y = d._y
// && _m == d._m
// && _d == d._d;
// cout << “operator=” << endl;
// }
// //这里返回的是当前被赋值好了的对象，就是下一次要进行赋值的对象，就是类似d1=d2=d3;每一次都是返回的是被赋值的，这个被赋值的就是this
// //指针指向的，因为，下一次this所指向的是右边的参数。
// return this;
// }
// //Date(const Date& d)
// //{
// // _y = y;
// // _m = m;
// // _d = d;
// // cout << “Date(const Date&)” << endl;
// }
//~Date()
//{
// cout << “~Date()” << endl;
//
//}
//private:
// int _y;
// int _m;
// int _d;
//};
////下边是判断的运算符重载
////函数名：operator==
////bool operator==（const Date& d1,const Date& d2）
////{
////
////
////
////}
//////内置类型的逻辑是不能进行修改的 运算符的所有参数都为内置类型不能进行重载
////int operator+（int a,int b）
////{
////return a * b;
////
////}
//void test()
//{
// Date d1(2020, 12, 10);
// Date d2(2020, 11, 10);
// Date d3(2020, 1, 1);
// //判断时期对象是否相同 这里的表示的就是针对自定义运算
// //this指针始终指向的是第一个运算符指向的对象，第一个从左往右看。
// //函数名字为：关键字operator后面接需要重载的运算符符号。
// // 函数原型：返回值类型 operator操作符(参数列表)
// //if (d1.operator== (d2))
//
// // ////简写形式就是
// // //if(d1d2)
// //{
// // cout << "" << endl;
// //}
// //else
// //{
// // cout << “!=” << endl;
// //}
//
// ////赋值 调用赋值运算符重载函数；修改已经存在的对象内容
// //d2 = d1;
// //d2.operator=(d3);
// //d2 = d2;
// //d1 = d3;
// //d2 = d1;
//
// int a, b, c;
// //连续赋值
// a = b = c = 100;
//
// d1 = d2 = d3;
// //完整形式就是
// d1.operator=(d2.operator=(d3));
//
// //是否为赋值
// Date d4 = d1;
// //这里是拷贝构造，而不是赋值的操作。赋值的操作指的是对已经存在的对象进行的操作，而不是对不存在的对象进行操作。
// //这里的d4对象时本身不存在的。所以我们要进行的就是拷贝构造的运算符重载。
//
//}
//int main()
//{
// test();
// return 0;
//
//}
//下边的程序就是浅拷贝的操作 资源连续释放的问题
//#include
//using namespace std;
//class String
//{
//public:
// String(const char str = “”)
// {
// _str = (char*)malloc(strlen(str) + 1);
// strcpy(_str, str);
// }
// ~String()
// {
// cout << “~String()” << endl;
// free(_str);
// }
//private:
// char* _str;
//};
//int main()
//{
// String s1(“hello”);
// String s2(“world”);
//
// s1 = s2;
//}
//日期类的操作
#include
using namespace std;
class Date
{
public:
Date(int y = 1, int m = 1, int d = 1)
{
//判断日期是否有效
if (_y <= 0 || m <= 0 || m > 12 || d <= 0 || d > getDay(y, m))
{
//日期无效
_y = 1;
_m = 1;
_d = 1;
cout << “日期无效，设为默认值：1-1-1” << endl;
}
else
{
_y = y;
_m = m;
_d = d;
}
}
int getDay(int y, int m)
{
static int days[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int day = days[m];
//如果是2月，且为二月，修改天数
if (m == 2 && (((y% 4 == 0) && (y % 100 != 0)) || y % 400 == 0))
day += 1;
return day;
}

//日期运算
//Date+=int   int a,int b  a+=b
//左操作数+=右操作数；左操作数的内容发生变化；返回值；相加之后的值

Date& operator+=(int day)
{
//日期；2021 ,2,4
//day:1 30 90 360
//2021,2,4+1=2021,2,5 2021,2,4+30=2021,2,34 ----28----》2021…3.6
//2021,2,4+90=2021,2,94–28---->2021.3.66-31=2021,4,35- 30—>2021,5,5
//相加天数 首先是天数的更新
_d += day;
//判断天数是否溢出
while (_d > getDay(_y, _m))
{
//减去当月的天数
_d -= getDay(_y, _m);
++_m;
//判断月份是否溢出
if (_m == 13)
{
//年份的进位
//下一年的1月份
//年份进位
++_y;
_m = 1;
}
}
//相加之后的结果是可以直接返回*this，因为这里是左操作数，还有就是这里是成员函数所以说是包含有this指针的操作。
return *this;
}
//Date + int
//加法：返回相加之后的结果
Date operator+(int day)
{

//重新创建一个新的，然后再就是返回值
//使用拷贝构造，使用新生成的对象进行返回
Date tmp = *this;
return tmp += day;

//下边的也是可以的
Date copy(*this);
//Date copy = *this;
copy += day;
return copy ;

}
//++Date
Date& operator++()
{

//使用的是引用  就是日期类对象本身
return *this += 1;

}
//后置++

//Date++
Date operator++(int)
//这里使用的int只是为了和上边进行区分。为了构成函数的重载。
{
Date copy(*this);
*this += 1;
//返回++之前的值
return copy;

}
private:
int _y;
int _m;
int _d;
};
void test()
{
Date d1(2021, 2, 4);
Date d2(2021, 2, 4);
Date d3(2021, 2, 4);
Date d4(2021, 2, 4);
d1.operator+=(1);
d2 += 30;
d3 += 90;
d4 += 360;
d3 = d4 + 90;
d4=++d3;
//后置++
d4 = d3.operator++(10);
//前置
d4 = d3.operator++();
int main()
{
test();
return 0;
}