1.String类，只给了构造函数和析构函数，拷贝构造函数和赋值运算符重载都是编译器合成。
class String
{
public:
String(const char* str = "")
{
if (NULL == str)
{
_str = new char[1];
_str = '\0';
}
else
{
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
}
~String()
{
if (_str != NULL)
{
delete _str;
_str = NULL;
}
}
private:
char* _str;
};
int main()
{
String s1;
String s2("123456");
String s3(s2);
s1 = s2;
return 0;
}上面的代码，在编译的时候没有错误，但是在程序运行时出现了错误。程序调用构造函数生成了对象s1，由于我们的构造函数为缺省构造函数，所以会开辟一段空间存放‘\0’。s2也调用构造函数生成对象s2，并有自己的内存存放着字符串“123456\0”。由于上面代码没有显式的拷贝构造函数定义和赋值运算符重载，所以s3通过编译器合成的拷贝构造函数，拷贝构造s2生成。s1赋值运算s2得到内容。编译器合成的赋值运算符重载，只是把s1的_str指向s2的空间，并没有释放和标记s1的空间，所以会导致s1的空间找不到，空间泄露了。
可以看到对象s1，s2，s3的内容都是“123456”
由于生成了3个对象，所以在程序结束时，编译器会自动调用析构函数。析构函数执行的是释放当前对象的空间，并把对象里的_str指针指向NULL。当调用析构函数时，首先析构s3，把对象s3中_str指向的内存释放，并指向为NULL。再析构s2时，想把s2中的_str指向的内存释放，这时出现了错误。
我们可以看到3个对象的_str都指向的同一块内存：
由于s3对象在析构的时候已经将该空间释放了，再在s2中释放时，已经无法释放。所以我们可以看到由编译器自己合成的赋值运算符重载，拷贝构造函数，只是把对象的值直接给了当前对象，并没有为当前对象另开辟空间。这时就出现了一块空间被多个对象使用。
这就是浅拷贝，一块空间被多个对象使用。当我们在调用析构函数时，如果不处理这种情况，就直接释放空间，就会导致程序崩溃。
2.解决浅拷贝方式一：普通版深拷贝
class String
{
public:
String(const char* str = "")
{
if (NULL == str)
{
_str = new char[1];
_str = '\0';
}
else
{
_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& operator=(const String& s)
{
if (&s != this)
{
if (_str)
delete _str;//释放原有空间
_str = new char[strlen(s._str) + 1];
strcpy(_str, s._str);
}
return *this;
}
~String()
{
if (_str != NULL)
{
delete _str;
_str = NULL;
}
}
private:
char* _str;
};
int main()
{
String s1;
String s2("123456");
String s3(s2);
s1 = s2;
return 0;
}String类深拷贝，自己显式的定义了，拷贝构造函数和赋值运算符重载。在调用拷贝构造函数和赋值运算符重载的时候，都开辟了自己的内存存放字符串。解决了浅拷贝时，多个对象共用同一块空间的问题，删除对象时，析构函数释放了对象自己的空间。
每个对象都有自己的空间：
调用析构函数，释放了自己的空间：
3.解决浅拷贝方式二：简介版的深拷贝
class String
{
public:
String(const char* str = "")
{
if (str == NULL)
{
_str = new char[1];
_str = '\0';
}
else
{
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
}
String(const String& s)
:_str(NULL) //一定要初始化，否则该对象和tmp交换_str的时候，
{ //tmp调用析构函数时找不到该对象原来_str所指向的地方
String tmp(s._str);
std::swap(_str, tmp._str);
}
String& operator=(String s)
{
std::swap(_str, s._str);
return *this;
}
~String()
{
if (_str != NULL)
{
delete _str;
_str = NULL;
}
}
private:
char* _str;
};
int main()
{
String s1;
String s2("123456");
String s3(s2);
s1 = s2;
return 0;
}简洁版的深拷贝，和普通版的深拷贝，都是解决浅拷贝多个对象共用一块空间的问题。
简洁版的深拷贝，在拷贝构造函数时，通过构造一个临时的对象，把s2的的值拷贝进去，通过交换临时对象和s3对象的_str的指向，实现了拷贝构造，同时s3和s2没有共用同一块空间。拷贝构造函数一定要对该对象的_str指针初始化，否则在交换后，临时变量tmp的_str将有指向不可访问的空间，导致程序崩溃。
简洁版的深拷贝，在赋值运算符重载时，参数就是一个通过拷贝构造的对象s,对象s的_str与该对象的_str交换指向。与普通的深拷贝比较，普通的深拷贝方式，先释放原有的空间，再新申请一个新空间，再拷贝。申请空间有可能失败，不安全。所以简洁版的这种方式比较安全与简洁。
4.解决浅拷贝方式问题：引用计数实现（浅拷贝）
1.使用非静态成员变量计数器，每个类都拥有独立的计数器，而在对象的拷贝和赋值时，需要修改计数器的值，对象计数器之间缺乏共通性。
2.使用静态成员变量，不同对象之间需要独立的内存块，还需要独立的计数器，缺乏了独立性。
3.使用成员指针，满足了共通性和独立性。
class String
{
public:
String(const char* str = "")
{
if (str == NULL)
{
_str = new char[1];
_str = '\0';
}
else
{
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
_pCount = new int[1];
(*_pCount) = 1;
}
String(const String& s)
{
_str = s._str;
_pCount = s._pCount;
(*(s._pCount))++;
}
String& operator=(const String& s)
{
if (&s != this)
{
if (*_pCount == 1)
{
delete _str;
delete _pCount;
}
_str = s._str;
_pCount = s._pCount;
(*(s._pCount))++;
}
return *this;
}
~String()
{
if ((_str != NULL)&&((--(*_pCount)) == 0))//判断是否为空，及引用计数是否为0
{
delete _str;
delete _pCount;
_pCount = NULL;
_str = NULL;
}
}
private:
char* _str;
//int _count;
// static int _count;
int *_pCount;
};
int main()
{
String s1;
String s2("123456");
String s3(s2);
s1 = s2;
system("pause");
return 0;
}使用引用计数，还需要为指针开辟空间，产生了大量的内存碎片，所以我们可以优化，使计数器和字符串存在同一块内存内。优化如下：
class String
{
public:
String(const char* str = "")
{
if (str == NULL)
{
_str = new char[4+1];//4个字节是开辟给计数器的
_str += 4; //把指针移到字符串开始的位置
*((int *)(_str - 4)) = 1;
_str = '\0';
}
else
{
_str = new char[strlen(str) + 1 + 4];
_str += 4;
*((int *)(_str - 4)) = 1;
strcpy(_str, str);
}
}
String(const String& s)
{
_str = s._str;
++(*((int *)(_str - 4)));
}
String& operator=(const String& s)
{
if (_str != s._str)
{
if (*((int *)(_str - 4)) == 1)
{
delete[](_str - 4);
}
_str = s._str;
++(*((int *)(_str - 4)));
}
return *this;
}
~String()
{
if (((*((int *)(_str - 4)))--) == 1)
{
delete[](_str - 4);
_str = NULL;
}
}
char& operator[](size_t index) //写时拷贝，如果改变一个对象的内容，再开辟另一块内存出来存放
{
if (*((int *)(_str - 4)) > 1)
{
char *tmp = new char[strlen(_str) + 1 + 4];
tmp += 4;
*((int *)(tmp - 4)) = 1;
strcpy(tmp, _str);
*((int *)(_str - 4)) -= 1;
_str = tmp;
}
return _str[index];
}
private:
char* _str;
//int _count;
// static int _count;
// int *_pCount;
};
int main()
{
String s1;
String s2("123456");
String s3(s2);
s1 = s2;
S1[3] = 'A';
system("pause");
return 0;
}
ps:最后实现的String类存在线程安全问题。为什么存在线程安全问题？
因为在线程中，每个线程都是时间片轮流切换的在运行。如果一个线程刚想通过拷贝s2生成对象s3，时间片刚好到调用拷贝构造函数，也传完了参。这时时间片完了，轮到了下一个线程，而这个线程却是析构s2，并运行完了，这时时间片轮到了第一个线程，继续接上次运行到的位置，这时就出现了错误，发现s2没有了。
以上就是我总结的string类，希望对正在学习C++深浅拷贝的有所帮助。