深拷贝与浅拷贝
简单的来说,浅拷贝是增加了一个指针,指向原来已经存在的内存。而深拷贝是增加了一个指针,并新开辟了一块空间让指针指向这块新开辟的空间。
浅拷贝在多个对象指向一块空间的时候,释放一个空间会导致其他对象所使用的空间也被释放了,再次释放便会出现错误。
浅拷贝
为了形象化说明什么是深拷贝和浅拷贝,我们就先写一个String类(包含构造函数、拷贝构造函数、赋值运算符重载、析构函数和输出操作符"<<"的重载)。
class String
{
public:
String(const char *p = "") //构造函数
{
if(p == NULL)
{
p = new char[1];
*p = '\0';
}
else
{
pstr = new char[strlen(pStr)+1]; //加1,存放'\0'
strcpy(pstr, p); //用拷贝字符串的函数
}
}
String(const String &s) : pstr(s.pstr)//拷贝构造函数,浅拷贝指向同一块空间,可能造成释放的错误,这是浅拷贝的缺点
{}
String& operator=(const String &s) //=运算符重载
{
if(this != &s)
{
delete[] pstr; //将原来所指向的空间释放
pstr = s.pstr; //让pstr重新指向s的pstr所指向的空间(也会导致错误)
}
return *this;
}
~String() //析构函数
{
if(NULL != pstr)
{
delete[] pstr; //释放指针所指向的内容
pstr = NULL; //将指针置为空
}
}
friend ostream&operator<<(ostream & _cout,const String &s) //<<运算符重载
{
_cout<<s.pstr;
return _cout;
}
private:
char *pstr;
};
经过测试之后,在某种情况下是可以正常运行的,在特定情况下是不可以正常的运行的。
int main()
{
String s1("sss");
String s2(s1);
String s3(NULL);
s3 = s1;
cout<<s1<<endl;
cout<<s2<<endl;
cout<<s3<<endl;
return 0;
}
在该例子中,我们有三个String类的对象,s1调用【构造函数】存入字符"sss",s2调用【拷贝构造函数】来利用s1进行初始化,s3则用【赋值运算符】来进行初始化。
接下来看一下析构函数:
~String()
{
if (pstr != NULL)
{
delete[] pstr;
pstr = NULL;
}
}
由于s1、s2、s3都指向同一块空间。
当我们释放s3的时候,可以正常释放,然而当释放s2的时候,由于s3已经释放过了,所以s2所指向的这段空间已经不属于s1或者s2了。
此时我们调用delete释放的时候,必然会崩溃。
深拷贝
深拷贝和浅拷贝的不同之处,仅仅在于修改了拷贝构造函数,以及赋值运算符的重载。
String(const String &s) : pstr(new char[strlen(s.pstr)+1])
{
strcpy(pstr, s.pstr);
}
/* 浅拷贝
String(const String &s) : pstr(s.pstr)//拷贝构造函数,浅拷贝指向同一块空间,可能造成释放的错误,这是浅拷贝的缺点
{}
*/
String& operator=(const String &s)
{
if(this != &s)
{
char* tmp = new char[strlen(s.pstr)+1]; //动态开辟一个临时变量,然后将pstr指向这一个新的临时变量里
delete[] pstr; //将原来的空间进行释放
strcpy(tmp,s.pstr); //将s.pstr里的内容复制到临时变量中
pstr = tmp; //pstr指向临时变量的这段空间
}
return *this;
}
/* 浅拷贝
String& operator=(const String&s)
{
if(this != &s)
{
delete[] pstr;//将原来所指向的空间释放
pstr = s.pstr;//让pstr重新指向s的pstr所指向的空间(也会导致错误)
}
return *this;
}
*/
深拷贝增加了一个指针指向新开辟了一块空间,使用的时候需要注意内存泄漏问题。