文章目录
- 拷贝构造函数
- 1.拷贝构造函数的概念
- 2.拷贝构造函数的特性
前言
本章继续学习类的6个默认成员函数——拷贝构造函数
拷贝构造函数
1.拷贝构造函数的概念
拷贝构造函数：使用已经存在的一个对象初始化创建另一个对象。
举例：
class Date
{
public:
// 构造函数
Date()
{
cout << "Date()" << endl;
}
// 拷贝构造函数
Date(const Date& d)
{
cout << "Date(&)" << endl;
_year = d._year;
_month = d._month;
_day = d._day;
}
~Date()
{
cout << "~Date()" << endl;
}
private:
int _year = 0;
int _month = 0;
int _day = 0;
};
void TestDate()
{
Date d1;
Date d2(d1);
}
int main()
{
TestDate();
}
运行结果：
2.拷贝构造函数的特性
- 拷贝构造函数是构造函数的重载
- 拷贝构造函数的参数只有一个且必须是类类型对象的引用。若使用传值的方式，则编译器会报错，因为理论上这会引发无穷递归。
错误示例：
class Date
{
public:
// 错误示例：
// 这样写，编译器就会报错，会引发无穷递归
Date() {};
Date(const Date d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
private:
int _year = 0;
int _month = 0;
int _day = 0;
};
void TestDate()
{
Date d1;
Date d2(d1);
}
- 当拷贝构造函数的参数采用传值的方式时，创建对象
d2，会调用它的拷贝构造函数，d1会作为实参传递给形参d。但是，实参传递给形参本身又是一个拷贝，会再次调用形参的拷贝构造函数……，因此会引发无穷递归。
3.若显示未定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数按对象内存存储字节序完成拷贝，这种拷贝叫做浅拷贝或值拷贝。
示例：
class Date
{
public:
// 错误示例：
// 这样写，编译器就会报错，会引发无穷递归
Date(int year=0,int month=0,int day=0)
{
_year = year;
_month = month;
_day = day;
}
// 未显示定义的拷贝构造函数
//Date(const Date& d)
//{
// _year = d._year;
// _month = d._month;
// _day = d._day;
//}
void print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year = 0;
int _month = 0;
int _day = 0;
};
void TestDate()
{
Date d1(2023,5,3);
Date d2(d1);
d2.print();
}
int main()
{
TestDate();
return 0;
}
运行结果：
注意：
- 在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
义类型是调用其拷贝构造函数完成拷贝的。
4.类中如果没有涉及资源申请时，拷贝构造函数写不写都可以，一旦涉及资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
错误示例：
class stack
{
public:
stack(int defaultCapacity = 10)
{
_a = (int*)malloc(sizeof(int) * defaultCapacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capacity = defaultCapacity;
}
~stack()
{
cout << "~stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
void push(int n)
{
_a[_top++] = n;
}
void print()
{
for (int i = 0; i < _top; i++)
{
cout << _a[i] << " ";
}
cout << endl;
}
private:
int* _a;
int _top;
int _capacity;
};
void TestStack()
{
stack s1;
s1.push(1);
s1.push(2);
s1.push(3);
s1.push(4);
s1.print();
stack s2(s1);
s2.print();
s2.push(5);
s2.push(6);
s2.push(7);
s2.push(8);
s2.print();
}
int main()
{
TestStack();
return 0;
}
运行结果：
如图所示：程序崩溃了，经过排查，我们发现是在第二次析构的时候出现了错误：在第二次析构的时候对野指针进行了free。
那为什么会出现对野指针进行free呢？
-
对象
s1与对象s2中的成员_a，指向的是同一块内存空间。 在s2析构完成后，这块空间已经被释放，此时的s1._a就是野指针。这也就是浅拷贝导致的后果。 -
多个对象进行析构的顺序如同栈一样，先创建的对象后析构，后创建的对象先析构。
浅拷贝？？ 🤔
编译器默认生成的拷贝构造函数是按字节序拷贝的，在创建对象
s2时，仅仅是把s1._a的值赋给s2._a，并没有重新开辟一块与s1._a所指向的空间大小相同且内容相同的空间。我们把前者的拷贝方式称为浅拷贝，后者称为深拷贝。
当打开监视窗口来观察整个过程时，我们发现s1._a与s2._a指向的是同一块空间，内容是相同的：
正确的做法应该是：
class stack
{
public:
stack(int defaultCapacity = 10)
{
_a = (int*)malloc(sizeof(int) * defaultCapacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capacity = defaultCapacity;
}
stack(const stack& s)
{
_a = (int*)malloc(sizeof(int) * s._capacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
memcpy(_a, s._a, sizeof(int) * s._capacity);
_top = s._top;
_capacity = s._capacity;
}
~stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
void push(int n)
{
_a[_top++] = n;
}
void print()
{
for (int i = 0; i < _top; i++)
{
cout << _a[i] << " ";
}
cout << endl;
}
private:
int* _a;
int _top;
int _capacity;
};
5.拷贝构造函数典型的使用场景
- 使用已存在对象创建新对象
- 函数参数类型为类类型对象
- 函数返回值类型为类类型对象
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用以用尽量使用引用。
本文到此结束，码文不易，还请多多支持哦！！
