深层次理解拷贝构造函数

1.1 拷贝构造概念

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

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

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

1.2 特征

拷贝构造函数也是特殊的成员函数，其特征如下：

拷贝构造函数是构造函数的一个重载形式。

拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，

因为会引发无穷递归调用。

为什么拷贝构造函数不能用传值传参？因为c++规定自定义类型都要调用拷贝构造函数，这样子调用自己，会造成无穷递归。

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 // Date(const Date& d)   // 正确写法
    Date(const Date& d)   // 错误写法：编译报错，会引发无穷递归
 {
 _year = d._year;
 _month = d._month;
 _day = d._day;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d1;
 Date d2(d1);//拷贝构造
 Date d3 = d1;//拷贝构造
 return 0;
}

// 传值传参
// 内置类型，编译器可以直接拷贝
// 自定义类型的拷贝，需要调用拷贝构造
void Func1(Date d)//这个是自定义类型，需要调用拷贝构造函数， 引发无限递归
{

}

// 传引用传参
void Func2(Date& d)//引用是别名，直接拷贝
{

}

void Func3(Date* d)//这个是指针，也是直接拷贝
{

}

int main()
{
	Date d1(2023, 2, 3);
	Date d2(d1);
	Date d3 = d1;

	//Date d4(&d1);
	//Date d5 = &d1;

	Func1(d1);
	Func2(d1);
	Func3(&d1);

	return 0;
}

const 是权限减小，为了防止程序员误修改了d1。

若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按

字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

深拷贝就是不是单纯的复制，还把malloc开辟的空间也另外开辟。

c语言中结构体传参都是传地址，一旦是传值传参，就是浅拷贝，有可能会出现bug，因为如果传了malloc开辟的地址，结构体传过来修改了，就可能改了原来的结构体。这是c语言的bug。

class Time
{
public:
 Time()
 {
 _hour = 1;
 _minute = 1;
 _second = 1;
     }
 Time(const Time& t)
 {
 _hour = t._hour;
 _minute = t._minute;
 _second = t._second;
 cout << "Time::Time(const Time&)" << endl;
 }
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
private:
 // 基本类型(内置类型)
 int _year = 1970;
 int _month = 1;
 int _day = 1;
 // 自定义类型
 Time _t;
};
int main()
{
 Date d1;
    
    // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
    // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构
造函数
 Date d2(d1);
 return 0;
}

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定

义类型是调用其拷贝构造函数完成拷贝的。

编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？

当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
typedef int DataType;
class Stack
{
public:
 Stack(size_t capacity = 10)
 {
 _array = (DataType*)malloc(capacity * sizeof(DataType));
 if (nullptr == _array)
 {
 perror("malloc申请空间失败");
 return;
 }
     _size = 0;
 _capacity = capacity;
 }
 void Push(const DataType& data)
 {
 // CheckCapacity();
 _array[_size] = data;
 _size++;
 }
 ~Stack()
 {
 if (_array)
 {
 free(_array);
 _array = nullptr;
 _capacity = 0;
 _size = 0;
 }
 }
private:
 DataType *_array;
 size_t _size;
 size_t _capacity;
};
int main()
{
 Stack s1;
 s1.Push(1);
 s1.Push(2);
 s1.Push(3);
 s1.Push(4);
 Stack s2(s1);
 return 0;
}

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

拷贝构造函数典型调用场景：

使用已存在对象创建新对象

函数参数类型为类类型对象

函数返回值类型为类类型对象

class Date
{
public:
 Date(int year, int minute, int day)
 {
 cout << "Date(int,int,int):" << this << endl;
 }
 Date(const Date& d)
 {
 cout << "Date(const Date& d):" << this << endl;
 }
 ~Date()
 {
 cout << "~Date():" << this << endl;
 }
private:
 int _year;
 int _month;
 int _day;
};
Date Test(Date d)
{
 Date temp(d);
 return temp;
}
int main()
{
 Date d1(2022,1,13);
 Test(d1);
 return 0;
}