关于深拷贝和浅拷贝

深拷贝和浅拷贝的认识：
浅拷贝：就是被拷贝对象和拷贝对象公用同一块空间，即两个对象的指针指向同一块空间。
深拷贝：就是被拷贝对象和拷贝对象有各自的空间，拷贝对象将新开辟一块空间，再将被拷贝对象拷贝下来。


下面是关于深拷贝和浅拷贝的实现
class String
{
public:
//传统写法
String& operator=(const String& s)   //运算符的重载   
{
if (this != &s)
{
/*delete[] _str;    //先将_str释放，然后开辟空间，再拷贝
_str = new char[strlen(s._str) + 1];
strcpy(_str, s._str);*/

char* tmp = new char[strlen(s._str) + 1];
strcpy(tmp, s._str); //先用临时对象tmp开辟空间，在将字符串拷贝到
delete[] _str;      tmp;然后释放_str,最后在将tmp地址赋值给_str
_str = tmp;   
}

return *this;

}
 
String(char* str = "")    //构造函数
:_str(new char[strlen(str) + 1])
{
strcpy(_str, str);
}

   
String(const String& s)     //拷贝构造函数
:_str(new char[strlen(s._str) + 1])
{
strcpy(_str, s._str);
}

~String()        //析构函数
{
if (_str)    //如果_str不为空，就用将_str释放
{
delete[] _str;
}
}

//现代写法

String(const String& s)    //拷贝构造函数
:_str(NULL)
{
String tmp(s._str);  //开辟临时对象,在将字符串拷贝到临时对象tmp
swap(_str, tmp._str); //交换_str和tmp._str指针值，此时tmp指向NULL
                           而_str指向字符串
}
     

String& operator=(const String& s)      //运算符的重载
{
if (&s != this)
{
String tmp(s._str);    //方法同上
swap(_str, tmp._str);
}

return *this;
}

String& operator=(String s)      //运算符的重载优化
{
swap(_str, s._str);  //对上面函数就行了优化，传入对象过程中就进行了拷贝
                           所以直接交换指针值就可以了
return *this;
}

private:

char * _str;

};