C++面向对象程序设计——9.拷贝和赋值

原创已于 2025-06-23 00:44:07 修改 · 890 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#c++

于 2025-06-22 02:22:36 首次发布

C++面向对象程序设计专栏收录该内容

24 篇文章

订阅专栏

一、核心概念：拷贝构造 vs 赋值

这是最重要的区别，必须首先搞清楚。

拷贝构造 (Copy Construction): 从无到有。它使用一个已存在的对象，来创建一个全新的、一模一样的对象。
- A a2(a1); // 直接调用拷贝构造函数
- A a3 = a1; // 同样是调用拷贝构造函数，因为a3是新创建的对象
赋值 (Assignment): 修改旧的。将一个已存在对象的数据，赋值给另一个已存在的对象。
- A a1, a2;
- a1 = a2; // 调用赋值运算符，a1在赋值前已经存在

简单记： 定义新变量时用 = 是拷贝构造；对两个已存在的变量用 = 是赋值。

二、为什么需要拷贝与赋值？

编译器在一些情况下会自动进行对象拷贝，如果你不了解这个机制，程序可能在运行时悄无声息地崩溃。

当函数参数按值传递时：

void printStudent(Student stu) { // stu是通过拷贝构造函数创建的副本
    // ...
}

int main() {
    Student s1;
    printStudent(s1); // 这里发生了对象拷贝
    return 0;
}

当函数返回一个对象时：

Student createStudent() {
    Student temp;
    return temp; // 返回时，会创建一个临时对象作为temp的副本
}

int main() {
    Student s2 = createStudent(); // 临时对象被用来构造s2
    return 0;
}

注意：现代编译器有“返回值优化”(RVO)技术，在某些情况下可以避免这次拷贝，但这不代表你可以忽略拷贝构造函数的存在。

三、拷贝构造函数 (Copy Constructor)

1. 浅拷贝 (Shallow Copy) - 默认行为与陷阱

如果你不自己定义拷贝构造函数，编译器会自动生成一个。这个默认的拷贝构造函数执行的是浅拷贝。

什么是浅拷贝？
它就是简单地将对象内存中的数据逐位(bit-by-bit)复制到新对象。
- 对于int, double等基本类型成员，这没问题。
- 对于指针成员，它只复制指针的地址，而不是指针指向的内容。

浅拷贝的致命问题
当两个对象的指针成员指向同一块堆内存时：

其中一个对象析构时，会 delete 这块内存。
另一个对象在未来析构时，会尝试 delete 同一块已经被释放的内存，导致程序崩溃（二次释放 Double Free）。

【机试高频考点】

class Student {
public:
    Student(const char* name) {
        _name = new char[strlen(name) + 1]; // 在堆上分配内存
        strcpy(_name, name);
    }
    ~Student() {
        delete[] _name; // 析构时释放内存
    }
private:
    char* _name;
};

int main() {
    Student s1("Tom");
    Student s2 = s1; // 默认浅拷贝，s1._name 和 s2._name 指向同一地址
    return 0;
} // main结束时，s2析构，释放内存。然后s1析构，再次释放同一块内存，程序崩溃！

2. 深拷贝 (Deep Copy) - 正确的解决方案

为了解决浅拷贝的问题，我们需要自定义拷贝构造函数，实现深拷贝。

什么是深拷贝？
当拷贝指针成员时，不是只拷贝地址，而是为新对象重新分配一块内存，并将源对象指针所指向的内容复制过来。

如何实现？

class Student {
public:
    Student(const char* name) {
        _name = new char[strlen(name) + 1];
        strcpy(_name, name);
    }

    ~Student() {
        delete[] _name;
    }

    // 自定义拷贝构造函数，实现深拷贝
    Student(const Student& other) {
        // 1. 为新对象的指针成员分配新的内存
        _name = new char[strlen(other._name) + 1];
        // 2. 复制内容，而不是地址
        strcpy(_name, other._name);
    }

private:
    char* _name;
};

int main() {
    Student s1("Tom");
    Student s2 = s1; // 调用自定义的深拷贝构造函数
    return 0;
} // s2析构，释放自己的内存。s1析构，释放自己的内存。互不影响，程序安全。

3. 拷贝构造函数的标准格式

ClassName(const ClassName& other);

const: 保证在拷贝过程中不会修改到源对象 other。
& (引用): 必须是引用传递。如果按值传递 (ClassName other)，会导致为了传入参数 other 而调用拷贝构造函数，从而无限递归直到栈溢出。

4. 如何禁止对象拷贝？

有些类的对象天生就不应该被拷贝（例如数据库连接、文件句柄等）。

C++11及以后 (推荐方式): 使用 = delete 关键字。

class NonCopyable {
public:
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
    // ... 其他成员
};

C++03 (传统方式): 将拷贝构造函数声明为 private 且不提供实现。

class NonCopyable {
private:
    NonCopyable(const NonCopyable&); // 只声明，不实现
    // ...
};

四、赋值运算符 (Assignment Operator)

1. 浅赋值与深赋值

与拷贝构造函数类似，如果你不提供自定义的赋值运算符，编译器也会生成一个默认的，它同样执行浅赋值，会带来和浅拷贝一模一样的内存泄漏和二次释放问题。

浅赋值的陷阱：

// 假设Student类没有自定义赋值运算符
Student s1("Tom");
Student s2("Jerry");
s1 = s2; // s1原来的内存泄漏了，且s1和s2的_name指针指向同一处

2. 自定义赋值运算符的标准实现

一个健壮的赋值运算符必须处理好三件事：自我赋值、资源清理和深拷贝。

【机试必背代码】

// 在Student类中添加
Student& operator=(const Student& other) {
    // 1. 检查自我赋值 (a = a 的情况)
    if (this == &other) {
        return *this; // 如果是自我赋值，什么都不做，直接返回
    }

    // 2. 释放当前对象已有的资源
    delete[] _name;

    // 3. 执行深拷贝
    _name = new char[strlen(other._name) + 1];
    strcpy(_name, other._name);

    // 4. 返回当前对象的引用，以支持链式赋值 (a = b = c)
    return *this;
}

返回 ClassName&: return *this; 是为了支持 a = b = c; 这样的链式赋值。
自我赋值检查: if (this == &other) 是为了防止 s1 = s1; 这样的操作。如果没有这个检查，delete[] _name; 会先把自己删掉，后面的 other._name 就变成非法内存了。