c++新经典 14.5拷贝构造函数 王建伟 自用

前面讲到了对象的复制，那么怎么控制这种复制呢？不要以为就随随便便copy一下类里面的值就行了

⬇️

拷贝构造函数是一个特殊的构造函数。复制就是创建一个新对象时，用另一个同类型的对象来初始化这个新对象。而拷贝构造函数定义了如何控制这种复制。

拷贝构造函数通常具有以下特点：

1. 它的参数是一个对同类型对象的引用。

2. 为了防止对参数对象的修改，这个引用通常是 const 类型。

3. 它可以进行深拷贝，即复制对象内部动态分配的资源，比如指向动态分配内存的指针。

4. 如果程序员没有显式定义拷贝构造函数，编译器会自动生成一个默认的拷贝构造函数，进行成员逐个拷贝（浅拷贝）。

一个拷贝构造函数的声明通常看起来像这样：

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

实现时，你需要复制 other 对象的每个属性到新创建的对象中，确保两个对象虽然内容相同，但是互不影响。如果类中没有包含指向动态分配资源的指针，通常可以依赖编译器生成的默认拷贝构造函数。但是，如果类中包含了动态分配的内存或其他需要“深拷贝”的资源，就必须自己定义拷贝构造函数来确保资源的正确复制。

下面是一个简单的拷贝构造函数的例子：

class MyClass {
public:
    int* data;

    // 普通构造函数
    MyClass(int value) {
        data = new int(value);
    }

    // 拷贝构造函数
    MyClass(const MyClass& other) {
        data = new int(*other.data);
    }

    // 析构函数
    ~MyClass() {
        delete data;
    }
};

在这个例子中，拷贝构造函数确保了当创建一个 MyClass 对象的副本时，动态分配的内存也得到了正确的复制，而不是仅仅复制指针，这避免了两个对象指向同一内存块的问题。

实例：

#include <iostream>
#include <cstring>

class StringWrapper {
public:
    // 成员变量，指向动态分配的字符串
    char* str;

    // 构造函数，用 C 风格字符串初始化
    StringWrapper(const char* s) {
        if (s) {
            str = new char[strlen(s) + 1];
            strcpy(str, s);
        } else {
            str = nullptr;
        }
    }

    // 拷贝构造函数，实现深拷贝
    StringWrapper(const StringWrapper& other) {
        if (other.str) {
            str = new char[strlen(other.str) + 1];
            strcpy(str, other.str);
        } else {
            str = nullptr;
        }
    }

    // 析构函数，释放动态分配的内存
    ~StringWrapper() {
        delete[] str;
    }

    // 打印字符串的辅助函数
    void print() const {
        if (str) {
            std::cout << str << std::endl;
        } else {
            std::cout << "String is null." << std::endl;
        }
    }
};

int main() {
    // 创建一个 StringWrapper 对象
    StringWrapper original("Hello, World!");

    // 使用拷贝构造函数创建一个副本
    StringWrapper copy(original);

    // 打印两个对象的字符串
    std::cout << "Original对象里的str地址: " << &(original.str) << std::endl;
    original.print();
    std::cout << "Copy对象里的str地址: " << &(copy.str) << std::endl;
    copy.print();

    return 0;
}

打印结果

Original对象里的str地址: 0x7ff7bfeff220
Hello, World!
Copy对象里的str地址: 0x7ff7bfeff218
Hello, World!

两个对象里的 字符串地址不一样

如果是随随便便copy了一下char*s str，那么这两个对象里的字符串地址应该是一样的