博客

深拷贝和浅拷贝 发生的时间就是在赋值的时候

类似int A;int B; A=B 的时候

我们已经知道在C语言的时候 操作char *需要memcpy strcpy这样的函数不能直接等

但是结构体呢？这个时候你用memcpy就是深拷贝 而你用=就是浅拷贝

系统默认的就是浅拷贝

你要自己深拷贝的话 就自己写 拷贝构造函数 他是构造函数中的 一员 就在赋值时候调用 用一个去初始化另外一个

开始测试

准备一个基础的代码：

#include <iostream>
using namespace std;
class Person {
public:
	void setAge(int a) { age = a; }
	void setName(char *n) { name = n; }
private:
	int age;
	char *name;

};
int main()
{
	Person tom;
	tom.setAge(20);
	char c[10] = { "TOM" };
	tom.setName(c);



	system("pause");
	return 0;
}

#include <iostream>
using namespace std;
class Person {
public:
	void setAge(int a) { age = a; }
	void setName(char *n) { name = n; }
private:
	int age;
	char *name;

};
int main()
{
	Person tom;
	tom.setAge(20);
	char c[10] = { "TOM" };
	tom.setName(c);

	Person Jack = tom;//默认拷贝构造函数--浅拷贝

	unsigned int *t = (unsigned int *)&tom;
	unsigned int *j = (unsigned int *)&Jack;

	//通过内存去看数据 地址通过unsigned int转化去拿 一个是int age 后面+1就是string的name
	printf("*t=%d\n", *t);//20
	printf("*(t+1)=%s\n", *(t + 1));//tom
	printf("*j=%d\n", *j);//20
	printf("*(j+1)=%s\n", *(j + 1));//tom

	//继续看地址！
	printf("c     =%p\n", c);
	printf("*(t+1)=%p\n", *(t + 1));
	printf("*(j+1)=%p\n", *(j + 1));
	/*
	*t=20
*(t+1)=TOM
*j=20
*(j+1)=TOM
c     =0058FBC0
*(t+1)=0058FBC0
*(j+1)=0058FBC0
	*/
	system("pause");
	return 0;
}

他的效果可以证明 这就是浅拷贝 tom jack都是执行的数组的地址 一旦数组变化 tom jack都变化

下面开始自己深拷贝  源码就太简单了 不要用char *表示name 那怎么做？？？？

用数组吗？？？

NO!

用C++的操作

*t=10
*(t+1)=TOM
*j=10
*(j+1)=TOM
*(t+1)=01032C50
*(j+1)=01032D10
c=00BBF730



#include <iostream>
using namespace std;
class Person {
public:
	void setAge(int a) { age = a; }
	void setName(char *n) { name = n; }

	Person(int a, char *n)
	{
		age = a;
		if (NULL == n)
		{
			name = new char[1];
			name[0] = '\0';
		}
		else
		{
			name = new char[strlen(n)+1];
			memcpy(name,n,strlen(n)+1);
		}
	}
	~Person() {
		delete[]name;
	}
	Person(const Person &orga)
	{
		age = orga.age;
		name = new char[strlen(orga.name) + 1];
		memcpy(name, orga.name, strlen(orga.name) + 1);
	}

private:
	int age;
	char *name;

};
int main()
{
	char c[10] = { "TOM" };
	Person tom(10,c);

	//Person Jack(tom);//拷贝构造函数--深拷贝Person(const Person &orga)
	Person Jack = tom;//拷贝构造函数--深拷贝Person(const Person &orga)
	unsigned int *t = (unsigned int *)&tom;
	unsigned int *j = (unsigned int *)&Jack;

	//通过内存去看数据 地址通过unsigned int转化去拿 一个是int age 后面+1就是string的name
	printf("*t=%d\n",     *t);//20
	printf("*(t+1)=%s\n", *(t+1));//tom
	printf("*j=%d\n",     *j);//20
	printf("*(j+1)=%s\n", *(j + 1));//tom

	//继续看地址！

	printf("*(t+1)=%p\n", *(t + 1));
	printf("*(j+1)=%p\n", *(j + 1));
	printf("c=%p\n",       c);
	system("pause");
	return 0;
}

此时完全分开 彼此不干扰了

也就是深拷贝是重新做内存 而浅拷贝是修改指针指向同一个内存