C++ 拷贝构造函数与赋值的区别

目录

• 拷贝构造函数
• 拷贝构造函数的使用方法
• 拷贝构造函数与赋值运算符的区别
• 谈深拷贝和浅拷贝
• 浅拷贝
• 注意:
• 深拷贝

拷贝构造函数

拷贝构造函数的也是一种构造函数,它的作用是将一个类的成员拷贝到另一个类中,类似于赋值。拷贝构造函数分为深拷贝和浅拷贝。

先来定义一个拷贝构造函数(构造函数可以重载),看招:

#include<IOStream>
using namespace std;
class date
{
public:
	date(int year=0, int month=0, int day=0)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	date(const date& d)//拷贝构造函数
	{
		this->_year = d._year;
		编程客栈this->_month = d._month;
		this->_day = d._day;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

 将一个类拷贝到另一个类中,自然是需要对应的参数的,参数就是类,这里可以传递指针,引用更好,只是传值形参的话,会造成无限递归。

拷贝构造函数的使用方法

拷贝构造函数的使用:

1.使用();2.使用'=';像这样

拷贝构造函数与赋值运算符的区别

那么拷贝构造函数和赋值运算符有什么区别呢,先来看一段代码对比一下：

int main()
{
	date d1(20244, 4, 24);
	date d2=d1;
	date d3;
	d3= d1;//编译器会自动将其转化为d3(d1);
	return 0;
}

这里d2采用的拷贝构造函数的方式,d3采用赋值的方式,通过观察,我们可以发现,前者是创造变量时就对类进行了赋值,这个赋值叫做初始化,而后者是先定义好的类,后续赋值,在赋值之前是已经将变量创建好的；

谈深拷贝和浅拷贝

先说浅拷贝

浅拷贝

浅拷贝就是对成员变量进行一一对应赋值,来看一个代码:

#include<iostream>
using namespace std;
class date
{
public:
	date(int a=1,int b=1)
	{
		_a = a;
		_b = b;
	}
	date(const date& d)
	{
		_a = d._a;//成员变量简单的赋值
		_b = d._b;
	}
	void print()
	{
		cout << _a << ',' << _b << endl;
	}
	~date()
	{
		coutwww.devze.com << "~date" << endl;
	}
private:
	int _a;
	int _b;
};


int main()
{
	date d1(2,5);
	date d2(d1);
	d2.print();
	return 0;
}

 在这个代码中,在对d2进行初始化的时候,是将d1的成员变量对d进行了赋值;最后代码结束存在两次析构,分别是d2和d1的;

注意:

对于简单的成员变量进行简单的复制操作并无大碍,但是如果是指针类型的变量就会出现问题;看代码；

#include<iostream>
using namespace std;
class date
{
public:
	date(int b=1)
	{
		_a =new int[4];
		_b = b;
	}
	date(const date& d)
	{
		_a = d._a;
		_b = d._b;
	}
	void print()
	{
		cout << _a << ',' << _b << endl;
	}
	~date()
	{
		free(_a);//拷贝后两个成员变量都指向同一块空间,会造成多次析构
		cout << "~date" << endl;
	}
private:
	int* _a;
	intYbqHS _b;
};


int main()
{
	date d1(5);
	date d2(d1);
	d2.print();
	return 0;
}

代码中_a为指针类型,初始化是对其进行开辟空间;代码结束对类进行析构,但是问题来了,浅拷贝只是简单的赋值,针对_a来说,d1和d2的_a都指向同一片空间,这就造成了在代码结束时,这片空间会释放两次,就会发生错误,对此就需要进行深拷贝来解决。 

深拷贝

#include<iostream>
using namespace std;
class date
{
public:
	date(int b=1)
	{
		_a =new int[4];
		_a[0] = 10;
		_b = b;
	}
	date(const date& d)
	{
		_a = new int[4];
		memcpy(_a, d._a, sizeof(int) * 4);//将d2的数据拷贝过来
		_b = d._b;
	}
	void print()
	{
		cout << _a[0] << ',' << _b &lwww.devze.comt;< endl;
	}
	~date()
	{
		free(_a);
		cout << "~date" << endl;
	}
private:
	int* _a;
	int _b;
};


int main()
{
	date d1(5);
	date d2python(d1);
	d2.print();
	return 0;
}

在拷贝构造的时候对本类的_a也进行开辟空间,然后把另一类的数据利用memcpy拷贝过来就OK了。 这样就不会出现析构多次同一片空间的问题。

到此这篇关于C++ 拷贝构造函数与赋值的区别的文章就介绍到这了,更多相关C++ 拷贝构造函数与赋值内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！