首先string的浅拷贝是让两个不同的指针指向同一块空间，而这在析构的时候会出现将一块空间释放两次，程序会崩溃，因此我们才需要进行深拷贝，即第二个指针开辟和第一个指针一样大小空间，然后将内容复制过去，不过深拷贝又分传统写法和现代写法，两者的区别主要在于拷贝构造和赋值运算符的重载上
第一种就是传统写法，拷贝构造和赋值的时候正常开辟空间，正常拷贝内容
class String
{
public:
String()//这是先给pstr开辟一个空间来存放'\0',注意'\0'的写法
:p(new char[1])
{
*p = '\0';\
}
//显示的给出 开辟空间时候加1是为了放'\0'
//也可以合起来写 改成String(char*p="")
String(char *pstr)
:p(new char[strlen(pstr)+1])
{
if (pstr == NULL)
{
p = new char[1];
*p = '\0';
}
else
{
p = new char[strlen(pstr) + 1];
strcpy(p, pstr);
}
}
//拷贝构造函数
String(const String &s)
{
p = new char[strlen(s.p) + 1];
strcpy(p, s.p);
}
//赋值运算符重载 注意四个问题
//1)返回值
//2)参数
//3)检测其是否给自身赋值
//4)返回为*this
String & operator = (const String &s)
{
if (this != &s)
{
char *tmp = new char[strlen(s.p) + 1];
strcpy(tmp, s.p);
delete []p;
p = tmp;
}
return *this;
}
//析构函数
~String()
{
if (p)
{
delete[] p;
}
}
private:
char *p;
};2 深拷贝的现代写法
现代写法构造函数和析构函数并没有改变，改变的是复制运算符重载，拷贝构造
先看这段实现代码，第一次我是这样写的，但是崩溃了。。。
String(const String &s)
{
String tmp(s.p);
std::swap(p, tmp.p);
}
//赋值运算符重载
String &operator=( String s)
{
std::swap(p, s.p);
return *this;
}
//另一种写法
String & operator=(const String &s)
{
if ( this != &s)
{
String tmp(s.p);
std::swap(p, tmp.p);
}
return *this;
}
看起来没毛病啊，所以这个时候可以单步进去跟踪一下看看程序到底是在哪里崩溃的。单步执行就会看到在拷贝构造的时候会出现下面的图情况，我们没有将_str的地址初始化，即访问了非法地址，但是这个时候还不会崩溃，而在交换之后，将它交换给tmp对象，在出了作用域之后tmp对象在析构的时候就会崩溃，因为是在释放非法内存空间。
因此，我们必须在使用之前在初始化的列表里面将_str置空，切记千万不能忘记了。
写到这突然想起来在写日期类的时候我写了一个这样的代码，
Date& operator=(const Date& d)
{
if (this != &d)
{
Date tmp(d);
std::swap(*this, tmp);
}
return *this;
}运行的时候会出现死循环，因为swap在交换的时候也是要创建临时变量，而自定义类型的创建又会调用拷贝构造，但是拷贝构造的时候有在创建临时变量，这样的话就会陷入无限的递归调用，最终栈溢出。
因此，在使用库函数swap进行交换的时候最好只去交换内置类型，对于自定义类型的类型，一定要自己去实现。
3.但是在有的时候我们并不需要每次都去开辟空间，拷贝数据，那么存不存在一种方法可以让我们一般情况下只实行浅拷贝，然后当我们需要改变新的空间的内容的时候，才会重新开辟空间呢？可以想到下面这些方法：
1）首先我们会想到增加一个类成员 int count，但是这样造成的后果是每一个成员都有一个不同的count 在析构的时候就很混乱还是会出错
2）然后呢我们会想到使用静态成员的办法，因为此时 static int count 是放在静态区，它是所有对象共享的，不会为每个对象单独生成一个count，可是当我们有三个不同的成员共同管理一块空间，而此时我们又用构造函数创建一个对象时候，count又会会变为1，所以这种方法还是不行 。
3）于是我们想到了引用计数，就是再创建对象的时候增加一个指针来存储当前有几个对象在管理_str 这块空间，代码实现如下：
class String
{
public：
String(char *pstr = "")
{
_pstr = new char[strlen(pstr) + 1];
strcpy(_pstr, pstr);
_pcount = new int(1);
}
String(const String &s)
:_pstr(s._pstr)
, _pcount(s._pcount)
{
GetCount()++;
}
String &operator=(const String& s)
{
//1.this指向空间引用计数为1，这时候减减它以后还要释放这块空间
//2.所指向的引用计数不为1，所以只用减减引用计数
if (this != &s)
{
this->Release();
_pstr = s._pstr;
_pcount = s._pcount;
GetCount()++;
}
return *this;
}
//为当前对象重新开辟空间拷贝数据并设置它的引用计数，然后返回这个地址
char& operator[](size_t index)
{
if (GetCount() > 1)
{
--GetCount();
char* tmp = new char[strlen(_pstr) + 1];
strcpy(tmp,_pstr);
_pstr = tmp;
_pcount = new int(1);
}
return _pstr[index];
}
~String()
{
assert(_pstr);
assert(_pcount);
this->Release();
}
int& GetCount()
{
return *(this->_pcount);
}
void Printf()
{
cout << this->_pstr;
}
void Release()
{
--GetCount();
if (GetCount() == 0)
{
delete[] _pstr;
_pstr = NULL;
delete _pcount;
_pcount = NULL;
}
}
private:
char* _pstr;
int* _pcount;
};
还有一种方式是在对象的头部加上四个字节存一个int型的整数来标记当前空间有几个指针在管理，类似于new[ ]的实现，代码和上面的很类似：
class String
{
public:
String(char* str = "")
{
if (str == NULL)
{
_str = new char[1 + 4];
*(int*)(_str) = 1;
_str += 4;
*_str = '\0';
}
else
{
_str = new char[strlen(str) + 5];
*(int*)_str = 1;
_str += 4;
strcpy(_str, str);
}
}
String(const String& s)
:_str(s._str)
{
++GetRef();
}
String &operator=(const String & s)
{
if (_str != s._str)
{
--GetRef();
ReduceRef();
}
else
{
_str = s._str;
}
return *this;
}
~String()
{
--GetRef();
ReduceRef();
}
//[]的重载 为了实现写时拷贝的数组[]下标形式的访问
char &operator[](size_t index)
{
if (GetRef() > 1)
{
--GetRef();
char* tmp = new char(strlen(_str) + 1 + 4);
*(int*)tmp = 1;
tmp += 4;
strcpy(tmp, _str);
_str = tmp;
}
return _str[index];
}
public:
int& GetRef()
{
return *(int*)(_str-4);
}
void ReduceRef()
{
if (0 == --GetRef())
{
_str += 4;
delete[]_str;
_str = NULL;
}
}
void Printf()
{
cout << this->_str << endl ;
}
private:
char* _str;
};