C++ 默认成员函数：构造、拷贝、析构与赋值

默认构造函数涵盖三种情况：无参的、全缺省的、编译器自动生成的（当你一个都没写时）。只要不传实参就能调用的构造函数，都叫默认构造函数。

编译器生成的默认构造函数

如果一个类里你完全没写构造函数，编译器会悄悄生成一个默认无参的。但一旦你自己写了任何一个构造函数（即使带参数），编译器就撒手不管了——这就是'免费午餐'没了。

class B {
public:
    B(int x) { cout << x << endl; } 
};
B b; // 错误：此时类中没有可用的默认构造函数

最关键的地方：编译器生成的构造函数对待不同类型成员的方式截然不同。

• 对于自定义类型成员（比如 string、vector 或其他 class 对象），它会负责调用这些成员的默认构造函数。
• 对于内置类型成员（int、char、指针等），它什么都不做——内存里原来有什么垃圾值，现在还是什么。

下面这个例子用两个 Stack 实现 MyQueue，由于 Stack 有自己的默认构造函数，MyQueue 什么都不写，编译器生成的构造函数就会自动调用 Stack 的默认构造，一切正常。

typedef int STDataType;
class Stack {
public:
    Stack(int n = 4) { ... }
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

class MyQueue {
public:
    // 编译器自动生成构造函数，并调用 Stack 的默认构造
private:
    Stack pushst;
    Stack popst;
};

但如果 Stack 删掉自己的构造函数，依赖编译器生成，那就会出大问题：内置类型成员 _a 变成野指针，_capacity、_top 都是随机值，运行时就等着崩溃吧。

对于简单的日期类，若依赖编译器生成的构造函数，它的 _year、_month、_day 都是未定义的垃圾值。

class Date {
public:
    void Print() { cout << _year << "/" << _month << "/" << _day << endl; }
private:
    int _year, _month, _day;
};
int main() {
    Date d1; // 垃圾值
    d1.Print();
}

结论：永远不要信任编译器默认生成的构造函数能妥善处理内置类型（尤其是指针）。

小结

• 名称与类相同，无返回值，自动调用，可重载。
• 不写时编译器生成一个无参默认构造，你一旦写了任何一个，编译器就不再生成。
• 无参、全缺省、编译器生成的，都叫默认构造函数，但三者只能存在一个。

拷贝构造函数

克隆一个对象用拷贝构造函数——用一个已存在的对象去初始化一个新对象。

语法

class ClassName {
public:
    ClassName(const ClassName& other) {
        // 拷贝
    }
};

参数必须是引用（const ClassName&）。如果传值，形参的拷贝又会调用拷贝构造，无限递归直到栈溢出。const 则是为了防止误改原件。

为何必须用引用

假设你写出这样错误的拷贝构造：Date(Date d)，当执行 Date d2(d1) 时，为了将实参 d1 传递给形参 d，编译器又会调用拷贝构造，于是死循环。加上 & 变成 Date(const Date& d) 后，d 只是 d1 的别名，不会引发新的拷贝，循环打破。

触发场景

凡自定义类型对象进行拷贝时，都会调用拷贝构造。典型场景：

• 函数传值传参：void func(Student s)，实参传递给形参时。
• 函数传值返回：return temp; 时，先在调用方栈帧创建临时对象，把 temp 拷贝过去，然后再用临时对象初始化接收变量。

编译器生成的拷贝构造

若未显式定义，编译器会生成默认拷贝构造，同样遵循'免费午餐'原则：你一旦自己写了，它就不管了。

它的行为：

• 对内置类型成员，逐字节拷贝（浅拷贝）。
• 对自定义类型成员，调用该成员的拷贝构造函数。

比如 Person 类包含 int age、int* scorePtr 和 Wallet myWallet。编译器生成的拷贝构造会：

• 拷贝 age 的值；
• 拷贝指针 scorePtr 的值（也就是地址，指针本身被拷贝，但指向的内容没动——浅拷贝）；
• 调用 Wallet 的拷贝构造。

class Wallet {
public:
    Wallet(const Wallet& w) { cout << "Wallet 的拷贝构造被调用了！" << endl; }
};
class Person {
public:
    int age;
    int* scorePtr;
    Wallet myWallet;
    // 未写拷贝构造
};
int main() {
    Person p1;
    p1.age = 18; int score=100; p1.scorePtr = &score;
    Person p2 = p1;  // 触发默认拷贝构造
    cout << p1.scorePtr << " " << p2.scorePtr << endl; // 地址相同
}

浅拷贝的坑

对于管理资源的类，比如 Stack，如果直接拷贝指针 _a：

Stack(const Stack& st) {
    _a = st._a;        // 只拷贝地址
    _capacity = st._capacity;
    _top = st._top;
}

两个对象将指向同一块堆内存，一旦一个对象析构释放了内存，另一个就变成了悬空指针。更常见的是重复释放导致崩溃。

解决方法是深拷贝：为新对象独立分配内存，把数据复制过去。

Stack(const Stack& st) {
    _a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
    if (_a) {
        memcpy(_a, st._a, sizeof(STDataType) * st._top);
    }
    _capacity = st._capacity;
    _top = st._top;
}

拷贝构造小结

• 第一个参数必须是类类型对象的引用，否则无限递归。
• 自定义类型拷贝必须调用拷贝构造，所以传值传参和传值返回都会触发。
• 编译器生成的默认拷贝构造对内置类型浅拷贝，对自定义类型调用它的拷贝构造。
• 像 Date 这样只含内置类型且不涉及资源管理的类，默认拷贝构造就够用了；但对于 Stack 这样持有资源（堆内存）的类，必须自己实现深拷贝。
• 传值返回会产生临时对象，可用引用返回减少拷贝，但前提是返回的对象在函数结束后仍然有效（不要返回局部对象的引用）。

析构函数

析构函数是构造函数的'反义词'——对象临终前的清理。

语法

名称是 ~类名()，没有参数，没有返回值，也不能被重载（因为没参数）。

class MyClass {
public:
    ~MyClass() { /* 清理代码 */ }
};

当对象在构造函数里申请了资源（比如 malloc 的内存），就必须在析构函数里手动释放。

class Stack {
    ~Stack() { free(_a); _a = nullptr; }
};

调用时机

• 离开作用域：栈上的局部对象，函数结束时自动析构。
• delete 操作：堆上的对象，通过 delete ptr 触发。
• 对于全局对象或静态局部对象，它们在 main 结束后才析构。

编译器生成的析构函数

同样遵循'不写就送，写了就不管'的原则。它的行为：

• 对自定义类型成员，调用它们的析构函数。
• 对内置类型成员，什么都不做（指针成员不会释放其所指内存）。

因此，在 MyQueue 里，即使不写析构函数，编译器生成的也会自动调用 Stack 的析构，从而释放 pushst 和 popst 内部的资源。但如果 Stack 本身也没写析构函数，那里面的 _a 就不会被释放，造成内存泄漏。

析构顺序

在同一作用域，后构造的对象先析构（栈的顺序）。数组对象的析构顺序与构造相反：从大下标往小走。全局和静态对象在 main 结束后析构。

小结

• 析构函数无参无返回值，一个类只有一个。
• 必要的时候必须自己写，释放资源。
• 编译器生成的会处理自定义类型成员，但不处理内置类型。

运算符重载

运算符重载让自定义类型也能像内置类型一样写 a + b 或 cout << obj。它本质上就是函数调用的一种语法糖。

基本语法

返回类型 operator操作符 (参数列表)

例如，为 Person 重载 +，返回年龄之和：

int operator+(Person a, Person b) {
    return a._age + b._age;
}

不能重载的运算符：.、::、sizeof、?:、.*。

全局还是成员？

• 必须用成员函数：=, [], (), -> —— 因为语法要求。
• 必须用全局函数：<< 和 >> —— 因为左操作数是标准库的流对象，我们不能去修改它的类定义。
• 二元算术和比较运算符建议用全局函数，以保持对称性（允许左侧操作数隐式转换）。
• 复合赋值（+=）建议用成员函数，因为它通常要修改对象自身并返回引用。

前置和后置 ++

前置 ++：Type& operator++()，先加后用，返回引用自身。 后置 ++：Type operator++(int)，先用后加，返回旧值的副本，那个 int 只是占位符，用来区分重载。

MyInt& operator++() { value++; return *this; }
MyInt operator++(int) { MyInt temp=*this; value++; return temp; }

-- 同理。

流插入 << 和流提取 >>

必须实现为全局函数，并通常声明为类的友元。

• ostream& operator<<(ostream& out, const T& obj)：输出对象，返回 out 以支持链式调用。
• istream& operator>>(istream& in, T& obj)：读入数据，返回 in。

示例：

class Complex {
    friend ostream& operator<<(ostream& out, const Complex& c);
    friend istream& operator>>(istream& in, Complex& c);
    int real, imag;
};
ostream& operator<<(ostream& out, const Complex& c) {
    out << c.real << "+" << c.imag << "i";
    return out;
}
istream& operator>>(istream& in, Complex& c) {
    in >> c.real >> c.imag;
    return in;
}

赋值运算符重载

赋值运算符用于两个已经存在的对象之间的拷贝，与拷贝构造不同（拷贝构造是用一个已存在的对象去初始化一个新对象）。

语法：ClassName& operator=(const ClassName& other)

必须处理自赋值（if (this == &other)），返回 *this 的引用以支持链式 a = b = c。

编译器生成的赋值重载行为与拷贝构造类似：内置类型浅拷贝，自定义类型调用其 operator=。

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

如果一个类需要管理资源（如动态内存），默认的赋值重载会导致双重释放等问题，必须自定义。

三法则

最后，一个经典的 C++ 法则：如果你需要自定义析构函数、拷贝构造函数或赋值运算符中的任何一个，那么通常三个都需要定义。因为它们都涉及资源的正确管理。