C++基础语法篇五 ——类和对象

拷贝构造函数

如果一个构造函数的第⼀个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造是⼀个特殊的构造函数。

拷贝构造的特点：

拷贝构造函数是构造函数的⼀个重载。
拷贝构造函数的第⼀个参数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用。拷贝构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引用，后面的参数必须有缺省值。
C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。
若未显式定义拷贝构造，编译器会生成自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。
像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，所以不需要我们显示实现拷贝构造。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的拷贝构造会调用Stack的拷贝构造，也不需要我们显示实现MyQueue的拷贝构造。这里还有⼀个小技巧，如果⼀个类显示实现了析构并释放资源，那么他就需要显示写拷贝构造，否则就不需要。
传值返回会产生⼀个临时对象调用拷贝构造，传值引用返回，返回的是返回对象的别名(引用)，没有产生拷贝。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这时的引用相当于⼀个野引用，类似⼀个野指针⼀样。传引用返回可以减少拷贝，但是⼀定要确保返回对象，在当前函数结束后还在，才能用引用返回。

来看我们在调用拷贝函数的时候，传值传参是一种拷贝行为，传过去之后，调用拷贝函数，在调用的时候，又要传值传参，还要调用拷贝函数，就不返回了，一直死递归。所以我们要引用接收。

代码：

cpp 复制代码

 #include<iostream>
 using namespace std;

 class Date
 {
 public:
 Date(int year = 1, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }

 // 编译报错：error C2652: "Date": ⾮法的复制构造函数: 第⼀个参数不应是"Date"
 //Date(Date d)
 Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._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;
};


void Func1(Date d)
{
cout << &d << endl;
d.Print();
}
// Date Func2()
Date& Func2()
{
Date tmp(2024, 7, 5);
tmp.Print();
return tmp;
}

int main()
{
Date d1(2024, 7, 5);
// C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥传值传参要调⽤拷⻉
构造
// 所以这⾥的d1传值传参给d要调⽤拷⻉构造完成拷⻉，传引⽤传参可以减少这⾥的拷⻉
Func1(d1);//传参会调用拷贝构造，拷贝完成后在调用Func1函数。
cout << &d1 << endl;

Date d2(&d1);// 这⾥可以完成拷⻉，但是不是拷⻉构造，只是⼀个普通的构造,因为他是指针接收的
d1.Print();
d2.Print();
//这样写才是拷⻉构造，通过同类型的对象初始化构造，⽽不是指针
Date d3(d1);
d2.Print();
// 也可以这样写，这⾥也是拷⻉构造
Date d4 = d1;
d2.Print();

Date ret = Func2();// Func2返回了⼀个局部对象tmp的引⽤作为返回值
// Func2函数结束，tmp对象就销毁了，相当于了⼀个野引⽤
ret.Print();
return 0;
}

深拷贝与浅拷贝

浅拷贝就是Date类中不用向其他内存区域申请额外空间，一般就像给对象的成员变量赋值（内置类型），栈帧结束后就自动销毁了，也不用析构。自定义类型对调用他们的拷贝构造。但是一旦给内置类型成员变量申请空间，就需要深拷贝了。那就有讲究了！

代码：

cpp 复制代码

#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;
};
// 两个Stack实现队列
class MyQueue
{
public:
private:
Stack pushst;
Stack popst;
};
int main()
{
Stack st1;
st1.Push(1);
st1.Push(2);
// Stack不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉

Stack st2 = st1;// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃
//这里说一下为什莫会崩溃，因为他们用到是同一个地址空间,所以在对数据进行一些操作会出问题！
MyQueue mq1;
// MyQueue⾃动⽣成的拷⻉构造，会⾃动调⽤Stack拷⻉构造完成pushst/popst
// 的拷⻉，只要Stack拷⻉构造⾃⼰实现了深拷⻉，他就没问题
MyQueue mq2 = mq1;
return 0;
}

结论：深拷贝必须要我们自己完成，编译器给我们的默认拷贝构造功能不是我们想要的，我们必须自己实现！