文章目录
- 一、拷贝构造函数的概念
- 二、拷贝构造函数的特性
- 三、深度剖析拷贝构造函数不采用引用会无限递归的原因
- 1.C++对于传参的两个规定
- 2.如何解开这个无穷递归
- 四、拷贝构造函数的其他特性
- 五、拷贝构造的一些使用场景
一、拷贝构造函数的概念
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
二、拷贝构造函数的特性
- 拷贝构造函数是构造函数的一个重载形式
- 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
根据以上的两个特性，那么我们先来简单的写一个拷贝构造函数
class Date
{
public:
Date(int year = 2023, int month = 5, int day = 6)
{
_year = year;
_month = month;
_day = day;
}
Date(Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
void Print()
{
cout << _year << '-' << _month << '-' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 5, 6);
d1.Print();
Date d2(d1);
d2.Print();
return 0;
}
根据上面的这些，我们已经不难理解，拷贝构造函数其实就是一个构造函数。而一旦确定了拷贝构造函数，那么有没有了默认构造函数了，我们就得写一个默认构造函数。
三、深度剖析拷贝构造函数不采用引用会无限递归的原因
1.C++对于传参的两个规定
- 如果传的是内置类型，则直接拷贝给形参
- 如果传的是自定义类型，则通过调用拷贝构造函数拷贝给形参
根据这两条规矩，我们可以写出如下代码来进行测试
class Date
{
public:
Date(int year = 2023, int month = 5, int day = 6)
{
_year = year;
_month = month;
_day = day;
}
Date(Date& d)
{
cout << "Date(Date& d)" << endl;
_year = d._year;
_month = d._month;
_day = d._day;
}
void Print()
{
cout << _year << '-' << _month << '-' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
void func(int i)
{
}
void func(Date d)
{
}
int main()
{
//Date d1(2024, 5, 6);
//d1.Print();
//Date d2(d1);
//d2.Print();
Date d1;
func(10);
func(d1);
return 0;
}
运行结果如下所示：
可见确实在传参的时候调用了拷贝构造函数
这样一来我们就明白了，一旦，我们是不采用引用，直接传值的话，那么在拷贝给形参的过程中又要去调用拷贝构造函数，这个拷贝构造又要传参去调用新的拷贝构造…所以自然就会发生无穷递归了
2.如何解开这个无穷递归
- 采用指针，指针是内置类型，所以是直接拷贝。不会引发无穷递归，但是我们在使用拷贝构造函数的时候就需要传地址过去了
- 采用引用，这样一来我们直接传的是它的别名。不会产生新的空间消耗，自然就不会发生无穷递归了，C++中也是最好采用这种方法，在我们使用引用的时候，最好加上const进行修饰，这样别名的权限就缩小了。使得我们不会做出一些危害原本空间的事情.
四、拷贝构造函数的其他特性
若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
注意：内置类型成员变量是直接拷贝的/浅拷贝
而自定义类型成员变量需要调用它的拷贝构造函数
我们来测试一下这条规则
事实上，上面的情形是基于第一条的场景，如果对于自定义类型，如果是栈的话，会出现一些意想不到的情形
typedef int DataType;
class Stack
{
public:
Stack()
{
cout << "Stack" << endl;
_array = (DataType*)malloc(sizeof(DataType) * 4);
if (nullptr == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = 4;
_size = 0;
}
void Push(DataType data)
{
CheckCapacity();
_array[_size] = data;
_size++;
}
void Pop()
{
if (Empty())
return;
_size--;
}
DataType Top() { return _array[_size - 1]; }
int Empty() { return 0 == _size; }
int Size() { return _size; }
~Stack()
{
cout << "~Stack" << endl;
if (_array)
{
free(_array);
_array = nullptr;
_capacity = 0;
_size = 0;
}
}
private:
void CheckCapacity()
{
if (_size == _capacity)
{
int newcapacity = _capacity * 2;
DataType* temp = (DataType*)realloc(_array, newcapacity * sizeof(DataType));
if (temp == nullptr)
{
perror("realloc申请空间失败!!!");
return;
}
_array = temp;
_capacity = newcapacity;
}
}
private:
DataType * _array;
int _capacity;
int _size;
};
class Date
{
public:
Date(int year = 2023, int month = 5, int day = 6)
{
_year = year;
_month = month;
_day = day;
}
//Date(Date& d)
//{
// cout << "Date(Date& d)" << endl;
// _year = d._year;
// _month = d._month;
// _day = d._day;
//}
void Print()
{
cout << _year << '-' << _month << '-' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
void func(int i)
{
}
void func(Date d)
{
}
int main()
{
Date d1(2024, 5, 6);
d1.Print();
Date d2(d1);
d2.Print();
//Date d1;
//func(10);
//func(d1);
Stack s1;
Stack s2(s1);
return 0;
}
这里我们发现它报错了，具体报错的原因，我们可以通过调试分析，我们可以发现，它在析构函数中出现了错误。我们可以发现，我们调用了两次析构，一次是对是说s2的释放，一次是对是s1的释放，而巧的是，由于我们的栈中是由指针控制的数组，所以当成了值拷贝，仅仅只是拷贝了指针指向的地址。就会产生同一块空间释放两次的结果，自然就会报错了。需要注意的是，调用析构的时候，是按照栈的特性，后定义的先释放。
这也就是我们为什么所说的编译器生成的其实是浅拷贝的原因。
这时候就需要我们自己去写一个深拷贝来解决了，我们先来简单的写一个简单的深拷贝
Stack(const Stack& s)
{
cout << "Stack(const Stack& s)" << endl;
_array = (DataType*)malloc(sizeof(DataType) * s._capacity);
if (nullptr == _array)
{
perror("malloc申请空间失败!!!");
return;
}
memcpy(_array, s._array, sizeof(DataType) * s._size);
_capacity = s._capacity;
_size = s._size;
}
事实上，这时候我们也理解了为什么C++规定，自定义类型必须调用拷贝构造函数，如果不调用拷贝构造函数，那么如果在一个函数中传参传的是一个栈的话，就会产生将同一块空间析构两次的现象。而且也会产生一个栈的值改变了，影响另外一个栈的值的现象
注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝
我们在来分析一下，对于这个队列，事实上其实就需要写自己的拷贝构造函数了，因为可以直接调用它们的拷贝构造函数
class myQueue
{
private:
Stack push_st;
Stack pop_st;
};
五、拷贝构造的一些使用场景
- 使用已存在对象创建新对象
- 函数参数类型为类类型对象
- 函数返回值类型为类类型对象
使用对象创建新对象和函数参数我们已经了解了。在这期间会调用拷贝构造函数来实现拷贝
那么如果是对于返回值类型为类类型对象的话
如下所示，该过程比较复杂：
- 先进入func函数，调用s的构造函数，打印Stack
- 打印func函数中的字符串
- 由于是传值返回，会产生临时变量，将s的值调用拷贝构造函数给这个临时变量，打印深拷贝构造中的字符串
- 释放s，调用析构函数，打印析构的字符串
- 将临时变量中的数据直接拷贝给ret，然后释放临时变量调用析构函数，打印析构中的字符串
如果我们选择传引用返回的话，程序直接崩溃。
下面具体分析原因：
- 进入func函数，创建s，调用构造函数
- 打印func中的字符串
- 由于传引用返回不创建临时变量，所以直接调用析构
- 此时s的空间已经归还，继续将s的别名返回，相当于将s拷贝给ret，调用拷贝构造函数
- 由于在析构函数中，已经将指针置空。我们在拷贝构造函数中的memcpy已经是野指针访问了，报错
- 野指针访问虽然是直接原因，但如果没有这个原因的话，也会因为拷贝后的第二次析构而报错
好了本期内容就到这里了
如果对你有帮助的话，不要忘记点赞加收藏哦！！！
