C++中String类的深浅拷贝，写时拷贝

本文主要是介绍C++中String类的深浅拷贝，写时拷贝，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1.string传统拷贝
2.string现代拷贝
3.string计数拷贝
4.string写时拷贝

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;
}

4.string写时拷贝
使用引用计数，还需要为指针开辟空间，产生了大量的内存碎片，所以我们可以优化，使计数器和字符串存在同一块内存内。优化如下：

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++深浅拷贝的有所帮助。

这篇关于C++中String类的深浅拷贝，写时拷贝的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---