【C++】拷贝构造函数(超详细解析，小白必看系列）

1 拷贝构造引出

在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。

那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

2 拷贝构造特型

拷贝构造函数在C++中有一些重要的特性，了解这些特性有助于更好地使用和实现它们。以下是两个主要的特性：

1. 拷贝构造函数是构造函数的重载形式

拷贝构造函数是构造函数的一种特殊形式，它的参数是同类对象的引用。它的定义形式如下：

classname(const classname &obj);

例如：

class Point {
public:
    Point(int x = 0, int y = 0) : x(x), y(y) {}
    Point(const Point &p); // 拷贝构造函数
private:
    int x, y;
};

Point::Point(const Point &p) {
    x = p.x;
    y = p.y;
}

在这个例子中，Point 类的拷贝构造函数通过引用参数 p 初始化新对象的成员变量 x 和 y。

2. 拷贝构造函数的参数必须是类类型对象的引用

拷贝构造函数的参数必须是类类型对象的引用，而不能是传值方式。这是因为传值方式会导致无穷递归调用，从而引发编译错误。引用参数可以避免这种递归调用。

例如：

class Date {
public:
    Date(int year, int month, int day) : year(year), month(month), day(day) {}
    Date(const Date &d); // 正确的拷贝构造函数
private:
    int year, month, day;
};

Date::Date(const Date &d) {
    year = d.year;
    month = d.month;
    day = d.day;
}

如果使用传值方式定义拷贝构造函数，会导致编译错误：

class Date {
public:
    Date(int year, int month, int day) : year(year), month(month), day(day) {}
    Date(Date d); // 错误的拷贝构造函数
private:
    int year, month, day;
};

Date::Date(Date d) {
    year = d.year;
    month = d.month;
    day = d.day;
}

3. 若未显式定义，编译器会生成默认的拷贝构造函数。

默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

浅拷贝的例子

浅拷贝会直接复制对象的所有成员变量，包括指针成员的地址。这可能会导致多个对象共享同一块内存，从而引发潜在的问题，如双重释放内存。

#include <iostream>
using namespace std;

class ShallowCopy {
public:
    int *data;
    ShallowCopy(int d);
    ShallowCopy(const ShallowCopy &source);
    ~ShallowCopy();
    void display() const { cout << "Data: " << *data << endl; }
};

ShallowCopy::ShallowCopy(int d) {
    data = new int;
    *data = d;
}

ShallowCopy::ShallowCopy(const ShallowCopy &source) : data(source.data) {
    cout << "调用浅拷贝构造函数" << endl;
}

ShallowCopy::~ShallowCopy() {
    delete data;
    cout << "调用析构函数" << endl;
}

int main() {
    ShallowCopy obj1(10);
    ShallowCopy obj2 = obj1; // 浅拷贝
    obj2.display();
    return 0;
}

代码报错

深拷贝的解决方案

为了避免浅拷贝带来的问题，我们可以显式定义一个拷贝构造函数，进行深拷贝。深拷贝会为每个对象分配独立的内存空间，从而避免共享内存的问题。

#include <iostream>
using namespace std;

class Deep {
public:
    int *data;
    Deep(int d);
    Deep(const Deep &source); // 深拷贝构造函数
    ~Deep();
    void display() const { cout << "Data: " << *data << endl; }
};

Deep::Deep(int d) {
    data = new int;
    *data = d;
}

Deep::Deep(const Deep &source) {
    data = new int;
    *data = *source.data;
    cout << "调用深拷贝构造函数" << endl;
}

Deep::~Deep() {
    delete data;
    cout << "调用析构函数" << endl;
}

int main() {
    Deep obj1(10);
    Deep obj2 = obj1; // 触发深拷贝构造函数
    obj2.display();
    return 0;
}

代码成功调用