拷贝构造
概念
在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。
那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢?
拷贝构造函数: 只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
特征
拷贝构造函数也是特殊的成员函数，其特征如下
1.拷贝构造函数是构造函数的一个重载形式
2.拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错因为会引发无穷递归调用。
3.若未显式定义，编译器会生成默认的拷贝构造函数。
默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
实验日期类——浅拷贝
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month=1, int day=1)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2023, 10, 28);
Date d2(d1);
d1.Print();
d2.Print();
}
在日期类中，我们不写拷贝构造函数时，使用编译器默认生成的可以完成值拷贝/浅拷贝，对于日期类足够使用。
怎么验证呢？
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month=1, int day=1)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
~Date()
{
cout << "~Date()" << endl;
}
private:
int _year;
int _month;
int _day;
};
void F(Date d1)
{
d1.Print();
}
int main()
{
Date d1(2023, 10, 28);
F(d1);
}
这里析构了两次，第一次析构是d1.print出了作用域要销毁去调用一次析构，第二次是析构是Date d1在程序结束之前自己去调用了一次析构(日期类不需要去析构销毁，这里只是为了下面拷贝构造的引用传参做铺垫)
为了减去第一次析构，使用引用做形参
加上引用以后d1.print出了作用域就不会销毁，自然不会去调用掉析构函数，因为Date&d1 就是d1的别名，它会在程序结束之前自己去调用析构(虽说是内存自己回收内置类型，这里调用Date的析构只是为了好理解拷贝构造的引用传参)。
实验栈类——浅拷贝or深拷贝？
class Stack
{
public:
Stack(size_t capacity = 3)
{
cout << "Stack(size_t capacity = 3)" << endl;
_a = (int*)malloc(sizeof(int) * capacity);
if (_a == nullptr)
{
perror("malloc fail");
return;
}
_capacity = capacity;
_top = 0;
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
int* _a;
int _top;
int _capacity;
};
void f(Stack st1)
{
//...
}
int main()
{
Stack st;
f(st);
}
为什么会出现程序崩溃？
因为 st1出了作用域会销毁，去调用析构函数，_a被释放了，后面st再去调用析构函数，导致_a再次被释放，共计了释放了两次(_a指向的空间被释放了两次)
那么怎么解决这个问题呢？
规定：自定义类型对象拷贝的时候，必须调用一个函数叫拷贝构造。
在初始化的时候就去调用拷贝构造。
原因
栈类会造成_a释放两次 而日期类会造成无穷递归
调用拷贝构造 先传参 传值传参 形成新的拷贝构造 形成套娃
因此C++规定用引用传参
解决(正确使用拷贝构造)
拷贝构造(引用传值)
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month=1, int day=1)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
Date(const Date& d)
{
_year == d._year;
_month = d._month;
_day = d._day;
}
~Date()
{
cout << "~Date()" << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2023, 10, 28);
Date d2(d1);
}
为了防止拷贝构造赋值传反，加上const修饰， &d(d1)的别名，隐含的this指针指向了d2,引用传值又减少了一次析构(虽然内置类型数据系统自己结束时回收)。
栈—拷贝构造(深拷贝)
class Stack
{
public:
Stack(size_t capacity = 3)
{
cout << "Stack(size_t capacity = 3)" << endl;
_a = (int*)malloc(sizeof(int) * capacity);
if (_a == nullptr)
{
perror("malloc fail");
return;
}
_capacity = capacity;
_top = 0;
}
深拷贝
Stack(const Stack&stt)
{
cout << "Stack(const Stack&stt)" << endl;
_a = (int*)malloc(sizeof(int) * stt._capacity);
if(_a == nullptr)
{
perror("malloc fail");
return;
}
_top = stt._top;
_capacity = stt._capacity;
memcpy(_a, stt._a, sizeof(int) * stt._top);
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
int* _a;
int _top;
int _capacity;
};
int main()
{
Stack st;
Stack st1(st);
}
Stack &stt是st的别名，this指针指向st1，最后把st的数据给st1转过去完成拷贝。
st先进去构造 然后st1进行深拷贝 出了作用域再去调用析构函数 最后程序结束前 st再去调用析构函数。
st和st1指向的空间都不同，所以不会出现同一个空间释放两次的问题。拷贝构造完美解决。
队列
class Stack
{
public:
Stack(size_t capacity = 3)
{
cout << "Stack(size_t capacity = 3)" << endl;
_a = (int*)malloc(sizeof(int) * capacity);
if (_a == nullptr)
{
perror("malloc fail");
return;
}
_capacity = capacity;
_top = 0;
}
深拷贝
Stack(const Stack&stt)
{
cout << "Stack(const Stack&stt)" << endl;
_a = (int*)malloc(sizeof(int) * stt._capacity);
if(_a == nullptr)
{
perror("malloc fail");
return;
}
_top = stt._top;
_capacity = stt._capacity;
memcpy(_a, stt._a, sizeof(int) * stt._top);
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
int* _a;
int _top;
int _capacity;
};
class Myqueque
{
Stack _push;
Stack _pop;
int _sz = 0;
};
int main()
{
Stack st;
Stack st1(st);
Myqueque q1;
Myqueque q2(q1);
}
队列又完成了拷贝构造，又是间接调用栈的深拷贝(拷贝构造)，真是躺着赢下了游戏。
栈写了拷贝构造——深拷贝 myqueque就能调用栈的拷贝构造。
总结
日期类不用写拷贝构造 使用编译器默认生成的就可以完成值拷贝——可以完成我们的需要
拷贝构造对内置类型完成默认的拷贝构造——浅拷贝
Date 和 MyQueue 默认生成拷贝就可以用
1、内置类型成员完成值拷贝
2、自定义类型成员调用这个成员的拷贝构造stack需要自己写拷贝构造，完成深拷贝。
顺序表、链表、二又树等等的类，都需要深拷贝。
注意: 类中如果没有涉及资源申请时，拷贝构造函数是否写都可以;一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用
尽量使用引用。
