【C++入门】5 类与对象中-拷贝构造函数

目录

拷贝构造函数

概念

特征

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

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

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

---

拷贝构造函数

概念

在生活中，我们常能看到长得极其相似的事物，不管是树叶、人、还是动漫形象

孙悟空和六耳猕猴就是很好的例子， 那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存
在的类类型对象创建新对象时由编译器自动调用。

特征

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

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

因为和构造参数相比，拷贝构造函数主要是传递的参数个数有所差别。

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

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);
return 0;
}

如果把Date(const Date& d) 改写成Date(const Date d)  ，编译器就会报错。编译器在这里不允许拷贝构造函数使用传值传参，那我们来分析一下为什么传值传参有问题。

请看下图分析：

很明显，C++传值传参会去调用拷贝构造，就造成一直在传参，无穷递归，压根进不了函数。破不了局，连返回条件都没发写，因为没进函数。最完美的解决方案：传引用传参不需要调用拷贝构造。

3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

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;
Date d2(d1);
return 0;
}

 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构
造函数 。这里和构造函数性质是一样的，构造函数如果没有被显式的写出来，编译器会自动生成一个默认的构造函数，对内置型变量不做处理，对自定义类型调用其构造函数，这里对自定义类型的构造函数就是一种间接调用，而非直接调用，因为创建对象是Date类而非Time类。

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
义类型是调用其拷贝构造函数完成拷贝的。（但是浅拷贝也有他的缺陷）

4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？
当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
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;
}

我尝试运行了一下代码，结果不出所料，报错了。

分许：编译器警告我说：堆上的空指针有问题，于是我们走读代码。我们在这个代码中没写拷贝构造函数 ，于是编译器自己生成了拷贝构造函数，在这个类中，我们没有自定义类型，那么编译器对所有变量（内置类型）都是进行的浅拷贝，也就是一个个字节拷贝的。为什么会出现空指针的问题也就很显然了，类中的唯一有真正作用的指针就是_array的数组指针，在程序结束时，系统使用析构函数对资源进行清理，由于是浅拷贝，s1和s2的数组指针指向的是同一块空间，也就是说同一块空间被析构函数free了两次，第一次free后，系统就有可能给这块空间分配其他数据，再进行释放，这块数据就会丢失，编译器自然会报错。

具体分析图如下：

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

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

1.使用已存在对象创建新对象
2.函数参数类型为类类型对象
3.函数返回值类型为类类型对象 

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;
}

 

这里的销毁就是基于析构函数的调用顺序的

局部对象（后定义先析构）-》局部静态-》全局对象（后定义先析构）

因此先析构局部对象temp，再是局部对象 d，再是局部静态的函数返回值（返回值是临时变量，具有常性，存储在静态区中）最后再是全局的对象d1。

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用
尽量使用引用。