本文主要是介绍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类的深浅拷贝,写时拷贝的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!