深拷贝和浅拷贝 发生的时间就是在赋值的时候
类似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;
}
此时完全分开 彼此不干扰了
也就是深拷贝是重新做内存 而浅拷贝是修改指针指向同一个内存