struct Student {
    char name[20];
    int age;
    int id;
};

void printStudent(const struct Student* s) {
    printf("姓名: %s, 年龄: %d, 学号: %d\n", s->name, s->age, s->id);
}

int main() {
    struct Student stu = {"张三", 18, 1001};
    printStudent(&stu);
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Student {
public:
    // 成员函数
    void setName(const string& name) { _name = name; }  //成员变量前加上了_，就容易区分_name = name中哪个是成员变量了
    void setAge(int age) { _age = age; }
    void setId(int id) { _id = id; }
    void print() const {
        cout << "姓名: " << _name << ", 年龄: " << _age << ", 学号: " << _id << endl;
    }

private:
    // 成员变量
    string _name;  //成员变量加上_方便区分
    int _age;
    int _id;
};

int main() {
    Student stu;
    stu.setName("张三");
    stu.setAge(18);
    stu.setId(1001);
    stu.print();
    return 0;
}

class Student {  
public:

    void setName(const string& n);  //声明和定义分离则不默认内联

    void print() const {       //定义在类里面的函数默认内联
        cout << "姓名: " << _name  << endl;
    }
private:
    // 成员变量
    string _name;  
};

    //使用 :: 访问类域Student
    void Student::setName(const string& n)  
    {
     _name = n;
    }

struct Student {  
public:
    // 在C++中struct里也可以定义成员函数
    void setName(const string& n) { _name = n; }
    void print() const {
        cout << "姓名: " << _name  << endl;
    }
private:
    // 成员变量
    string _name;  
};

struct ListNode {
    int val;
    //ListNode* next;  C语言中无法这样使用,编译不通过
    struct ListNode* next;
};

typedef struct ListNode {
    int val;
    struct ListNode* next;  
}ListNode;

struct ListNode {
    int val;
    ListNode* next;  //C++中两种方式都支持
    //struct ListNode* next;
};

class A {


    // class类没有访问限定符默认私有

public:
    // 公有成员（对外接口）
protected:
    // 保护成员（供派生类访问）
private:
    // 私有成员（仅本类内部访问）

public:
    // 公有成员，访问限定符public作用范围到类的结尾

};  // 注意分号

struct B {

    // struct类没有访问限定符默认公有

public:
    // 公有成员（对外接口）
protected:
    // 保护成员（供派生类访问）
private:
    // 私有成员（仅本类内部访问）

public:
    // 公有成员，访问限定符public作用范围到类的结尾

};

class Student {  
public:

    void setName(const string& n) 
    {
     _name = n;
    }

    void print() const {       
        cout << "姓名: " << _name  << endl;
    }
private:
    string _name;  
};
int main()
{    
    Student A;  //实例化出A和B两个对象
    Student B;
    return 0;
}

class A {  
    char ch;
    int i;
};

class B {  
};
B b;

class Student {  
public:

    void setName(const string& n) 
    {
    //this->_name = n;
     _name = n;   //通过this指针访问
    }

    void print() const {       
        cout << "姓名: " << _name  << endl;
    }
private:
    string _name;  
};
Student A;
Student B;

A.setName("张三");  //隐含了this指针
B.setName("李四");
A.print();
B.print();

class A {
public:
    void Func() {
        cout << "Func called" << endl;   // 没有使用 this，可以正常运行
    }
    void Func2() {
        cout << _a << endl;   // 访问了成员变量，相当于 this->_a，会崩溃
    }
private:
    int _a;
};

int main() {
    A* p = nullptr;
    p->Func();   // 输出 "Func called"，正常运行
    p->Func2();  // 运行时崩溃（访问空指针）
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

typedef int STDataType;

typedef struct Stack {
    STDataType* a;
    int top;
    int capacity;
} ST;

void STInit(ST* ps) {
    assert(ps);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}

void STDestroy(ST* ps) {
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;
}

void STPush(ST* ps, STDataType x) {
    assert(ps);
    if (ps->top == ps->capacity) {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
        if (tmp == NULL) {
            perror("realloc fail");
            return;
        }
        ps->a = tmp;
        ps->capacity = newcapacity;
    }
    ps->a[ps->top++] = x;
}

void STPop(ST* ps) {
    assert(ps);
    assert(ps->top > 0);
    ps->top--;
}

STDataType STTop(ST* ps) {
    assert(ps);
    assert(ps->top > 0);
    return ps->a[ps->top - 1];
}

bool STEmpty(ST* ps) {
    assert(ps);
    return ps->top == 0;
}

int main() {
    ST s;
    STInit(&s);          // 必须手动初始化
    STPush(&s, 1);
    STPush(&s, 2);
    STPush(&s, 3);
    while (!STEmpty(&s)) {
        printf("%d\n", STTop(&s));
        STPop(&s);
    }
    STDestroy(&s);       // 必须手动释放资源
    return 0;
}

#include <iostream>
#include <cstdlib>
#include <cassert>
using namespace std;

typedef int STDataType;

class Stack {
public:
    // 构造函数：初始化对象
    Stack(int n = 4) {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (_a == nullptr) {
            perror("malloc fail");
            return;
        }
        _capacity = n;
        _top = 0;
    }

    // 析构函数：释放资源
    ~Stack() {
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }

    void Push(STDataType x) {
        if (_top == _capacity) {
            int newcapacity = _capacity * 2;
            STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
            if (tmp == nullptr) {
                perror("realloc fail");
                return;
            }
            _a = tmp;
            _capacity = newcapacity;
        }
        _a[_top++] = x;
    }

    void Pop() {
        assert(_top > 0);
        _top--;
    }

    STDataType Top() const {
        assert(_top > 0);
        return _a[_top - 1];
    }

    bool Empty() const {
        return _top == 0;
    }

private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

int main() {
    Stack s;               // 自动调用构造函数初始化
    s.Push(1);
    s.Push(2);
    s.Push(3);
    while (!s.Empty()) {
        cout << s.Top() << endl;
        s.Pop();
    }
    // 离开作用域时，自动调用析构函数释放资源
    return 0;
}

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;
// }


// 3.全缺省构造函数
//写了全缺省就不需要写无参了，同时存在会构成函数重载歧义，同时也不需要写带参的了，全缺省可以完美代替
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};

int main()
{
    Date A;             //调用无参构造，不需要写括号(),否则编译器无法区分这里是函数声明还是实例化对象
    Date B(1979,1,1);   //调用带参构造
}

int main()
{                             
    Date C;            //无参构造，不需要写括号()
    Date D(1979,1,1); //全缺省构造函数，无参，带一半参数，全参数都可以应对
    Date E(1999); 

}

//Date类
~Date()   //析构函数，在类名前加上字符~
{}        

Stack ss; 
int main() {
    {
        Stack s;      // 构造
    }                 // 离开作用域，s 的析构函数自动调用
    Stack* p = new Stack;   // 构造
    delete p;                // 析构
    return 0;
}              //程序结束ss析构

class A{
~A(){}

Date _D;   //即使类A的析构什么都不处理，或者不写类A的析构，也会自动调用Date的析构
int _i;   
};      

//动态内存管理需要写析构
class String {
public:
    String(const char* s = "") {
        _data = new char[strlen(s) + 1];
        strcpy(_data, s);
    }

    ~String() {
        delete[] _data;   // 必须释放
    }

private:
    char* _data;
};    

//文件操作需要写析构
class FileHandler {
public:
    FileHandler(const char* filename) {
        _file = fopen(filename, "r");
        if (!_file) throw runtime_error("open file failed");
    }

    ~FileHandler() {
        if (_file) fclose(_file);
    }
private:
    FILE* _file;
};  

{
Date D1;   
Date D2;   
}      //先析构D2再析构D1

class Date {
public:
    // 拷贝构造函数的声明
    Date(const Date& d);   // 参数为本类类型的 const 引用
    // ...
};

// 错误！会导致无穷递归
Date(const Date d);   // 传值，编译错误
// 正确
Date(const Date& d);  // 传引用

//用已有对象初始化新对象
Date d2(d1);       // 拷贝构造
Date d3 = d1;      // 也是拷贝构造（等号在这里是初始化，不是赋值）

//函数传值传参
void func(Date d) { ... }
Date d1;
func(d1);   // 实参 d1 拷贝构造形参 d

//函数传值返回
Date func() {
    Date tmp;
    return tmp;   // 返回时拷贝构造一个临时对象
}

//当类中有指针成员指向动态内存时，默认拷贝构造的浅拷贝会带来严重问题
class Stack {
public:
    Stack(int n = 4) {
        _a = new int[n];
        _capacity = n;
        _top = 0;
    }
    ~Stack() { delete[] _a; }
    // 没有自定义拷贝构造
private:
    int* _a;
    size_t _capacity;
    size_t _top;
};

int main() {
    Stack s1;
    s1.Push(1);
    Stack s2 = s1;   // 默认拷贝构造，浅拷贝
    // s1 和 s2 的 _a 指向同一块内存
    // 析构时，先析构 s2，释放内存；再析构 s1，再次释放同一块内存 -> 崩溃！
}

//对于有资源管理的类，必须自己实现 深拷贝：为每个对象分配独立的内存，并复制源对象的内容。
class Stack {
public:
    // 构造函数
    Stack(int n = 4) {
        _a = new int[n];
        _capacity = n;
        _top = 0;
    }

    // 深拷贝的拷贝构造
    Stack(const Stack& st) {
        // 为新对象分配同样大小的内存
        _a = new int[st._capacity];
        // 复制数据
        for (size_t i = 0; i < st._top; ++i) {
            _a[i] = st._a[i];
        }
        _top = st._top;
        _capacity = st._capacity;
    }

    // 析构函数
    ~Stack() {
        delete[] _a;
    }

    // 其他成员函数...
private:
    int* _a;
    size_t _capacity;
    size_t _top;
};

// 传值返回：拷贝构造临时对象
Date getDate() {
    Date tmp(2024, 7, 5);
    return tmp;   // 拷贝构造临时对象,返回的是局部对象,必须采用传值返回
}

// 传引用返回：不拷贝，但要确保对象生命周期
Date& getDateRef(Date& d) {
    return d;     // 返回参数本身，没有拷贝
}

class Counter {
public:
    // 前置++
    Counter& operator++() {
        ++_value;
        return *this;   // 返回自身引用
    }

    // 后置++
    Counter operator++(int) {
        Counter tmp = *this;
        ++(*this);      // 复用前置++
        return tmp;     // 返回旧值
    }
private:
    int _value = 0;
};

class Date {
public:
    // 需要将友元声明放在类内，以便访问私有成员
    friend ostream& operator<<(ostream& out, const Date& d);
    friend istream& operator>>(istream& in, Date& d);
    // ...
private:
    int _year, _month, _day;
};

// 全局重载 <<
ostream& operator<<(ostream& out, const Date& d) {
    out << d._year << "-" << d._month << "-" << d._day;
    return out;   // 返回 out 以支持连续输出
}

// 全局重载 >>
istream& operator>>(istream& in, Date& d) {
    in >> d._year >> d._month >> d._day;
    return in;
}

Date d1(2024, 7, 5);
Date d2(d1);   // 拷贝构造（初始化）
Date d3;
d3 = d1;       // 赋值重载（赋值）

Date& operator=(const Date& d);   // 正确
// Date operator=(const Date& d); // 可以，但会多一次拷贝

class Date {
    int _year, _month, _day;
    string _note;   // 自定义类型
};
// 默认赋值运算符会逐字节复制 _year, _month, _day，并调用 _note 的赋值运算符

class Stack {
public:
    Stack(int n = 4) {
        _a = new int[n];
        _capacity = n;
        _top = 0;
    }
    ~Stack() { delete[] _a; }
    // 没有自定义赋值运算符
private:
    int* _a;
    size_t _capacity;
    size_t _top;
};

int main() {
    Stack s1, s2;
    s1.Push(1);
    s2 = s1;        // 默认赋值：浅拷贝，s2._a 与 s1._a 指向同一块内存
    // 析构时，先析构 s2，释放内存；再析构 s1，再次释放同一块内存 -> 崩溃！
}

class MyQueue {
    Stack pushst;
    Stack popst;
};
// 默认生成的 MyQueue 赋值运算符会调用 Stack 的赋值运算符，如果 Stack 已正确实现，则 MyQueue 的赋值是安全的

class Date {
public:
    // 声明为 const 成员函数，表示不会修改成员变量
    void Print() const {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

    // 非 const 成员函数，可以修改成员
    void SetYear(int year) {
        _year = year;
    }

private:
    int _year, _month, _day;
};

// 非 const 成员函数，this 类型为 Date* const
void SetYear(int year) {
    this->_year = year;   // 可以修改
}

// const 成员函数，this 类型为 const Date* const
void Print() const {
    cout << this->_year;  // 只能读取，不能修改
    // this->_year = 2024; // 错误！不能修改
}

class Array {
public:
    // 非 const 版本，返回引用，允许修改元素
    int& operator[](size_t index) {
        return _data[index];
    }

    // const 版本，返回 const 引用，只读
    const int& operator[](size_t index) const {
        return _data[index];
    }

private:
    int _data[10];
};

int main() {
    Array arr;
    arr[0] = 10;           // 调用非 const 版本

    const Array carr;
    cout << carr[0];       // 调用 const 版本
    // carr[0] = 20;       // 错误，不能修改 const 对象
}

class A {
public:
    void ConstFunc() const {
        _ptr = nullptr;   // 错误！不能修改指针本身
        *_ptr = 10;       // 可以！指针指向的内容可以被修改（因为指针指向的是非 const int）
    }
private:
    int* _ptr;
};

class Date {
public:
    Date* operator&() { return this; }
    const Date* operator&() const { return this; }
};

class Secret {
public:
    // 永远返回 nullptr，让外界无法获取有效地址
    Secret* operator&() {
        return nullptr;
    }

    const Secret* operator&() const {
        return nullptr;
    }

private:
    int _data;
};

int main() {
    Secret s;
    Secret* p = &s;   // p 得到 nullptr
    // 无法通过 p 访问对象，但 s 本身仍然可以正常使用
}

class Date {
public:
    Date(int year, int month, int day) {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year, _month, _day;
};

class Date {
public:
    // 初始化列表
    Date(int year, int month, int day)
        : _year(year), _month(month), _day(day)
    {
        // 函数体可以为空
    }
private:
    int _year, _month, _day;
};

class A {
public:
    A(int& ref) : _ref(ref) {}   // 必须使用初始化列表
private:
    int& _ref;
};

class B {
public:
    B(int n) : _n(n) {}   // 必须使用初始化列表
private:
    const int _n;
};

class Time {
public:
    Time(int hour) : _hour(hour) {}   // 没有默认构造
private:
    int _hour;
};

class Date {
public:
    Date(int hour) : _t(hour) {}      // 必须用初始化列表初始化 _t
private:
    Time _t;
};

class A {
public:
    A(int a, int b) : _a(a), _a(b) {}   // 错误！_a 重复初始化
private:
    int _a;
};

class C {
public:
    C(int a) : _b(a), _a(_b) {}   // 看起来 _b 先，_a 后
    void Print() { cout << _a << " " << _b << endl; }
private:
    int _a;   // 先声明
    int _b;   // 后声明
};

int main() {
    C c(5);
    c.Print();   // 输出：随机值 5       （_a 先初始化，此时 _b 还未初始化，_a = _b 是未定义行为）
    return 0;
}

class D {
public:
    static int _count;   // 声明
};
int D::_count = 0;       // 定义并初始化

class Date {
public:
    Date(int year) : _year(year) {}   // _month、_day 使用缺省值
private:
    int _year;
    int _month = 1;    // 缺省值
    int _day = 1;      // 缺省值
};

class A {
public:
    A(int x) : _x(x) {}
private:
    int _x;
};

void func(A a) { /* ... */ }

int main() {
    A a1 = 10;      // 隐式转换：先用 10 构造一个临时 A 对象，再拷贝构造 a1（通常会被优化）
    func(20);       // 隐式转换：20 → A 临时对象，然后传递给 func
    return 0;
}

class String {
public:
    String(int size) { /* 分配 size 大小的字符串 */ }
    // ...
};

String s = 10;   // 本意是创建包含字符串 "10" 的对象，实际却创建了长度为 10 的字符串

class String {
public:
    explicit String(int size) { /* ... */ }
};

String s = 10;   // 错误！不能隐式转换
String s(10);    // 正确，显式调用
func(20);        // 错误！20 无法隐式转换为 String

class B {
public:
    B() {}
    // 接受 A 对象的构造函数
    B(const class A& a) { /* 从 A 构造 B */ }
};

class A {
    // ...
};

void func(B b) {}

int main() {
    A a;
    B b = a;       // 隐式转换：a → B 临时对象，再拷贝构造 b
    func(a);       // 同样隐式转换
    return 0;
}

class B {
public:
    explicit B(const A& a) { /* ... */ }
};

B b = a;   // 错误！
B b(a);    // 正确，显式调用

class Counter {
public:
    static int count;   // 声明静态成员变量
};

// 类外定义并初始化
int Counter::count = 0;

#include <iostream>
using namespace std;

class Counter {
public:
    static int count;   // 静态成员变量
    Counter() { ++count; }
    ~Counter() { --count; }
};

// 类外定义
int Counter::count = 0;

int main() {
    cout << Counter::count << endl;   // 通过类名访问，输出 0
    Counter c1, c2;
    cout << Counter::count << endl;   // 输出 2
    cout << c1.count << endl;         // 通过对象访问，输出 2（推荐用类名访问）
    return 0;
}

#include <iostream>
using namespace std;

class Counter {
private:
    static int count;   // 私有静态成员
public:
    Counter() { ++count; }
    ~Counter() { --count; }
    static int getCount() { return count; }   // 静态成员函数，返回私有静态成员
};

int Counter::count = 0;

int main() {
    cout << Counter::getCount() << endl;   // 输出 0
    Counter c1, c2;
    cout << Counter::getCount() << endl;   // 输出 2
    // cout << Counter::count << endl;     // 错误！count 是私有成员
    return 0;
}

class Test {
    int x;
    static int y;
public:
    static void func() {
        // x = 10;      // 错误！不能访问非静态成员
        y = 20;         // 正确，可以访问静态成员
    }
};

class A {
private:
    int data;
public:
    friend void showData(const A& a);   // 声明友元函数
};

void showData(const A& a) {
    cout << a.data << endl;   // 可以访问私有成员
}

#include <iostream>
#include <cmath>
using namespace std;

class Point {
private:
    double x, y;
public:
    Point(double x = 0, double y = 0) : x(x), y(y) {}
    // 声明友元函数
    friend double distance(const Point& p1, const Point& p2);
};

// 友元函数定义
double distance(const Point& p1, const Point& p2) {
    double dx = p1.x - p2.x;
    double dy = p1.y - p2.y;
    return sqrt(dx*dx + dy*dy);
}

int main() {
    Point a(0, 0), b(3, 4);
    cout << "距离: " << distance(a, b) << endl;   // 输出 5
    return 0;
}

class A {
    friend class B;   // 声明 B 是 A 的友元类
private:
    int secret;
};

class B {
public:
    void showA(const A& a) {
        cout << a.secret << endl;   // 可以访问 A 的私有成员
    }
};

class A {
private:
    int data;
public:
    friend void B::func(const A&);   // 仅将 B 的 func 设为友元
};

class B {
public:
    void func(const A& a) { cout << a.data << endl; }
    void other(const A& a) { /* 不能访问 a.data */ }
};

class Outer {
public:
    class Inner {   // 内部类
    public:
        void show() { cout << "Inner" << endl; }
    };
};

Date(2024, 7, 5);   // 匿名对象，没有名字
Date d(2024, 7, 5);   // 有名对象，生命周期到作用域结束

void func(const A& a) {
    a.show();
}

int main() {
    func(A(30));   // 传递匿名对象
    return 0;
}

A makeA() {
    A a;
    return a;
}
int main() {
    A obj = makeA();
    return 0;
}

#include<iostream>
using namespace std;
class A
{
public:
    A(int a = 0)
        :_a1(a)
    {
        cout << "A(int a)" << endl;
    }
    A(const A& aa)
        :_a1(aa._a1)
    {
        cout << "A(const A& aa)" << endl;
    }
    A& operator=(const A& aa)
    {
        cout << "A& operator=(const A& aa)" << endl;
        if (this != &aa)
        {
            _a1 = aa._a1;
        }
        return *this;
    }
    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a1 = 1;
};

A makeA() {
    A a;
    return a;
}
int main() {
    A obj = makeA();
    return 0;
}

A(int a)
~A()

A(int a)
A(const A& aa)
~A()
A(const A& aa)
~A()
~A()

class Date
{
	private:
		int _year;
		int _month;
		int _day;
};

		Date(int year = 1970, int month = 1, int day = 1)
			:_year(year)
			, _month(month)
			, _day(day)
		{
		}

int GetMonthDay(int year,int month) 
{
	assert(month > 0 && month <= 12);                //断言判断月份是否在1~12之间
	static int monthDay[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };  //将1~12月的天数填入数组，因为查找月份天数的操作非常频繁，所以数组设置为静态，避免每次查找时构建，提高效率
	if (month==2&&((year%4==0&&year%100!=0)||year%400==0))  //优先判断是不是2月，如果不是就不用再走后面的判断逻辑，
	{
		return 29;
	}
	return monthDay[month];
}

		bool checkDate() const  //不涉及修改对象，加上const防止代码写错意外修改
		{
			if (_month < 1 || _month>12)    //判断月份是否在1~12之间
			{
				return false;
			}
			if (_day < 1 || _day>GetMonthDay(_year, _month))   //判断传入日期是否在相应月份的正常范围之间
			{
				return false;
			}
			return true;
		}

		Date(int year = 1970, int month = 1, int day = 1)
			:_year(year)
			, _month(month)
			, _day(day)
		{
			if (!checkDate())
			{
				cout << "非法日期" << endl;
				print();
				cout << "------" << endl;

			}
		}

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

		Date& operator= (const Date& d2)
		{
			_year = d2._year;
			_month = d2._month;
			_day = d2._day;
			return *this;
		}

		void print() const
		{
			cout << _year << "-" << _month << "-" << _day << endl;
		}

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);   //加入友元声明
};


ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "-" << d._month << "-" << d._day;
	return out;
}

		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)
				{
					_month = 1;
					_year++;
				}
			}
			return *this;
		}

		Date operator+ (int day)const
		{
			Date temp = *this;
			temp += day;
			return temp;
		}

		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;
		}

		Date operator- (int day)const
		{
			Date temp = *this;
			return temp -= day;
		}

		Date& operator++ ()
		{
			*this += 1;
			return *this;
		}

		Date operator++ (int)  //后置++在参数列表加上int
		{
			Date temp = *this;
			*this += 1;
			return temp;
		}

		Date& operator-- ()
		{
			*this -= 1;
			return *this;
		}

		Date operator-- (int)  //后置--在参数列表加上int
		{
			Date temp = *this;
			*this -= 1;
			return temp;
		}

		bool operator== (const Date& d2)const
		{
			return _year == d2._year && _month == d2._month && _day == d2._day;
		}

    bool operator!=(const Date& d) const
    {
    	return !(*this == d);
    }

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

		bool operator<= (const Date& d2)const
		{
			return *this < d2 || *this == d2;
		}

		bool operator> (const Date& d2)const
		{
			return!(*this <= d2);
		}

		bool operator>= (const Date& d2)const
		{
			return !(*this < d2);
		}

		int operator- (const Date& d2)const
		{
			int flag = 1;
			Date max = *this;
			Date min = d2;
			if (max<min)
			{
				max = d2;
				min = *this;
				flag = -1;
			}
			int days = 0;
			while (min<max)
			{
				min++;
				++days;
			}
			return days * flag;
		}

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);  //友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
	public:
    int GetMonthDay(int year,int month) 
    {
    	assert(month > 0 && month <= 12);                //断言判断月份是否在1~12之间
    	static int monthDay[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };  //将1~12月的天数填入数组，因为查找月份天数的操作非常频繁，所以数组设置为静态，避免每次查找时构建，提高效率
    	if (month==2&&((year%4==0&&year%100!=0)||year%400==0))  //优先判断是不是2月，如果不是就不用再走后面的判断逻辑，
    	{
    		return 29;
    	}
    	return monthDay[month];
    }


		bool checkDate() const
		{
			if (_month < 1 || _month>12)    //判断月份是否在1~12之间
			{
				return false;
			}
			if (_day < 1 || _day>GetMonthDay(_year, _month))   //判断传入日期是否在相应月份的正常范围之间
			{
				return false;
			}
			return true;
		}

		Date(int year = 1970, int month = 1, int day = 1)
			:_year(year)
			, _month(month)
			, _day(day)
		{
			if (!checkDate())
			{
				cout << "非法日期" << endl;
				print();
				cout << "------" << endl;

			}
		}

    //拷贝构造，可不写，使用编译器默认生成的效果相同
		Date(const Date& d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
    //赋值重载，可不写，使用编译器默认生成的效果相同
		Date& operator= (const Date& d2)
		{
			_year = d2._year;
			_month = d2._month;
			_day = d2._day;
			return *this;
		}

		void print() const
		{
			cout << _year << "-" << _month << "-" << _day << endl;
		}

		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)
				{
					_month = 1;
					_year++;
				}
			}
			return *this;
		}

		Date operator+ (int day)const
		{
			Date temp = *this;
			temp += day;
			return temp;
		}

		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;
		}

		Date operator- (int day)const
		{
			Date temp = *this;
			return temp -= day;
		}

		Date& operator++ ()
		{
			*this += 1;
			return *this;
		}

		Date operator++ (int)  //后置++在参数列表加上int
		{
			Date temp = *this;
			*this += 1;
			return temp;
		}

		Date& operator-- ()
		{
			*this -= 1;
			return *this;
		}

		Date operator-- (int)  //后置--在参数列表加上int
		{
			Date temp = *this;
			*this -= 1;
			return temp;
		}

		bool operator== (const Date& d2)const
		{
			return _year == d2._year && _month == d2._month && _day == d2._day;
		}

    bool operator!=(const Date& d) const
    {
    	return !(*this == d);
    }

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

		bool operator<= (const Date& d2)const
		{
			return *this < d2 || *this == d2;
		}

		bool operator> (const Date& d2)const
		{
			return!(*this <= d2);
		}

		bool operator>= (const Date& d2)const
		{
			return !(*this < d2);
		}

		int operator- (const Date& d2)const
		{
			int flag = 1;
			Date max = *this;
			Date min = d2;
			if (max<min)
			{
				max = d2;
				min = *this;
				flag = -1;
			}
			int days = 0;
			while (min<max)
			{
				min++;
				++days;
			}
			return days * flag;
		}

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

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "-" << d._month << "-" << d._day;
	return out;
}