C++ 类和对象：拷贝构造与赋值运算符重载详解

解释特点第 5 条：

拷贝构造函数就和构造、析构有点不同。它会对内置类型的成员变量进行处理。类似 Date 类这样全是内置类型的变量，编译器默认生成的就够用；对于复杂结构的类 Stack，就要自定义深拷贝；对于 MyQueue 这样的类，不显式定义拷贝构造，编译器就会调用成员变量对应类的拷贝构造。

解释特点第 6 条： 通过实现栈来观察

• 有指向的资源，浅拷贝的后果：
  • 一个对象改变会影响另一个对象；
  • 析构时，同一块空间会释放两次空间；

#include <cstdlib>
#include <cstring>

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 st2(st1);
    Stack(const Stack& s) {
        _a = s._a;
        _capacity = s._capacity;
        _top = s._top;
    }
    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;
};

int main() {
    Stack s1;
    s1.Push(1);
    s1.Push(2);
    s1.Push(3);
    s1.Push(4);
    Stack s2(s1);
    return 0;
}

（会产生错误，通常是内存相关的问题。）

这样浅拷贝会使两个对象的指针变量都指向同一块空间，最后的两次析构就导致第二次析构对已经释放完的空间再次释放，发生错误。

• 有指向的资源，自定义深拷贝：（先简单了解）
  • 不仅仅对成员拷贝，还对指向的资源空间数据进行处理。（开空间）

Stack(const Stack& s) {
    _a = (STDataType*)malloc(sizeof(STDataType) * s._capacity);
    if (_a == NULL) {
        perror("realloc fail");
        return;
    }
    memcpy(_a, s._a, s._top * sizeof(STDataType));
    _capacity = s._capacity;
    _top = s._top;
}

调试程序发现：不指向同一空间。

解释特点第 7 条：

在上面栈的基础上

int& func1() {
    int ret = 1;
    return ret; // 返回的是 ret 的别名
}

Stack& func2() {
    Stack st;
    return st;
}

int main() {
    int ret1 = func1(); // ret 在函数结束时就销毁了，所以这里存在错误
    cout << ret1 << '\n'; // 可能是 1 或者随机值
    Stack ret2 = func2(); // 调拷贝构造，但是 st 不存在
    return 0;
}

根据特点 7，函数传值返回是会调用拷贝构造的，但是传引用返回不会。对于 st 这里，函数就是进行析构（成员函数），那么在通过返回的别名来访问 st 肯定是错的。

【所以，在传引用返回是一定要注意返回对象是否还存在！】

1.2 关键：拷贝构造的调用

• 用一个对象初始化另一个同类的对象（在创建的同时初始化）

基本形式：

Example a;
Example b(a); // 调用拷贝构造函数
Example c = a; // 调用拷贝构造函数

#include <iostream>
using namespace std;

class Date {
public:
    // 构造函数：全缺省
    Date(int day = 8, int month = 1, int year = 2026) {
        _day = day;
        _month = month;
        _year = year;
    }
    // 拷贝构造函数
    Date(const Date& d) {
        _day = d._day;
        _month = d._month;
        _year = d._year;
    }
    void Print() {
        cout << _year << '/' << _month << '/' << _day << endl;
    }
private:
    int _day;
    int _month;
    int _year;
};

int main() {
    // 调用构造函数初始化 d1
    Date d1;
    // 不要写成 Date d1();
    d1.Print();
    // 创建对象的同时，调用拷贝构造进行初始化
    Date d2(d1);
    d2.Print();
    return 0;
}

• 函数参数按值传递该类的对象（传值传参）

基本形式：

void func(Example obj) {
    // ...
}
Example a;
func(a); // 调用拷贝构造函数

注意： 调用函数，形参是用实参拷贝构造出来的新对象，将实参传递就符合调用拷贝构造的规则。（函数形参也是一个需要被创建的对象。）

#include <iostream>
using namespace std;

class Date {
public:
    // 构造函数：全缺省
    Date(int day = 8, int month = 1, int year = 2026) {
        _day = day;
        _month = month;
        _year = year;
    }
    // 拷贝构造函数
    Date(const Date& d) {
        _day = d._day;
        _month = d._month;
        _year = d._year;
    }
    void Print() {
        cout << _year << '/' << _month << '/' << _day << endl;
    }
private:
    int _day;
    int _month;
    int _year;
};

void func(Date d) {
    d.Print();
}

int main() {
    // 调用构造函数初始化 d1
    Date d1;
    d1.Print();
    func(d1); // 调用拷贝函数
    return 0;
}

二、赋值运算符重载

2.1 铺垫：运算符重载特点

1. 当运算符被用于类类型的对象时，C++ 允许通过运算符重载的形式指定新的含义。C++ 规定，类类型对象使用运算符时，需要转换成调用相应的运算符重载，没有会报错；
2. 运算符重载式具有特殊名字的函数，名称由 operator 和后面的运算符构成，与普通函数一样，具有返回值、返回类型、参数、函数体等；
3. 重载运算符函数的参数个数和运算符的操作对象数量相同：一元运算符一个参数，二元运算符两个参数。对于二元：左侧运算对象传给第一个参数，右侧传给第二个参数；
4. 如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传隐式的 this 指针，因此运算符重载作为成员函数时，参数比运算对象少一个；
5. 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致；
6. 不能通过连接语法中没有的符号来创建新的操作符：比如 operator@；
7. .*、::、sizeof、? :、. 以上五个运算符不能重载；
8. 重载运算符至少有一个类类型的参数，不能通过运算符重载改变内置类型对象的含义，如：operator+(int x, int y);
9. 一个类需要哪些运算符重载。是看那些有实际意义，比如：Date 类的 operator- 有意义，operator* 没有意义；
10. 重载 ++ 运算符时，有前置 ++ 和后置 ++，运算符重载函数名都是 operator++，无法很好的区分。C++ 规定，后置 ++ 重载时，增加一个 int 形参，跟前置 ++ 构成函数重载，方便区分；
11. 重载 << 和 >> 时，需要重载为全局函数，因为重载为成员函数，this 指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了对象 <<cout，不符合使用习惯和可读性。重载为全局函数把 ostream/istream 放到第⼀个形参位置就可以了，第二个形参位置当类类型对象。

2.1.1 核心：理解运算符重载

【搭配举例】：

#include <iostream>
using namespace std;

class Date {
public:
    // 构造函数
    Date(int day = 8, int month = 1, int year = 2026) {
        _day = day;
        _month = month;
        _year = year;
    }
    // 如果运算符重载载在类外实现，解决变量私有化一个方法：
    // int Getyear(){return _year;}
    // 或者在类内定义
    // 比较 Date 类对象是否相等
    bool operator==(const Date& d) {
        // this 占第一个，显式第一个参数为左侧运算对象
        // 第 4 条：默认第一个参数为 this 指针
        return _day == d._day && _month == d._month && _year == d._year;
    }
private:
    int _day;
    int _month;
    int _year;
};

// 类外定义
// bool operator==(const Date& x1, const Date& x2) // 第 2 条
// {
//     return x1.day == x2._day && x1._month == x2._month &&
//            x1.year == x2._year;
// }

int main() {
    Date d1(1, 1, 1);
    Date d2;
    cout << (d1 == d2) << endl; // 第 3 条
}

【额外注意】：

• 当在类外定义运算符重载时，因为成员变量私有无法访问，可采取：
  • 将成员变量访问改为公有，但是太极端危险；
  • 在类内定义 int Getyear(); 之类函数，获取成员变量；
  • 直接在类内定义运算符重载成为成员函数（推荐），但是要注意参数的改变（第 4 条）。
  • 友元函数（后面会有）。
• 在最后输出结构，注意优先级。<< / >> 优先级较高，所以 ... == ... 要加括号。

【介绍 .* 运算符】：C++ 不常用，了解

#include <iostream>
using namespace std;

void func1() {
    cout << "void func()" << endl;
}

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

int main() {
    // 普通函数指针
    void (*pf1)() = func1;
    (*pf1)();
    // A 类型成员函数的指针
    void (A::* pf2)() = &A::func2;
    A aa;
    (aa.*pf2)(); // 这里就是使用的 .*
    // (aa.*pf2)(&aa); 错误，this 指针不能显式出现参数。
    return 0;
}

2.2 进阶：赋值运算符重载特点

赋值运算符重载是一个默认成员函数，用于完成两个已存在的对象直接的拷贝复制，要和拷贝构造区分开。

1. 赋值运算复是一个运算符重载，C++ 规定必须为成员函数。参数建议写成 const 当前类类型引用传参，当然传值传参会调用拷贝构造；
2. 有返回值，建议写成当前类类型引用，传引用返回可以提高效率，有返回值就可以连续赋值；
3. 当没有显式实现，编译器会默认生成，其行为和默认生成的拷贝构造类似，对内置类型成员变量会先完成值拷贝，对自定义类型会调用相应的赋值重载函数；
4. 类似 Date 类，为内置类型成员且不指向任何资源，编译器默认生成的浅拷贝就够了。但是类似 Stack 类，有指向的资源，就需要自定义深拷贝。

（这里和拷贝构造类似）

【技巧】：如果一个类显式实现了析构并释放资源，那么他就需要显式定义深拷贝，否则就不需要。

2.2 核心：理解赋值运算符重载

#include <iostream>
using namespace std;

class Date {
public:
    // 构造函数
    Date(int day = 8, int month = 1, int year = 2026) {
        _day = day;
        _month = month;
        _year = year;
    }
    // 拷贝构造
    Date(const Date& d) {
        _day = d._day;
        _month = d._month;
        _year = d._year;
    }
    // 赋值重载
    // d1 = d2
    Date& operator=(const Date& d) {
        if (this != &d) {
            _day = d._day;
            _month = d._month;
            _year = d._year;
        }
        return *this; // 返回 d1 别名，不拷贝
    }
    void Print() {
        cout << _year << '/' << _month << '/' << _day << endl;
    }
private:
    int _day;
    int _month;
    int _year;
};

int main() {
    Date d1(1, 1, 1);
    Date d2(d1); // 拷贝构造
    Date d3 = d1; // 拷贝构造
    d2.Print();
    d3.Print();
    Date d4;
    Date d5;
    d5 = d4 = d1; // 赋值重载
    d4.Print();
    return 0;
}

【说明】：Date& operator=(const Date& d); 为什么可以传引用返回？

在拷贝构造部分，有过说明'传值返回会发生拷贝'，但是 this 不是这个函数的局部对象，不会销毁，额外的拷贝就很麻烦，没必要。

总结

拷贝构造函数与赋值运算符重载构成了 C++ 对象复制机制的核心支柱。它们分别负责对象初始化和对象赋值两种不同场景的复制需求。掌握这些复制控制机制，不仅能写出更安全的代码，更能深入理解 C++ 对象生命周期的管理哲学。这是从 C++ 使用者迈向 C++ 设计者的重要一步。