C++入门——类的默认成员函数（拷贝构造函数）

---

一、拷贝构造函数

如果⼀个构造函数的第⼀个参数是⾃⾝类类型的引⽤，且任何额外的参数都有默认值，则此构造函数也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数。
下面代码中的Date(const Date& d)就是拷贝构造函数

#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,1,1);
	
	Date d2(d1);
	return 0;
}

二、拷⻉构造的特点

• 1.拷⻉构造函数是构造函数的⼀个重载。
  关于函数的重载，请参考下面这篇文章
  函数重载
• 2.拷⻉构造函数的第⼀个参数必须是类类型对象的引⽤，使⽤传值⽅式编译器直接报错，因为语法逻辑上会引发⽆穷递归调⽤。 拷⻉构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引⽤，后⾯的参数必须有缺省值。

#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;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

• 下面我们来讨论为什么会进入无穷递归
• 3.C++规定，自定义类型（也就是类类型）在进行传值传参的时候必须调用拷贝构造。

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;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

void Func(Date d)
{

}

int main()
{
	Date d1;

	Func(d1);
	return 0;
}

• 在上面的代码中，我们定义了Func函数，形参是Date类型的d，也就是说要进行传值传参。
  我们在调用Func函数的时候，会先调用d1的拷贝构造函数（前提是我们的拷贝构造函数没问题），完成之后再调用Func函数。
  也就是下面这个过程：
  
• 如果不想调用拷贝构造，就需要传引用。
  

讲完这个前置知识，我们再回到我们的拷贝构造函数，如果是传值传参：

这里用const修饰的原因是涉及到权限的放大，不加有时候会报错。
关于const引用和权限放大参考这篇文章
C++入门——引用&

Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

下面两种方法都是调用拷贝构造函数：

int main()
{
 Date d1;
	//都是调用拷贝构造
	Date d2(d1);
	Date d3 = d1;

	return 0;
}

• 4.若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构造。
  那要不要写析构就是我们要讨论的一个问题了，来看下面的代码：

#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()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};


int main()
{
	Stack st1(10);
	Stack st2(st1);
	return 0;
}

我们在，main函数里面定义了st1，将st1拷贝给st2。在调试时，我们看下图好像并没有什么问题，st1里的全部成员变量值，都拷贝给了st2.


但是当程序运行结束时，就会崩溃。

我们来看，在浅拷贝的过程中，会将st1中变量保存的值，一个字节一个字节拷贝给st2。而在_a中保存的指针也会给st2中的_a。也就是说，st2的_a和st1的_a，指向的是同一块空间。这种情况下就会出现大问题。

比如我们对st1进行了入栈操作，此时st1._top变成1，但是st2._top依旧是0,那对st2进行入栈时就会覆盖掉st1._a的数据。（当然还有各种对栈的操作都会出现问题，这里不一一列举）
再比如，在程序结束进行析构时，也会对同一块空间析构两次（当然这是非法的，所以上面的程序崩溃了）。关于析构函数，不了解的朋友可以看下面的文章。
析构函数

所以就需要自己写拷贝构造

//拷贝构造函数
	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;
	}

• 5.像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现MyQueue的拷⻉构造。
  总结就是：如果⼀个类显⽰实现了析构并释放资源，那么他就需要显⽰写拷⻉构造，否则就不需要。

• 6.传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。

---

总结

以上就是今天要讲的内容，本文仅仅简单介绍了拷贝构造的特点，关于其他默认成员函数，请关注后续文章。