1.经典的string类问题
上面已经对string类进行了简单的介绍,大家只要能够正常使用即可。在面试中,面试官总喜欢让 学生自己来模拟实现string类,最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析 构函数。大家看下以下string类的实现是否有问题?
class String
{
public:
/*String()
:_str(new char[1])
{*_str = '\0';}
*/
//String(const char* str = "\0") 错误示范
//String(const char* str = nullptr) 错误示范
String(const char* str = "")
{
// 构造String类对象时,如果传递nullptr指针,可以认为程序非
if (nullptr == str)
{
assert(false);
return;
}
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
~String()
{
if (_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};
// 测试
void TestString()
{
String s1("hello bit!!!");
String s2(s1);
}
说明:上述String类没有显式定义其拷贝构造函数与赋值运算符重载,此时编译器会合成默认 的,当用s1构造s2时,编译器会调用默认的拷贝构造。最终导致的问题是,s1、s2共用同一块内 存空间,在释放时同一块空间被释放多次而引起程序崩溃,这种拷贝方式,称为浅拷贝。
1.2 浅拷贝
浅拷贝:也称位拷贝,编译器只是将对象中的值拷贝过来。如果对象中管理资源,最后就会导致 多个对象共享同一份资源,当一个对象销毁时就会将该资源释放掉,而此时另一些对象不知道该 资源已经被释放,以为还有效,所以当继续对资源进项操作时,就会发生发生了访问违规。
可以采用深拷贝解决浅拷贝问题,即:每个对象都有一份独立的资源,不要和其他对象共享。
1.3 深拷贝
同时引入深赋值
/*方法一: string的传统版实现*/
namespace bit
{
class string
{
public:
//构造函数
string(const char* str = "")
{
// 构造string类对象时,如果传递nullptr指针,认为程序非法,此处断言下
if (nullptr == str)
{
assert(false);
return;
}
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
//拷贝构造函数
string(const string& s)
: _str(new char[strlen(s._str) + 1])
{
strcpy(_str, s._str);
}
//赋值语句 初级阶段的实现,如果考虑异常安全,可以参考剑指offer一书的面试题1
string& operator=(const string& s)
{
if (this != &s)
{
delete[]_str;
_str = new char[strlen(s._str) + 1];
strcpy(_str, s._str);
}
return *this;
}
//析构函数
~string()
{
delete[]_str;
_str = nullptr;
}
private:
char* _str;
};
}
/*方法二: String的临时对象交换现代版*/
namespace bit
{
class string
{
public:
//构造函数 考虑str为空的情形
string(const char* str = "")
{
// 构造string类对象时,如果传递nullptr指针,认为程序非法,此处断言下
if (nullptr == str)
{
assert(0);
return;
}
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
//拷贝构造函数 通过临时对象的交换方式进行拷贝构造,构造对象借助之前实现的普通构造函数来构造 //对象,然后通过交换对象的内部指针的指向,从而达到拷贝构造对象,好处就是如果出错,其根本就是 //构造函数的错误,我们相当于把错误最终归结为构造函数
string(const string& s)
: _str(nullptr)
{
string strTmp(s._str);
swap(_str, strTmp._str);
}
//赋值语句 通过临时对象的交换方式进行实现,
//如果考虑异常安全,可以参考剑指offer一书的面试题1
//这种交换方式在赋值语句中,有利于预防内存泄漏,因为交换完成的临时对象,一旦生存作用域结
//束,就会自动调用其析构函数,释放对应的资源
string& operator=(const string& s)
{
if (this != &s)
{
string strTmp(s);
swap(_str, strTmp._str);
}
return *this;
}
//析构函数,当_str不为空时才进行释放工作并且以数组方式进行释放
~string()
{
delete[] _str;
_str = nullptr;
}
private:
char* _str;
};
}