class Date
{
public:
  //这可以用缺省参数来合成一个
  //Date()//函数名相同，没有返回值
  //{
  //  year_ = 0;
  //  month_ = 1;
  //  day_ = 1;
  //}
  //Date(int year,int month,int day)//函数重载
  //{
  //  year_ = year;
  //  month_ = month;
  //  day_ = day;
  //}
  Date(int year=0, int month=1, int day=2)//函数重载，全缺省更好用,推荐全缺省或者版半缺省 
  {
    year_ = year;
    month_ = month;
    day_ = day;
  }
private:
  //c++里面把类型分为两类，内置类型（基本类型），自定义类型
  //内置类型，int,double,long ,int arr[]
  //自定义类型：struct class
  //我们不写编译器默认生成的构造函数，对于内置类型不做初始化处理
  //对于自定义类型回去调用他的无参默认构造函数（不用参数就可以调用的）初始化
  //默认构造函数，1.无参的2.全缺省的。3，我们不写，编译器自己默认生成的
  //如果没有默认构造函数就会报错
  int year_;
  int day_;
  int month_;
  A _aa;
};
int main()
{
  //自动调用
  Date d;//这就是对象的实例化
  //year=0,day=1,month=1
  Date d2(2022, 1, 15);
  //year=2022,month=1,day=15
  Date d3(2022);
  Date d4  (2022, 3);
  return 0;
}

class Date
{
public:
  Date(int year = 1, int month = 1, int day = 2)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  ~Date()
  {
    //资源的清理
    cout << "~Date()" << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  //自动调用
  Date d;//这就是对象的实例化
  //year=0,day=1,month=1
  Date d2(2022, 1, 15);
  //year=2022,month=1,day=15
  Date d3(2022);
  Date d4  (2022, 3);
  //结束了就会自动上去调用析构函数
//但是对于Date类没有必要清理，
  Stack   s1;
  Stack s2(4);
  //析构的顺序是相反的,从后往前析构 
  return 0;
}

//用一个已经存在的成员去初始化一个不存在的成员
Date(const Date&d);//要用传引用，否则就会一直循环下去，

int main()
{
  Date d1(2022, 11, 9);
  //想去拷贝一下对象，
  //拷贝复制
  //前拷贝
  Date d2(d1);//c++里面传值传参就是拷贝构造，用一个同类型对象初始化我，就是拷贝构造，我们不写也会拷贝
  Stack st1(10);
  Stack st2(st1);
  //st2里面的数组地址指向同一个空间，出了作用域st2要析构，要对指向的空间进行析构，但是st1已经析构过了，一块空间不能析构两次
  //导致程序崩溃，应该要有自己独立的空间
  //后面还要学习深拷贝（要我们自己实现拷贝构造函数）
  return 0;
}

//写在类里面，因为有一个隐含的this指针，所以看上去只有一个参数，实际上是有两个，实现和原来运算符一样的功能
  bool operator>(const Date& d2)//==(const Date* this,const Date& d),d1传给this，d2传给d
  {
    if (_year > d2._year)
    {
      return true;
    }
    else if (_month > d2._month)
    {
      return true;
    }
    else if (_year == d2._year && _month == d2._month && _day > d2._day)
    {
      return true;
    }
    else
    {
      return false;
    }
  }

  Date& operator=(const Date& d)//两个参数
  {
    //极端情况下自己给自己赋值就可以不用处理了，直接判断一下跳过，
    if (this != &d)//如果自己和自己不相等，&d是取地址,this也是指针，用地址去比较
    {
      _year = d._year;
      _month = d._month;
      _day = d._day;
    }
    return *this;//this是指针，*this就是一个d1，返回左操作数
    //会有传值返回就会有调用拷贝构造，所以我们用传引用比较好一点，不会调用拷贝构造
    //出了作用域*this还在，*this就是d1，所以我们传引用返回
  }