【C++】类与对象（三） 运算符重载 赋值重载 取地址及const取地址操作符重载（1）

#include<iostream>
using namespace std;
class Date
{
public:
  Date(int year = 1, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  //给一个给日期加num天，不修改原始值
  Date Add(int num)
  {
    //......
  }
  //给一个日期加num天，并修改原始值
  Date AddEqual(int num)
  {
    //.....
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  int a = 10;
  a + 10;
  a += 10;
  Date d1;
  d1.Add(10);
  //d1+10;    //想写成这样，这样更直观方便，可是编译器不允许啊啊啊
  d1.AddEqual(10);
  //d1+=10;   //想写成这样，这样更直观方便，可是编译器不允许啊啊啊
  return 0;
}

// 全局的operator==
#include<iostream>
using namespace std;
class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
//private:
  int _year;
  int _month;
  int _day;
};
// 这里会发现：运算符重载成全局的 就需要成员变量是公有的，不然下面的函数无法访问到成员变量，
// 那么问题来了，封装性如何保证？
//这点我们现在还没有办法解决,所以我们先暂时将成员设定为公有。
//还有一种办法就是把它写进类中，变成成员函数。（暂时不用此种方法）
//判断两个对象是否相同
bool operator==(const Date& d1, const Date& d2)
{
  return d1._year == d2._year
    && d1._month == d2._month
    && d1._day == d2._day;
}
void Test()
{
  Date d1(2023, 2, 12);
  Date d2(2023, 2, 12);
  cout << operator==(d1, d2) << endl;//判断两个对象是否相同，第一种使用方法，直接调用函数
  cout << (d1 == d2) << endl;//判断两个对象是否相同，第二种使用方法，使用重载后的运算符
  //此处必须加括号，运算符优先级：<< 大于 ==
}

class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  Date& operator+(int num)
  {
    //......
  }
  Date& operator-(Date& d)
  {
    //......
  }
  Date& operator+=(int num)
  {
    //......
  }
  //......
  //其实这么多运算符重载我们可以一一实现，也可以实现一到两个，然后让其他运算符重载
private:
  int _year;
  int _month;
  int _day;
};

//前置++
  Date& operator++()
  {
  }
//后置++
  Date operator++()
  {
  }

//前置++
  Date& operator++()
  {
    *this += 1;//假设 +=我们已经运算符重载过了
    return this;
  }
//后置++
  Date operator++(int a)//形参名可以不写，直接写成 int，调用时也不需要传递参数
  {
    Date tmp(this); //会去调用拷贝构造 
    *this += 1; //假设 +=我们已经运算符重载过了
    return tmp;
  }

//<< 运算符重载
#include<iostream>
using namespace std;
class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  ostream& operator<< (ostream&out)
  {
    out << _year << "年" << _month << "月" << _day << "日" << endl;
    return out;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  int a = 10;
  cout << a << endl;//C++对自定义类型已经实现了 << 的运算符重载
  cout << d1;  
  return 0;
}

d1 << cout;           //第一种写法
d1.operator<<(cout);  //第二种写法

cout << d1;

#include<iostream>
using namespace std;
class Date
{
  friend ostream& operator<<(ostream& out, Date& d);//友元，允许我们在类外部使用成员变量。
public:
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
private:
  int _year;
  int _month;
  int _day;
};
ostream& operator<<(ostream& out, Date& d)
{
  out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
  return out;
}
int main()
{
  Date d1;
  int a = 10;
  cout << a << endl;//C++对自定义类型已经实现了 << 的运算符重载
  cout << d1;
  return 0;
}

//假如d1 d2 d3 都是Date类型
cout << d1 << d2 << d3 << endl;