C++之深、浅拷贝

先给出一段程序：

void fun()
{
int *pTest1 = new int[10];
int *pTest2 = pTest1;
delete[] pTest1;
delete[] pTest2;
}
int main()
{
fun();
return 0;
}

以上程序运行会崩溃，由于简单的“ = ”只能将pTest1和pTest2指向同一块空间，没有给pTest2开辟新的空间，所以，在delete对象时，该空间被释放了两次，因此，程序崩溃。

在类中，更容易出现这种情况，例如以下程序：

class String
{
public:
String(const char * pData = "")
: _pData(new char[strlen(pData) + 1])
{
strcpy(_pData, pData);
}
String(const String& _string)
{
if (this != &_string)
{
_pData = _string._pData;
}
}
~String()
{
if (NULL != _pData)
{
delete[] _pData;
_pData = NULL;
}
}
private:
char *_pData;
};
void FunTest()
{
String s1;
String s2("hallo world");
String s3(s2);
}
int main()
{
FunTest();
}

程序运行后，会出现崩溃。分析FunTest函数：

String s1:调用构造函数，由于没有参数，在构造函数内有缺省参数，所以，将S1的_pData赋为空。

String s2("hallo world"):调用构造函数，给_pData分配空间，将形参的内容拷贝到_pData中。

String s3(s2):调用拷贝构造函数，将s3的_pData指向形参的_pData,即s3._pData指向s2._pData。所以，两个指向的是同一块空间。

当程序继续往下执行时，局部变量s3被析构，调用析构函数，将s3._pData所指向的空间释放，并将s3._pData赋为NULL。当s2被析构，调用析构函数，因为s2._pData一直指向申请空间，s2._pData不为空，现在又要去释放已经被s3._pData释放的空间，所以会出现问题。

当类里面有指针对象时，拷贝构造和赋值运算符重载只进行值拷贝(浅拷贝)，两个对象指向同一块内存，对象销毁时该空间被释放了两次，因此程序崩溃！

        String s3(s2);
        String s4=s3;

浅拷贝：编译器只是直接将指针的值拷贝过来，结果多个对象共用同一块内存，当一个对象将这块内存释放掉之后，另一些对象不知道该块空间已经还给了系统，以为还有效，所以在对这段内存进行操作的时候，发生了访问违规。

要想解决这一问题，就得进行深拷贝，也就是在拷贝构造函数和赋值运算符重载的实现时，申请新的空间，并把要拷贝的对象的值复制一份放入新开辟的空间中，例如以下程序：

class String
{
public:
char* _pstr;
public:
String(char* pstr="")
{
if (pstr == NULL)
{
            _pstr = new char[1];
*_pstr = '\0';
}
else
{
_pstr = new char[strlen(pstr) + 1];
strcpy(_pstr,pstr);
}
}
String(const String&s)
{
_pstr = new char[strlen(s._pstr) + 1];
strcpy(_pstr, s._pstr);
}
String& operator = (const String& s)
{
if (this != &s)
{
char *pstr = new char[strlen(s._pstr) + 1];
strcpy(pstr, s._pstr);
delete[] _pstr;
_pstr = pstr;
}
return *this;
}
};<pre name="code" class="cpp">int main()
{
String s1("hallo world");
cout << s1._pstr << endl;
String s2(s1);
cout << s2._pstr << endl;
String s3 = s2;
cout << s3._pstr << endl;
return 0;
}

在这个程序之中，拷贝构造函数和赋值运算符重载都分配了新的空间，并拷贝了值，这样使得在对象使用完成后进行析构时，不会多次析构一个空间而出现错误，s1、s2、s3各都指向自己的数据块，析构时，释放各自的空间。这也就是深拷贝。

秒客网

C++之深、浅拷贝

相关文章