类和对象IV

运算符重载：

①重载函数写在类外

#include<iostream>
using namespace std;

class Date
{

public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Init(int year, int month, int day)
{
_year = year;//这里的_year是this->year，是d2的year
_month = month;
_day = day;
}
void Print()
{
cout << this << endl;
cout << _year << "-" << _month << "-" << _day << endl;
}
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;

}
//private:
int _year;
int _month;
int _day;
};

bool operator<(const Date& x1, const Date& x2)
{
if (x1._year < x2._year)
{
return true;
}
else if(x1._year==x2._year&&x1._month<x2._month)
{
return true;
}
else
{
return false;
}
}
int main()
{
Date d1(2026,6,12);
Date d2(2026, 6, 8);
d1 < d2; //转换成operator < (d1, d2);
//d1 – d2;//有意义
//d1 + d2;//无意义
//是否要重载运算符，取决于这个运算法对这个类是否有意义
return 0;
}

②重载函数写在类内（这时自变量可以私有化）

#include<iostream>
using namespace std;

class Date
{

public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Init(int year, int month, int day)
{
_year = year;//这里的_year是this->year，是d2的year
_month = month;
_day = day;
}
void Print()
{
cout << this << endl;
cout << _year << "-" << _month << "-" << _day << endl;
}
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;

}
bool operator<(const Date& x)
{
if (_year < x._year)
{
return true;
}
else if (_year == x._year && _month < x._month)
{
return true;
}
else
{
return false;
}
}
private:
int _year;
int _month;
int _day;
};

int main()
{
Date d1(2026,6,12);
Date d2(2026, 6, 8);
//方法一：d1 < d2; //转换成operator < (d1, d2);
// 方法二：d1<d2;//转换成d1.operator<(d2);
//d1 – d2;//有意义
//d1 + d2;//无意义
//是否要重载运算符，取决于这个运算法对这个类是否有意义
return 0;
}

注意事项：

拷贝构造是用一个对象去初始化另一个对象

以下是最简单的复制拷贝：

现在有一种情况

修改：

#include<iostream>
using namespace std;

class Date
{

public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Init(int year, int month, int day)
{
_year = year;//这里的_year是this->year，是d2的year
_month = month;
_day = day;
}
void Print()
{
cout << this << endl;
cout << _year << "-" << _month << "-" << _day << endl;
}
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;

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

}

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

return *this;
}
private:
int _year;
int _month;
int _day;
};

int main()
{
Date d1(2026,6,12);
Date d2(2026, 6, 8);

//已经存在的两个对象之间的复制拷贝 — 本质是运算符重载函数
d1 = d2;

//用一个已经存在的对象初始化另一个对象 —本质是构造函数
Date d3(d1);
return 0;
}

当然这里还有BUG：如果d1=d1呢？修改：

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

return *this;
}