C++类与对象(二)——拷贝构造函数

前言

本章继续学习类的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.拷贝构造函数的特性

1. 拷贝构造函数是构造函数的重载
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.拷贝构造函数典型的使用场景

• 使用已存在对象创建新对象
• 函数参数类型为类类型对象
• 函数返回值类型为类类型对象

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用以用尽量使用引用。

---

本文到此结束，码文不易，还请多多支持哦！！