【C++】深拷贝和浅拷贝

目录

浅拷贝

 深拷贝

字符串的构造

例有两个类的深拷贝：

---

浅拷贝

在类中，若我们不写拷贝构造函数，则程序会提供一个默认的拷贝构造函数，该函数为浅拷贝。

   //默认拷贝构造 ---浅拷贝--值复制

类名(const 类名& 形参名)   {成员1= 形参名.成员1; }

class A
{
public:
	A(int i = 0, int j = 0) :m_i(i), m_j(j) {}//构造函数
	void print() { cout << m_i << "," << m_j << endl; }
private:
	int m_i;
	int m_j;
};
void main()
{
	A a(4, 7);
	A b(a);//使用默认拷贝构造函数
	a.print();//4，7
	b.print();//4，7
}

 

浅拷贝将一个对象的所有信息直接拷贝到另一个对象中，如果是值则拷贝值；如果是引用、指针则拷贝其内存地址，这时，两个对象的该成员共用一个地址。

由于对象最后都需要析构，若浅拷贝的对象中有指针，该地址在析构的时候将会进行两次（拷贝和被拷贝的对象每个一次），导致程序出错。

class A
{
public:
	A(int i = 0)
	{
		//m_i = new int(i);
		m_i = new int;
		*m_i = i;
	}
	~A()
	{
		if (m_i != NULL)
		{
			delete m_i;
			m_i = NULL;
		}

	}
	A(const A& a)  //默认拷贝构造 ---浅拷贝--值复制
	{
		m_i = a.m_i;  //两个对象的指针指向同一块内存单元
	}
	void print()
	{
		cout << *m_i << endl;
	}
private:
	int* m_i;
};
void main()
{
	A a(10);
	a.print();
	A b(a);  //调用默认拷贝构造，会导致b对象中的m_i和a对象中的m_i指向同一块内存空间
	b.print();
	//在即将退出时，调用析构会出问题，析构了两次
}

 深拷贝

如果有指针作为数据成员，则必须要写析构函数和拷贝构造函数，拷贝资源。

深拷贝中如果对象有申请动态内存，则深拷贝中也会新申请一个（属性拷贝），析构函数中释放空间。

class A
{
public:
	A(int i = 0)
	{
		m_i = new int;
		*m_i = i;
	}
	A(const A& a)  //深拷贝
	{
		m_i = new int;//开新空间
		*m_i = *(a.m_i);
	}
	~A()
	{
		delete m_i;
		m_i = NULL;
	}
	void print() { cout << *m_i << endl; }
private:
	int* m_i;
};
void main()
{
	A a(20);
	A b(a);
	a.print();//20
	b.print();//20
}

字符串的构造

strcpy拷贝所有字符串
strncpy拷贝n个字符串
memcpy  void*memcpy(void*dest,void*src,count)都可以拷贝

class STR
{
public:
	STR(const char* str)
	{
		m_str = new char[strlen(str) + 1];
		strcpy_s(m_str, strlen(str) + 1, str);
	}
	STR()//什么都不传入，拿一个\0占位
	{
		m_str = new char[1];
		m_str[0] = '\0';
	}
	STR(int n, char c)
	{
		m_str = new char[n + 1];
		memset(m_str, c, n);//strcpy只能拷贝字符串，memset什么都可以拷贝
		m_str[n] = '\0';
	}
	STR(const STR& s)//深拷贝
	{
		m_str = new char[strlen(s.m_str) + 1];
		strcpy_s(m_str, strlen(s.m_str) + 1, s.m_str);
	}
	~STR()//析构
	{
		if (m_str != NULL)
		{
			delete[]m_str;
			m_str = NULL;
		}
	}
	void print()
	{
		cout << m_str << endl;
	}
private:
	char* m_str;
};
void main()
{
	STR s1("12345");
	STR s2;
	STR s3(4, 'k');
	STR s4(s1);
	s1.print();
	s2.print();
	s3.print();
	s4.print();
}

如果成员是指针可以new大小（上方代码），但数组不能，只能依靠数组定大小截断（如下）

就是说指针需要先申请空间（申请需要放入的大小）再往里面放东西，而数组因为本身有大小所以直接放入数组能存的大小的内容。

class STR
{
public:
	STR(const char* str)
	{
		int n = sizeof(m_str);
		memcpy(m_str, str, n - 1);
		m_str[n - 1] = '\0';
	}
	void print()
	{
		cout << m_str << endl;
	}
private:
	char m_str[20];
};
void main()
{
	STR a("asdf");
	STR b("asdfasdfasdfasddfasdfasdfadfgsdfgsdfgsdfg");
	a.print();
	b.print();
}

例有两个类的深拷贝：

class Date
{
private:
	int m_year;
	int m_month;
	int m_day;
public:
	Date(int y, int m, int d) :m_year(y), m_month(y), m_day(d) {}
	void show()
	{
		cout << m_year << " /" << m_month << "/" << m_day << endl;
	}
	Date(const Date& d) :m_year(d.m_year), m_month(d.m_month), m_day(d.m_day)
	{
		cout << "Data(&)" << endl;
	}
};
class Student
{
private:
	int m_num;
	char* m_name;
	char m_sex;
	Date m_birthday;
public:
	Student(int num, const char* name, char sex, int y, int m, int d) :m_num(num), m_sex(sex), m_birthday(y, m, d)//没有默认值必须显示的调用构造函数
	{
		m_name = new char[strlen(name) + 1];
		strcpy_s(m_name, strlen(name) + 1, name);
	}
	void print()
	{
		cout << m_num << " " << m_name << " " << m_sex;
		m_birthday.show();
	}
	~Student()
	{
		if (m_name != NULL)
		{
			delete[]m_name;
			m_name = NULL;
		}
	}
	Student(const Student& s) :m_num(s.m_num), m_sex(s.m_sex), m_birthday(s.m_birthday) //调用Date类的拷贝构造
	{
		m_name = new char[strlen(s.m_name) + 1];
		strcpy_s(m_name, strlen(s.m_name) + 1, s.m_name);
	}
};

void main()
{
	Student s1(1001, "wangpangpang", 'm', 2000, 12, 24);
	Student s2(s1);
	s2.print();
	s1.print();
}