如果⼀个构造函数的第⼀个参数是⾃⾝类类型的引⽤(只要求是第一个),且任何额外的参数都有默认值(缺省值),则此构造函数也叫做拷⻉构造函数,也就是说拷⻉构造是⼀个特殊的构造函数
1. 拷⻉构造函数是构造函数的⼀个重载;
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//拷贝函数
//第一的参数:类类型的引用
//Date(const Date& d , int x = 0)//其他的一定要是默认值/缺省值,但一般不用
//Date(const Date)//使用传值方式编译器会报错
Date(const 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, 7, 16);
d1.Print();
//用d1拷贝d2
//调用的就是拷贝构造
Date d2(d1);
d2.Print();
return 0;
}
2. 拷⻉构造函数的第一个参数必须是类类型对象的引⽤(因为要完成当前对象的拷贝),使⽤传值⽅式编译器直接报错,因为语法逻辑上会引发⽆穷递归调⽤;
3. 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;
}
Date(const 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;
};
//为什么必须是引用?
void Func1(Date d)
{
cout << &d << endl;
d.Print();
}
int main()
{
Date d1(2024, 7, 16);
d1.Print();
//C++规定传值传参要调用拷贝构造函数,C语言传直接按字节拷贝过去了
Func1(d1);//调试发现,按F11并没有跳到Func1函数中,而是跳到了拷贝构造函数中,再跳到Func,本质是调用了两个函数
}
调试图像演示:
因为传参会构成一个新的拷贝构造,这也就是为什么拷贝构造函数不可以以传值方式构造,而是要用引用 :因为用传值方式构造会导致无限递归。
图解:
用引用的话,d是d1的别名,所以传参的时候不会形成新的拷贝构造
4. 若未显式定义拷⻉构造,编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型(构造函数:(初始化不确定)和析构函数:(不处理)对内置类型是不做处理的)成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉),对⾃定义类型成员变量会调⽤他的拷⻉构造;(内置类型拷贝构造也管)
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_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;
int _month;
int _day;
};
int main()
{
//⾃动⽣成的拷⻉构造对内置类型成员变量会完成值拷⻉/浅拷⻉
//照样可以拷贝
Date d1(2024, 7, 17);
d1.Print();
Date d2(d1);
d2.Print();
//2024 / 7 / 17
//2024 / 7 / 17
return 0;
}
5. 像Date这样的类成员变量全是内置类型且没有指向什么资源,编译器⾃动⽣成的拷⻉构造就可以完成需要的拷⻉,所以不需要我们显⽰实现拷⻉构造。像Stack这样的类,虽然也都是内置类型, 但是_a指向了资源,编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求,所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)(也就是深拷贝) 。像MyQueue这样的类型内部主要是⾃定义类型Stack成员,编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造,也不需要我们显⽰实现MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧,如果⼀个类显⽰实现了析构并释放资源,那么他就需要显⽰写拷⻉构造,否则就不需要;
浅拷贝(编译器自动生成的)案例:
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a)
{
perror("malloc申请空间失败");
return;
}
_capacity = n;
_top = 0;
}
void Push(STDataType x)
{
if (_top == _capacity)
{
int newcapacity = _capacity * 2;
STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
_a = tmp;
_capacity = newcapacity;
}
_a[_top++] = x;
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};
int main()
{
Stack st1;
st1.Push(1);
st1.Push(2);
// Stack不显⽰实现拷⻉构造,⽤⾃动⽣成的拷⻉构造完成浅拷⻉
// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源,析构时会析构两次,程序崩溃
Stack st2(st1);
//Stack st3 = st1;//拷贝构造也可以这么写
return 0;
}
通过调试:
发现问题:
解决问题:
在public下,自己写一个拷贝构造:
Stack(const Stack& st)
{
// 需要对_a指向资源创建同样⼤的资源再拷⻉值
_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
if (nullptr == _a)
{
perror("malloc申请空间失败!!!");
return;
}
memcpy(_a, st._a, sizeof(STDataType) * st._top);
_top = st._top;
_capacity = st._capacity;
}
引用的好处:(体现):
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a)
{
perror("malloc申请空间失败");
return;
}
_capacity = n;
_top = 0;
}
Stack(const Stack& st)
{
// 需要对_a指向资源创建同样⼤的资源再拷⻉值
_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
if (nullptr == _a)
{
perror("malloc申请空间失败!!!");
return;
}
memcpy(_a, st._a, sizeof(STDataType) * st._top);
_top = st._top;
_capacity = st._capacity;
}
void Push(STDataType x)
{
if (_top == _capacity)
{
int newcapacity = _capacity * 2;
STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
_a = tmp;
_capacity = newcapacity;
}
_a[_top++] = x;
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};
void Func(Stack st)
{
}
int main()
{
Stack st1;
st1.Push(1);
st1.Push(2);
Func(st1);//这样是不行的,这时候st是st1的深拷贝,st的改变不会影响st1,另一个层度警示我们:自定义类型用传值传参不好,尽可能用引用,不改变时用const引用
// Stack不显⽰实现拷⻉构造,⽤⾃动⽣成的拷⻉构造完成浅拷⻉
// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源,析构时会析构两次,程序崩溃
//Stack st2(st1);
return 0;
}
6. 传值返回会产⽣⼀个临时对象调⽤拷⻉构造,传值引⽤返回,返回的是返回对象的别名(引⽤),没有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象,函数结束就销毁了,那么使⽤引⽤返回是有问题的,这时的引⽤相当于⼀个野引⽤,类似⼀个野指针⼀样。传引⽤返回可以减少拷⻉,但是⼀定要确保返回对象,在当前函数结束后还在,才能⽤引⽤返回;
传值返回:
传引用返回:
从栈帧上理解:
确保出了作用域,st还在:传引用返回还减少了拷贝
Stack& func2()
{
static Stack st;//这时候是静态对象,全局对象了
return st;
}
int main()
{
Stack ret = func2();
return 0;
}
还可以:
Stack func2(Stack& st)
{
st.Push(1);
st.Push(1);
st.Push(1);
return st;
}
int main()
{
Stack st1;
func2(st1);
return 0;
}
可以在拷贝构造函数中添加一行代码,进行更好的观察:没有调用拷贝构造:
cout << "Stack(const Stack& st)" << endl;//检验是否调用拷贝构造