C++ 类的默认成员函数详解及日期类实现

// 以下都是调用拷贝构造
Stack st4(st3);
Stack st5 = st3;
// 由 Date ret = Func2(); 得来

#include <iostream>
using namespace std;
typedef int STDataType;

class Stack {
public:
    Stack(int n = 4) {
        _a = (STDataType*)malloc(sizeof(STDataType)* n);
        if (nullptr == _a) {
            perror("malloc 申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }
    Stack(const Stack& st) {
        // 需要对_a 指向资源创建同样大的资源再拷贝值
        _a = (STDataType*)malloc(sizeof(STDataType)* st._capacity);
        if (nullptr == _a) {
            perror("malloc 申请空间失败!!!");
            return;
        }
        memcpy(_a, st._a, sizeof(STDataType)* st._top);
        _top = st._top;
        _capacity = st._capacity;
    }
    void Push(STDataType x) {
        if (_top == _capacity) {
            int newcapacity = _capacity * 2;
            STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
            if (tmp == NULL) {
                perror("realloc fail");
                return;
            }
            _a = tmp;
            _capacity = newcapacity;
        }
        _a[_top++] = x;
    }
    ~Stack() {
        cout << "~Stack()" << endl;
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

// 两个 Stack 实现队列
class MyQueue {
public:
private:
    Stack pushst;
    Stack popst;
};

int main() {
    Stack st1;
    st1.Push(1);
    st1.Push(2);
    // Stack 不显式实现拷贝构造，用自动生成的拷贝构造完成浅拷贝
    // 会导致 st1 和 st2 里面的_a 指针指向同一块资源，析构时会析构两次，程序崩溃
    Stack st2 = st1;
    MyQueue mq1;
    // MyQueue 自动生成的拷贝构造，会自动调用 Stack 拷贝构造完成 pushst/popst 的拷贝，只要 Stack 拷贝构造自己实现了深拷贝，他就没问题
    MyQueue mq2 = mq1;
    return 0;
}

5.赋值运算符重载

5.1 运算符重载

• 当运算符被用于类类型的对象时，C++语言允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。 • 运算符重载是具有特殊名字的函数，他的名字是由 operator 和后面要定义的运算符共同构成。和其他函数一样，它也具有其返回类型和参数列表以及函数体。 • 重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。 • 如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的 this 指针，因此运算符重载作为成员函数时，参数比运算对象少一个。 • 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致。 • 不能通过连接语法中没有的符号来创建新的操作符：比如 operator@。

注意以上 5 个运算符不能重载。(选择题里面常考，大家要记一下)

. * 符号补充演示：

void func() { cout << "func()" << endl; }
class A {
public:
    void func2() { cout << "A::func()" << endl; }
};

int main() {
    void (*pf1)() = func; // 调用 (*pf)();
    void (A::*pf2)() = &A::func2; // 调用 A aa; (aa.*pf2)();
    return 0;
}

• 重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，如：int operator+(int x, int y)。 • 一个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如 Date 类重载 operator- 就有意义，但是重载 operator* 就没有意义。 • 重载 ++ 运算符时，有前置 ++ 和后置 ++，运算符重载函数名都是 operator++，无法很好的区分。C++规定，后置 ++ 重载时，增加一个 int 形参，跟前置 ++ 构成函数重载，方便区分。 • 重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this 指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了对象<<cout，不符合使用习惯和可读性。重载为全局函数把 ostream/istream 放到第一个形参位置就可以了，第二个形参位置当类类型对象。

#include <iostream>
using namespace std;
// 编译报错：'operator +'必须至少有一个类类型的形参
int operator+(int x, int y) {
    return x - y;
}

#include <iostream>
using namespace std;

class Date {
public:
    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;
};

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

int main() {
    Date d1(2024, 7, 5);
    Date d2(2024, 7, 6);
    // 运算符重载函数可以显示调用 operator==(d1, d2);
    // 编译器会转换成 operator==(d1, d2);
    d1 == d2;
    return 0;
}

重载函数作用域在全局时无法访问私有成员变量

有几种方法可以解决：

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; }
    void Print() { cout << _year << "-" << _month << "-" << _day << endl; }
    bool operator==(const Date& d) {
        return _year == d._year && _month == d._month && _day == d._day;
    }
    Date& operator++() {
        cout << "前置++" << endl;
        // ...
        return *this;
    }
    Date operator++(int) {
        Date tmp;
        cout << "后置++" << endl;
        // ...
        return tmp;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main() {
    Date d1(2026, 3, 6);
    Date d2(2024, 3, 6);
    // 运算符重载函数可以显示调用
    d1.operator==(d2);
    // 编译器会转换成 d1.operator==(d2);
    d1 == d2;
    // 编译器会转换成 d1.operator++();++d1;
    // 编译器会转换成 d1.operator++(0); d1++;
    return 0;
}

5.2 赋值运算符重载

赋值运算符重载是一个默认成员函数，用于完成两个已经存在的对象直接的拷贝赋值，这里要注意跟拷贝构造区分，拷贝构造用于一个对象拷贝初始化给另一个要创建的对象。

赋值运算符重载的特点：

1. 赋值运算符重载是一个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成const 当前类类型引用，否则会传值传参会有拷贝
2. 有返回值，且建议写成当前类类型引用，引用返回可以提高效率，有返回值目的是为了支持连续赋值场景。
3. 没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝 (一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的赋值重载函数。
4. 像 Date 这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们显示实现赋值运算符重载。 像 Stack 这样的类，虽然也都是内置类型，但是_a 指向了资源，编译器自动生成的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝 (对指向的资源也进行拷贝)。 像 MyQueue 这样的类型内部主要是自定义类型 Stack 成员，编译器自动生成的赋值运算符重载会调用 Stack 的赋值运算符重载，也不需要我们显示实现 MyQueue 的赋值运算符重载。 这里还有一个小技巧，如果一个类显示实现了析构并释放资源，那么他就需要显示写赋值运算符重载，否则就不需要。

class Date {
public:
    Date(int year = 1, int month = 1, int day = 1) { _year = year; _month = month; _day = day; }
    Date(const Date& d) {
        cout << " Date(const Date& d)" << endl;
        _year = d._year; _month = d._month; _day = d._day;
    }
    // 传引用返回减少拷贝
    // d3 = d5;
    Date& operator=(const Date& d) {
        // 检查自己给自己赋值的情况
        if (this != &d) {
            _year = d._year; _month = d._month; _day = d._day;
        }
        // d3 = d5 表达式的返回对象应该为 d1，也就是*this
        return *this;
    }
    void Print() { cout << _year << "-" << _month << "-" << _day << endl; }
private:
    int _year;
    int _month;
    int _day;
};

int main() {
    Date d1(2024, 7, 5);
    Date d2(d1);
    Date d3(2024, 7, 6);
    d1 = d3 = d5;
    // 需要注意这里是拷贝构造，不是赋值重载
    Date d4 = d1;
    return 0;
}

6.取地址运算符重载

6.1 const 成员函数

1. 将 const 修饰的成员函数称之为 const 成员函数，const 修饰成员函数放到成员函数参数列表的后面。const 不能修饰全局函数（可以理解为没有 this 指针 2.1 const 修饰该成员函数隐含的 this 指针，表明在该成员函数中不能对类的任何成员进行修改。 2.2 const 修饰 Date 类的 Print 成员函数，Print 隐含的 this 指针由 Date* const this 变为 const Date* const this 总结：不修改成员变量的成员函数都应该加上 const，这样普通对象和 const 对象都可以调用这个 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; }
    // void Print(const Date* const this) 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 Date d2(2024, 8, 5);
    d2.Print();
    return 0;
}

6.2 取地址运算符重载

取地址运算符重载分为普通取地址运算符重载和 const 取地址运算符重载，一般这两个函数编译器自动生成的就可以够我们用了，不需要去显示实现。

除非一些很特殊的场景，比如我们不想让别人取到当前类对象的地址，就可以自己实现一份，胡乱返回一个地址。

class Date {
public:
    // d2 调用这个
    Date* operator&() {
        return this;
        // return nullptr;
    }
    // d1 调用这个
    const Date* operator&() const {
        return this;
        // return nullptr;
    }
private:
    int _year; // 年
    int _month; // 月
    int _day; // 日
};

int main() {
    const Date d1(2025, 9, 1);
    const Date* p1 = &d1;
    Date d2(2025, 9, 8);
    Date* p2 = &d2;
    cout << p1 << " " << p2 << endl;
    return 0;
}

7. 日期类实现

// 0+2 次拷贝
Date& 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;
}

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

// 反过来 1+2 次拷贝
Date& Date::operator+=(int day) {
    *this = *this + day;
    return *this;
}

Date Date::operator+(int day) {
    if (day < 0) {
        return *this -= -day;
    }
    Date tmp(*this);
    tmp._day += day;
    while (tmp._day > GetMonthDay(tmp._year, tmp._month)) {
        tmp._day -= GetMonthDay(tmp._year, tmp._month);
        ++tmp.month;
        if (tmp._month == 13) {
            ++tmp._year;
            tmp._month = 1;
        }
    }
    return tmp;
}

所以选上面那种方式

d1-d2（日期相减）

1. 最简单直接办法：二者差的年数*365+跨越闰年数+（二者距自己当前年 1 月 1 号差的天数相减）
2. 小的日期不断++，直到和大的日期相等，++了多少次，他们就相差多少天

总的代码演示：

// Data.h
#pragma once
#include <iostream>
using namespace std;
#include <assert.h>

class Date {
    // 友元函数声明（也可以写在 public，也可以写在 private，它实质不属于这个类）
    // 友元函数可以访问私有变量
    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);
    void Print() const;
    // 直接定义类里面，他默认是 inline
    // 频繁调用
    int GetMonthDay(int year, int month) const {
        assert(month > 0 && month < 13);
        // 用 static 修饰更好
        static int monthDayArray[13] = {-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        // 365 天 5h +
        if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))) {
            return 29;
        } else {
            return monthDayArray[month];
        }
    }
    bool CheckDate();
    bool operator<(const Date& d) const;
    bool operator<=(const Date& d) const;
    bool operator>(const Date& d) const;
    bool operator>=(const Date& d) const;
    bool operator==(const Date& d) const;
    bool operator!=(const Date& d) const;
    // d1 += 天数
    Date& operator+=(int day);
    Date operator+(int day) const;
    // 不修改本身的值，可以加 const
    // d1 -= 天数
    Date& operator-=(int day);
    Date operator-(int day) const;
    // d1 - d2
    int operator-(const Date& d) const;
    // ++d1 -> d1.operator++()
    Date& operator++();
    // d1++ -> d1.operator++(0)
    // 为了区分，构成重载，给后置++，强行增加了一个 int 形参
    // 这里不需要写形参名，因为接收值是多少不重要，也不需要用
    // 这个参数仅仅是为了跟前置++构成重载区分
    Date operator++(int);
    Date& operator--();
    Date operator--(int);
    // 不能直接 cout<<d
    // 流插入
    // 调用代码：d1.operator<<(cout);或者 d1<<cout;
    // 不建议，因为 Date* this 占据了一个参数位置，使用 d<<cout 不符合
    // void operator<<(ostream& out)
    // {
    //     out << _year << "/" << _month << "/" << _day << '\n';
    // }
private:
    int _year;
    int _month;
    int _day;
};

// 重载，放成全局函数，这样就不隐含 this 指针
ostream& operator<<(ostream& out, const Date& d);
// 注意不加 const
istream& operator>>(istream& in, Date& d);

// Date.cpp
#include "Date.h"

bool Date::CheckDate() {
    if (_month < 1 || _month > 12 || _day < 1 || _day > GetMonthDay(_year, _month)) {
        return false;
    } else {
        return true;
    }
}

Date::Date(int year, int month, int day) {
    _year = year; _month = month; _day = day;
    // 检查必须在赋值之后，因为检查函数只有隐含的 this 指针，会访问_day 等
    if (!CheckDate()) {
        cout << "日期非法" << endl;
    }
}

void Date::Print() const {
    cout << _year << "-" << _month << "-" << _day << endl;
}

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

// d1 < d2
// 把所有为真的情况找出来，剩下的就是假的
bool Date::operator<(const Date& d) const {
    if (_year < d._year) {
        return true;
    } else if (_year == d._year) {
        if (_month < d._month) {
            return true;
        } else if (_month == d._month) {
            return _day < d._day;
        }
    }
    return false;
}

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

// 可以把<改为>，但是下面这样更好，复用度更高
bool Date::operator>(const Date& d) const {
    return !(*this <= d);
}

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

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

// d1 += 50
// d1 += -50
Date& 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;
}

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

// d1 -= 100
Date& Date::operator-=(int day) {
    if (day < 0) {
        return *this += -day;
    }
    _day -= day;
    // day=0 也不合法
    while (_day <= 0) {
        --_month;
        if (_month == 0) {
            _month = 12;
            _year--;
        }
        // 借上一个月的天数
        _day += GetMonthDay(_year, _month);
    }
    return *this;
}

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

// 为了区分，构成重载，给后置++，强行增加了一个 int 形参
// ++d1，返回的是拷贝后，尽量用前置++
Date& Date::operator++() {
    *this += 1;
    return *this;
}

// 这里不需要写形参名，因为接收值是多少不重要，也不需要用
// 这个参数仅仅是为了跟前置++构成重载区分
// d1++，返回的是拷贝前，因为是局部对象不能用引用返回
Date Date::operator++(int) {
    Date tmp(*this);
    *this += 1;
    return tmp;
}

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

Date Date::operator--(int) {
    Date tmp(*this);
    *this -= 1;
    return tmp;
}

// d1 - d2
int Date::operator-(const Date& d) const {
    // 假设前一个大于后一个
    Date max = *this;
    Date min = d;
    int flag = 1;
    // 如果前一个小，最后结果为负
    if (*this < d) {
        max = d;
        min = *this;
        flag = -1;
    }
    int day = 0;
    while (min != max) {
        ++min;
        ++day;
    }
    return day * flag;
}

// 第一个参数也可以写成_cout，不建议写成 cout，与库里面的 cout 最好区分开来
ostream& operator<<(ostream& out, const Date& d) {
    out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
    return out; // 返回 out 可以连续输出：cout<<d1<<d2;
}

istream& operator>>(istream& in, Date& d) {
    while (1) {
        cout << "请依次输入年月日：>";
        in >> d._year >> d._month >> d._day;
        if (d.CheckDate()) {
            break;
        } else {
            cout << "日期非法，请重新输入：" << endl;
        }
    }
    return in;
}

// Test.cpp
#include "Date.h"

void TestDate1() {
    // Date d1(2025, 9, 8);
    // d1+=100;
    // d1.Print();
    // Date d2=d1+100;
    // d2.Print();
    // d1-=50;
    // d1.print();
    // Date d3=d1-50;
    // d3.print();
    // 这里需要测试一下大的数据 + 和-
    Date d1(2025, 9, 8);
    Date d2 = d1 + 2000;
    d1.Print(); d2.Print();
    Date d3(2024, 4, 14);
    Date d4 = d3 - 5000;
    d3.Print(); d4.Print();
    Date d5(2024, 4, 14);
    d5 += -5000;
    d5.Print();
}

void TestDate2() {
    Date d1(2025, 9, 8);
    Date d2 = ++d1;
    d1.Print(); d2.Print();
    Date d3 = d1++;
    d1.Print(); d3.Print();
    Date d5 = --d1; // d1.operator--(); d1.Print(); d5.Print();
    Date d4 = d1--; // d1.operator--(10); d1.Print(); d4.Print();
}

void TestDate3() {
    Date d1(2026, 3, 4);
    Date d2(2026, 7, 15);
    int n = d1 - d2;
    cout << n << endl;
}

void TestDate4() {
    Date d1(2026, 3, 4);
    Date d2 = d1 + 3000; // operator<<(cout, d1)
    cout << d1; cout << d2;
    cin >> d1 >> d2;
    cout << d1 << d2;
}

void TestDate5() {
    const Date d1(2024, 4, 14);
    d1.Print();
    // d1 += 100; d1 +100;
    Date d2(2024, 4, 25);
    d2.Print(); d2 += 100;
    d1 < d2; d2 < d1;
}

int main() {
    // TestDate1();
    // TestDate2();
    // TestDate3();
    TestDate4();
    // TestDate5();
    return 0;
}