类和对象（中）：构造、析构与拷贝，对象的生死与复制

class A
{
public:
    A()  { cout << "构造" << endl; }
    ~A() { cout << "析构" << endl; }
};
 
int main()
{
    A a;          // 触发默认构造
    A a2 = a;     // 触发默认拷贝构造
    a = a2;       // 触发默认赋值重载
    return 0;
}

#include <iostream>
using namespace std;
 
class Date
{
public:
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year = 1900;   // C++11 起支持类内默认初始化
    int _month = 1;
    int _day = 1;
};
 
int main()
{
    Date d;    // 没有任何构造，编译器生成默认构造，会带上类内缺省值
    d.Print(); // 输出：1900-1-1
    return 0;
}

#include <iostream>
using namespace std;
 
class Date
{
public:
    // 1. 无参构造函数：也是默认构造函数，因为不给实参就能调用
    Date()
    {
        _year = 1;
        _month = 1;
        _day = 1;
    }
 
    // 2. 带参构造函数：构造对象时传入年/月/日
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
 
    void Print()
    {
        cout << _year << "/" << _month << "/" << _day << endl;
    }
 
private:
    int _year;
    int _month;
    int _day;
};
 
int main()
{
    Date d1;              // 调用无参构造函数，结果 _year=1,_month=1,_day=1
    Date d2(2025, 4, 18); // 调用带参构造函数，结果 _year=2025,_month=4,_day=18
    d1.Print();
    d2.Print();
 
    // 这里埋个坑：如果你写 Date d3(); 编译器会把这行当成
    // "声明一个名叫 d3、返回值是 Date、参数为空的函数"，而不是定义对象！
    // 因此通过无参构造创建对象时，对象名后面千万不要跟括号。
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;
 
typedef int STDataType;
 
class Stack
{
public:
    // 全缺省构造函数：默认值 n=4，既满足"不给实参能调用"，又能按需传参
    Stack(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (_a == NULL)
        {
            perror("malloc 申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }
 
    ~Stack()
    {
        cout << "~Stack()" << endl;
        free(_a);
        _a = NULL;
        _top = _capacity = 0;
    }
 
private:
    STDataType* _a;   // 指向动态申请的内存
    size_t _capacity; // 容量
    size_t _top;      // 元素个数
};
 
// 用两个 Stack 组合出一个 MyQueue，我这里故意什么都不写
class MyQueue
{
public:
    // 这一行注释上方是一片空白：我没有写任何构造、析构
private:
    Stack _pushst; // 自定义类型成员，用来入队
    Stack _popst;  // 自定义类型成员，用来出队
};
 
int main()
{
    Stack st;  // 调用 Stack 的全缺省构造，_a 指向申请好的 4 个 int 的空间
    MyQueue mq; // 关键在这里：编译器生成的 MyQueue 构造，会自动去调 _pushst 和 _popst 的构造
    return 0;
}

#include <iostream>
using namespace std;
 
class A
{
public:
    A()  { cout << "A() 构造" << endl; }
    ~A() { cout << "~A() 析构" << endl; }
};
 
class B
{
public:
    B()  { cout << "B() 构造" << endl; }
    ~B() { cout << "~B() 析构" << endl; }
};
 
int main()
{
    A a;   // main 中先定义 a
    B b;   // 后定义 b
    cout << "main 函数即将结束" << endl;
    return 0;
    // 最终输出顺序：
    // A() 构造
    // B() 构造
    // main 函数即将结束
    // ~B() 析构   <- 后定义的先析构
    // ~A() 析构   <- 先定义的后析构
}

#include <iostream>
using namespace std;
 
typedef int STDataType;
 
class Stack
{
public:
    // 构造：对象一出场内存就申请好了，不用手动 Init
    Stack(int n = 4)
    {
        _a = new STDataType[n];
        if (_a == nullptr)
        {
            cout << "new 失败" << endl;
            return;
        }
        _capacity = n;
        _top = 0;
    }
 
    void Push(STDataType x)
    {
        // 简化处理：满了就直接扩容一倍
        if (_top == _capacity)
        {
            int newCap = _capacity * 2;
            STDataType* tmp = new STDataType[newCap];
            for (size_t i = 0; i < _top; ++i)
            {
                tmp[i] = _a[i];   // 把旧数据搬过去
            }
            delete[] _a;          // 释放旧的
            _a = tmp;
            _capacity = newCap;
        }
        _a[_top++] = x;
    }
 
    bool Empty() const { return _top == 0; }
    STDataType Top() const { return _a[_top - 1]; }
    void Pop() { if (_top > 0) --_top; }
 
    // 析构：对象一死亡资源自动释放，不用手动 Destroy
    ~Stack()
    {
        delete[] _a;
        _a = nullptr;
        _top = _capacity = 0;
    }
 
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};
 
// 检查括号是否匹配的经典问题
bool isValid(const char* s)
{
    Stack st;              // 自动构造，无需 STInit
    while (*s)
    {
        // 左括号直接入栈
        if (*s == '(' || *s == '[' || *s == '{')
        {
            st.Push(*s);
        }
        else // 右括号：去栈顶取一个左括号来配对
        {
            if (st.Empty())
            {
                return false;  // 右括号比左括号多，直接判不匹配
            }
            char top = st.Top();
            st.Pop();
            // 顺序不匹配的三种情况
            if ((*s == ')' && top != '(')
                || (*s == ']' && top != '[')
                || (*s == '}' && top != '{'))
            {
                return false;
            }
        }
        ++s; // 处理下一个字符
    }
    return st.Empty(); // 都配对完还剩余左括号，说明左括号多了
}
 
int main()
{
    cout << isValid("({[]})") << endl; // 期望输出 1，表示匹配
    cout << isValid("([)]") << endl;   // 期望输出 0，表示不匹配
    return 0;
}

#include <iostream>
using namespace std;
 
class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
 
    // 拷贝构造：参数是 const 类类型引用
    // 若写成 Date(Date d) 会报错：传值会引发自身的无限递归拷贝，导致栈溢出
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
 
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
 
private:
    int _year;
    int _month;
    int _day;
};
 
void Func1(Date d) // 传值传参：形参 d 要调拷贝构造来初始化
{
    d.Print();
}
 
int main()
{
    Date d1(2024, 7, 5);
 
    Date d2(d1);    // 写法一：显式调用拷贝构造
    Date d3 = d1;   // 写法二：也是拷贝构造（注意！这行是"拷贝初始化"，不是赋值）
 
    Func1(d1);      // 传值传参，隐式调用拷贝构造
 
    d1.Print();
    d2.Print();
    d3.Print();
    return 0;
}

#include <iostream>
using namespace std;
 
class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
 
// 反例：返回局部对象的引用
Date& Func2()
{
    Date tmp(2024, 7, 5); // tmp 是这里的局部对象
    tmp.Print();
    return tmp;           // 危险！函数结束 tmp 就销毁了，返回的是"野引用"
}
 
int main()
{
    Date ret = Func2(); // 拿到一个已经死亡的对象的别名
    ret.Print();        // 行为未定义，可能读到垃圾数据
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;
 
typedef int STDataType;
 
class Stack
{
public:
    Stack(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (_a == NULL)          // 记得加括号，NULL 是宏值 0
        {
            perror("malloc fail");
            return;
        }
        _capacity = n;
        _top = 0;
    }
 
    void Push(STDataType x)
    {
        if (_top == _capacity)   // 满了就扩到 2 倍
        {
            int newCap = _capacity * 2;
            STDataType* tmp = (STDataType*)realloc(_a, newCap * sizeof(STDataType));
            if (tmp == NULL)
            {
                perror("realloc fail");
                return;
            }
            _a = tmp;
            _capacity = newCap;
        }
        _a[_top++] = x;
    }
 
    ~Stack()
    {
        cout << "~Stack()" << endl;
        free(_a);      // 释放 _a 指向的内存
        _a = NULL;
        _top = _capacity = 0;
    }
 
private:
    STDataType* _a;   // 指向堆上的数组
    size_t _capacity;
    size_t _top;
};
 
// 注意：这个 Stack 我没有写拷贝构造，用的是编译器默认的浅拷贝
 
int main()
{
    Stack st1;
    st1.Push(1);
    st1.Push(2);
    Stack st2 = st1; // 浅拷贝！st2 的 _a 和 st1 的 _a 指向同一块堆内存
    return 0;        // 走到这里 st2 先析构释放一次，st1 再析构又释放一次，同一块内存 free 两次 => 崩溃！
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;
 
typedef int STDataType;
 
class Stack
{
public:
    Stack(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (_a == NULL)
        {
            perror("malloc fail");
            return;
        }
        _capacity = n;
        _top = 0;
    }
 
    // 深拷贝：给 _a 单独申请一块资源，再把内容原样拷过来
    Stack(const Stack& st)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
        if (_a == NULL)
        {
            perror("malloc fail");
            return;
        }
        memcpy(_a, st._a, sizeof(STDataType) * st._top); // 只拷贝实际用到的 _top 个元素
        _top = st._top;
        _capacity = st._capacity;
    }
 
    void Push(STDataType x)
    {
        if (_top == _capacity)
        {
            int newCap = _capacity * 2;
            STDataType* tmp = (STDataType*)realloc(_a, newCap * sizeof(STDataType));
            if (tmp == NULL)
            {
                perror("realloc fail");
                return;
            }
            _a = tmp;
            _capacity = newCap;
        }
        _a[_top++] = x;
    }
 
    ~Stack()
    {
        cout << "~Stack()" << endl;
        free(_a);
        _a = NULL;
        _top = _capacity = 0;
    }
 
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};
 
// 这个 Stack 的拷贝构造是深拷贝；只要它写对了，MyQueue 什么都不用写
class MyQueue
{
private:
    Stack _pushst;
    Stack _popst;
};
 
int main()
{
    Stack st1;
    st1.Push(1);
    st1.Push(2);
    Stack st2 = st1;  // 深拷贝：st2 的 _a 是全新的内存，内容为 {1,2}
    // 各析构各的，谁也不会碰谁的内存，安全释放
    return 0;
}

class Date
{
public:
    Date(int y, int m, int d)
        : _year(y)   // 初始化列表：冒号后是"成员名(实参)"的形式
        , _month(m)
        , _day(d)
    { }
private:
    int _year;
    int _month;
    int _day;
};

#include <iostream>
using namespace std;
 
class Time
{
public:
    // 只提供带参构造，没有提供"不给实参也能调"的默认构造
    Time(int h, int m, int s)
    {
        _hour = h;
        _minute = m;
        _second = s;
    }
    void Print() const
    {
        cout << _hour << ":" << _minute << ":" << _second << endl;
    }
private:
    int _hour;
    int _minute;
    int _second;
};
 
class Date
{
public:
    // 必须用初始化列表给 _time 传入实参，否则 _time 没有默认构造可用，编译报错
    Date(int year, int month, int day, int h, int m, int s)
        : _time(h, m, s)   // 初始化列表：显式调用 Time 的带参构造
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print() const
    {
        _time.Print();
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
    Time _time;    // 自定义类型成员，没有默认构造
};
 
int main()
{
    Date d(2025, 4, 18, 9, 30, 0);
    d.Print();
    return 0;
}

#include <iostream>
using namespace std;
 
class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
 
    // 成员函数重载 operator==：左边对象用 this，右边对象用形参 d
    bool operator==(const Date& d) const
    {
        return _year == d._year
            && _month == d._month
            && _day == d._day;
    }
 
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
 
private:
    int _year;
    int _month;
    int _day;
};
 
int main()
{
    Date d1(2024, 7, 5);
    Date d2(2024, 7, 6);
    Date d3(2024, 7, 5);
 
    // 编译器会把 d1 == d2 转成 d1.operator==(d2)
    cout << (d1 == d2) << endl;   // 输出 0，年相同、月相同、但日 5!=6
    cout << (d1 == d3) << endl;   // 输出 1，三个字段都相等
 
    // 运算符重载函数也可以像普通函数一样显式调用
    cout << d1.operator==(d2) << endl; // 等价于 d1 == d2，输出 0
    return 0;
}

#include <iostream>
using namespace std;
 
class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
 
    // 前置 ++：先自增，再返回自增后的对象本身，因此返回引用
    Date& operator++()
    {
        cout << "前置++：" << _year << "-" << _month << "-" << _day << endl;
        ++_day;          // 简化实现：只让天数 +1，日期校正逻辑略去
        return *this;    // 返回 *this，即对象自增后的本体
    }
 
    // 后置 ++：先返回自增前的副本，再自增；函数名相同，靠多出的 int 形参区分
    Date operator++(int) // 注意：这里的 int 是"哑参数"，只用来区分，不接收真实值
    {
        cout << "后置++：" << _year << "-" << _month << "-" << _day << endl;
        Date tmp = *this;  // 保存自增前的副本
        ++_day;            // 本体自增
        return tmp;        // 返回的是自增前的副本，符合"后置++先取旧值"的语义
    }
 
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
 
private:
    int _year;
    int _month;
    int _day;
};
 
int main()
{
    Date d1(2024, 7, 5);
    ++d1;   // 编译器转成 d1.operator++()
    d1.Print();
 
    Date d2 = d1++; // d1++ 转成 d1.operator++(0)；d1 本身 +1，d2 拿到 +1 前的旧值
    d1.Print();
    d2.Print();
    return 0;
}

ostream& operator<<(ostream& out, const Date& d);   // 全局函数，第一个参数是流
istream& operator>>(istream& in, Date& d);          // 全局函数，第一个参数是流

#include <iostream>
using namespace std;
 
class Date
{
    // 声明为友元：允许这个全局函数访问私有成员
    friend ostream& operator<<(ostream& out, const Date& d);
public:
    Date(int year = 1, int month = 1, int day = 1)
        : _year(year), _month(month), _day(day)
    { }
private:
    int _year;
    int _month;
    int _day;
};
 
// 全局重载 <<：第一个参数是流，第二个参数是对象
ostream& operator<<(ostream& out, const Date& d)
{
    out << d._year << "年" << d._month << "月" << d._day << "日";
    return out;   // 返回 out，支持 cout << d1 << d2 的连续输出
}
 
int main()
{
    Date d1(2024, 7, 5);
    Date d2(2025, 1, 1);
    cout << d1 << endl;   // 输出：2024年7月5日
    cout << d1 << " | " << d2 << endl;  // 连续链式输出：2024年7月5日 | 2025年1月1日
    return 0;
}

#include <iostream>
using namespace std;
 
class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
 
    // 赋值运算符重载：两个已存在的对象之间赋值
    Date& operator=(const Date& d)
    {
        if (this != &d)     // 自赋值检查：防止 d1 = d1 自己赋给自己
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
        return *this;       // 返回 *this，以支持 d1 = d2 = d3 的连续赋值
    }
 
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
 
private:
    int _year;
    int _month;
    int _day;
};
 
int main()
{
    Date d1(2024, 7, 5);
    Date d2(2030, 1, 1);
    Date d3(2025, 4, 18);
 
    d2 = d3;    // 赋值：d2 和 d3 都已存在，把 d3 的值赋给 d2。编译器转成 d2.operator=(d3)
    d2.Print();
 
    // 请特别注意：下面这行 Date d4 = d1; 看起来像赋值，
    // 但 d4 是"正在创建的新对象"，所以这行走的是拷贝构造，不是赋值重载！
    Date d4 = d1; // 拷贝构造
    d4.Print();
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;
 
typedef int STDataType;
 
class Stack
{
public:
    Stack(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (_a == NULL)
        {
            perror("malloc fail");
            return;
        }
        _capacity = n;
        _top = 0;
    }
 
    Stack(const Stack& st)   // 拷贝构造：深拷贝
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
        if (_a == NULL)
        {
            perror("malloc fail");
            return;
        }
        memcpy(_a, st._a, sizeof(STDataType) * st._top);
        _top = st._top;
        _capacity = st._capacity;
    }
 
    // 赋值重载：也是深拷贝。特别要注意"先释放旧资源"
    Stack& operator=(const Stack& st)
    {
        if (this != &st)   // 自赋值检查：如果是 st = st，直接跳过，避免自释放后自拷贝
        {
            free(_a);      // 关键！先把左边对象自己的旧资源释放掉
            _a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
            if (_a == NULL)
            {
                perror("malloc fail");
                _top = _capacity = 0;
                return *this;
            }
            memcpy(_a, st._a, sizeof(STDataType) * st._top); // 深拷贝数据
            _top = st._top;
            _capacity = st._capacity;
        }
        return *this; // 支持连续赋值
    }
 
    void Push(STDataType x)
    {
        if (_top == _capacity)
        {
            int newCap = _capacity * 2;
            STDataType* tmp = (STDataType*)realloc(_a, newCap * sizeof(STDataType));
            if (tmp == NULL)
            {
                perror("realloc fail");
                return;
            }
            _a = tmp;
            _capacity = newCap;
        }
        _a[_top++] = x;
    }
 
    ~Stack()
    {
        free(_a);
        _a = NULL;
        _top = _capacity = 0;
    }
 
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};
 
int main()
{
    Stack st1;
    st1.Push(1);
    st1.Push(2);
    Stack st2;
    st2.Push(3);
 
    st2 = st1; // 赋值：先释放 st2 旧的资源，再申请一块新的、内容为 {1,2} 的资源并拷进来
    st1.Push(100); // 此时 st1 变大，st2 不受任何影响，两者资源完全独立
    return 0;
}

void Print() const
{
    // ...
}

#include <iostream>
using namespace std;
 
class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
 
    // const 成员函数：内部 this 是 const Date* const，不能修改任何成员
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
 
private:
    int _year;
    int _month;
    int _day;
};
 
int main()
{
    // 非 const 对象也能调用 const 成员函数，这属于"权限缩小"，安全
    Date d1(2024, 7, 5);
    d1.Print();
 
    // const 对象必须通过 const 成员函数来读取，否则编译报错
    const Date d2(2024, 8, 5);
    d2.Print(); // 通过！因为 Print 是 const 成员函数
    return 0;
}

#include <iostream>
using namespace std;
 
class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
 
    // 普通取地址重载：让 &对象 返回这个对象的真实地址（this）
    Date* operator&()
    {
        return this;
        // return nullptr;   // 如果你不想让别人拿到真实地址，就手动返回其它值
    }
 
    // const 对象取地址重载：const 版本返回 const 指针
    const Date* operator&() const
    {
        return this;
        // return nullptr;
    }
 
private:
    int _year;   // 年
    int _month;  // 月
    int _day;    // 日
};
 
int main()
{
    Date d(2025, 4, 18);
    Date* p = &d;       // 普通对象取地址，走 Date* operator&()
    cout << p << endl;
 
    const Date cd(2025, 4, 18);
    const Date* cp = &cd; // const 对象取地址，走 const Date* operator&() const
    cout << cp << endl;
    return 0;
}

#include <iostream>
#include <cassert>
using namespace std;
 
class Date
{
    // 把 << 和 >> 声明为 Date 的友元，让全局函数能访问私有成员
    friend ostream& operator<<(ostream& out, const Date& d);
    friend istream& operator>>(istream& in, Date& d);
public:
    // 全缺省构造：既是默认构造，又能按需初始化
    Date(int year = 1900, int month = 1, int day = 1)
        : _year(year), _month(month), _day(day)
    {
        if (_month < 1 || _month > 12
            || _day < 1 || _day > GetMonthDay(_year, _month))
        {
            cout << "日期非法" << endl;
        }
    }
 
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
 
    // 判断某年某月有几天：处理闰年（四年一闰，百年不闰，四百年再闰）
    int GetMonthDay(int year, int month) const
    {
        assert(month >= 1 && month <= 12);
        static int monthDayArray[13] = { -1, 31, 28, 31, 30, 31, 30,
                                         31, 31, 30, 31, 30, 31 };
        if (month == 2
            && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
        {
            return 29;   // 闰年二月
        }
        return monthDayArray[month];
    }
 
    // 六个比较运算符：全部用 const 成员函数重载，只读不改
    bool operator==(const Date& d) const
    {
        return _year == d._year
            && _month == d._month
            && _day == d._day;
    }
 
    bool operator<(const Date& d) const
    {
        if (_year < d._year) return true;
        if (_year > d._year) return false;
        if (_month < d._month) return true;
        if (_month > d._month) return false;
        return _day < d._day;
    }
 
    // 复数个逻辑运算符可以基于一个基础运算符组合出来
    bool operator<=(const Date& d) const { return *this < d || *this == d; }
    bool operator>(const Date& d) const  { return !(*this <= d); }
    bool operator>=(const Date& d) const { return !(*this < d); }
    bool operator!=(const Date& d) const { return !(*this == d); }
 
    // d1 += days：返回引用，因为要改自己；days 可为负
    Date& operator+=(int day)
    {
        if (day < 0)
        {
            return *this -= -day;   // 天数为负，转成 -= 运算
        }
        _day += day;
        while (_day > GetMonthDay(_year, _month))  // 天后了，往前进位
        {
            _day -= GetMonthDay(_year, _month);
            ++_month;
            if (_month == 13)
            {
                ++_year;
                _month = 1;
            }
        }
        return *this;
    }
 
    // d1 + days：不改动 d1，返回一个新对象，因此是 const + 值返回
    Date operator+(int day) const
    {
        Date tmp = *this;   // 拷一份副本
        tmp += day;          // 调整副本
        return tmp;          // 返回副本，d1 本身不动
    }
 
    // d1 -= days：同理，支持负数
    Date& operator-=(int day)
    {
        if (day < 0)
        {
            return *this += -day;   // 天数为负，转成 += 运算
        }
        _day -= day;
        while (_day <= 0)      // 天不够了，往前借位
        {
            --_month;
            if (_month == 0)
            {
                _month = 12;
                --_year;
            }
            _day += GetMonthDay(_year, _month);   // 借上个月的天数
        }
        return *this;
    }
 
    // d1 - days
    Date operator-(int day) const
    {
        Date tmp = *this;
        tmp -= day;
        return tmp;
    }
 
    // 前置 ++：返回引用
    Date& operator++()
    {
        *this += 1;
        return *this;
    }
 
    // 后置 ++：用 int 哑参数区分，返回自增前的副本（值返回）
    Date operator++(int)
    {
        Date tmp = *this;
        *this += 1;
        return tmp;
    }
 
    // 前置 --
    Date& operator--()
    {
        *this -= 1;
        return *this;
    }
 
    // 后置 --
    Date operator--(int)
    {
        Date tmp = *this;
        *this -= 1;
        return tmp;
    }
 
    // d1 - d2：两个日期相差多少天（结果可正可负）
    int operator-(const Date& d) const
    {
        Date max = *this;
        Date min = d;
        int flag = 1;
        if (*this < d)
        {
            max = d;
            min = *this;
            flag = -1;
        }
        int n = 0;
        while (min != max)   // min 一天天自增，数到和 max 相等所需的天数
        {
            ++min;
            ++n;
        }
        return n * flag;
    }
 
private:
    int _year;   // 年
    int _month;  // 月
    int _day;    // 日
};
 
// 全局重载 <<：第一个参数是流，第二个是对象，靠 friend 访问私有成员
ostream& operator<<(ostream& out, const Date& d)
{
    out << d._year << "年" << d._month << "月" << d._day << "日";
    return out;   // 返回 out，支持 cout << d1 << d2 的连续输出
}
 
// 全局重载 >>：从流读入年月日
istream& operator>>(istream& in, Date& d)
{
    cout << "请依次输入年月日（空格分隔）:>";
    in >> d._year >> d._month >> d._day;
    return in;   // 返回 in，支持 cin >> d1 >> d2
}
 
int main()
{
    // 构造 + 打印
    Date d1(2024, 7, 5);
    Date d2(2024, 7, 6);
    d1.Print();                            // 输出: 2024-7-5
 
    // 比较
    cout << (d1 < d2) << endl;             // 输出 1
    cout << (d1 == d2) << endl;            // 输出 0
 
    // += 和 +
    Date d10(2024, 7, 5);
    d10 += 30;          // 30 天后进位，变成 2024-08-04
    d10.Print();
    Date d11(2024, 7, 5);
    Date d12 = d11 + 60; // 60 天后又是一次跨月进位，变成 2024-09-03；d11 本身不变
    d11.Print();
    d12.Print();
 
    // -= 和 -
    Date d20(2024, 3, 1);
    d20 -= 1;           // 往前退 1 天，借位回到 2024-02-29（2024 是闰年，所以有 29 号）
    d20.Print();
 
    // 前置 / 后置 ++
    Date d30(2024, 7, 5);
    ++d30;              // 前置：变成 2024-07-06
    d30.Print();
    Date d31 = d30++;   // 后置：d31 拿到自增前（07-06），d30 变成 07-07
    d30.Print();
    d31.Print();
 
    // 两个日期求天数差
    Date d40(2024, 7, 5);
    Date d41(2024, 8, 9);
    cout << "天数差: " << (d41 - d40) << endl;   // 输出 35
 
    // 用重载的 << 打印（走 ostream& operator<<）
    cout << d11 << endl;   // 输出：2024年7月5日
    return 0;
}