C++中拷贝构造函数解读_拷贝构造函数参数是多个对象-CSDN博客

本文链接：https://blog.csdn.net/m0_68553722/article/details/128396936

在c++中拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

1.我们在写拷贝构造函数时：拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

为什么不能用传值的方式将实参传递给形参，而必须用引用才能进行函数的拷贝？

class Date
{
public:

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

	//拷贝构造
    //Date(const 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;

};

int main()
{
	

	Date d1(2022, 11, 12);

	Date d2(d1);
	
	return 0;
}

在上面代码中如果我们使用错误的写法即：Date(const Date d)这是用值传参的方式来进行拷贝

导致下面的现象：

通过传值的方式将实参传递给形参，这中间本身就要经历一次对象的拷贝过程，而对象拷贝则必须调用拷贝构造函数，会一直无线循环的调用拷贝函数导致进入一个死循环。

2. 若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

语法中说：如果用户没有显示定义，则编译器会生成一份
实际情况：编译器不一定会生成，但是会完成拷贝的工作

（1）如下Date类的代码中，虽然我们没有写拷贝构造函数，但是编译器会自己进行完成拷贝，而且编译器也没有自己生成拷贝构造函数，而是按照字节方式直接拷贝的。

因为编译器的实现并不一定严格的按照语法的规范实现，编译器实现可能会考虑程序的运行效率构造方法：编译器感觉生成的构造方法没有实际意义，则不生成。

class Date
{
public:

	Date(int year = 1900, 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(2022, 11, 20);

	
	Date d2(d1);
	return 0;
}

（2）在下面代码中，编译器就会生成拷贝构造函数：

class Time
{
public:

	Time(int hour = 17, int minute = 30, int second = 25)
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}


	Time(const Time& t)
	{
		_hour = t._hour;
		_minute =t._minute;
		_second = t._second;
	}

	void Print()
	{
		cout << _hour << ":" << _minute << ":" << _second << endl;
	}


private:
	int _hour;
	int _minute;
	int _second;
};


class Date
{
public:

	Date(int year = 1900, 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;

	Time _t;
};

void TestDate()
{
	Date d1(2022, 11, 12);
	Date d2(d1);
	
	//里面_t的拷贝借助的是Time类的拷贝函数完成的
}

由于Date类的函数中，包含了_t，他是一个自定义类型的函数。

在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调
用其拷贝构造函数完成拷贝的。

3.类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构
造函数是一定要写的，否则就是浅拷贝。

typedef int DataType;

struct Stack
{
public:
	Stack()
	{
		_array = (DataType*)malloc(10 * sizeof(DataType));
		if (NULL == _array)
		{
			assert(false);
			return;
		}
		_capacity = 3;
		_size = 0;
		cout << "Stack():" << this << endl;

	}

	void Push(DataType data)
	{
		_array[_size] = data;
		++_size;
	}

	int Size()
	{
		return _size;
	}


	//析构函数
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
		cout << "~Stack():" << this << endl;
	}


private:
	void _checkCapacity();


private:
	DataType* _array;
	size_t _capacity;
	size_t _size;
};

void TestStack()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	

	Stack s2(s1);
	cout << s2.Size() << endl;

}

在上面代码中如果我们不去写拷贝构造函数，对于Stack就会出错，因为两个的对象最终使用的是同一份内存空间，因为当对象销毁时，同一份空间会被释放多次而引起程序崩溃。