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