STL讲解——模拟实现string
经典的string类问题
大厂在面试中，面试官总喜欢让学生自己来模拟实现string类，最主要是实现string类的增、删、查、改、构造、拷贝构造、赋值运算符重载以及析构函数。大家看下自己可不可以写一个string类？
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()
{
if(_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};
大家肯定会想想我刚刚这样设计一个string类吧？可是你不觉得少了好多东西吗？
缺少什么呢：
1.缺少拷贝构造、赋值构造函数（虽然可以默认生成，但是都是浅拷贝，
这种开辟空间的类肯定是不行的，析构函数会多次析构同一片区域）。
2.增删查改一个都没有。
3.析构函数需要自己编写。
4.iterator和re_iterator也没有编写（还有const形式的）。
仔细讲解一下为什么浅拷贝会引起报错：
就是说浅拷贝是：有个同学的抄你作业，把你的名字都给抄上了，这肯定有问题呀，一个班有两个你，老师一定要批评叫你家长呢！回到编译器方面，一个地址被释放一次变为空，可是还要再释放一次（该地址就变成了野指针了）释放野指针肯定会报错呀。（free（nullptr）是没问题的哦，但是释放野指针就会报错了）
浅拷贝
浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共
享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为
还有效，所以 当继续对资源进项操作时，就会发生发生了访问违规。要解决浅拷贝问题，C++中引入了深拷
贝。
深拷贝
如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情
况都是按照深拷贝方式提供。
也就是说我单独开一个空间，把我要复制的内容都复制过来，复制到了一个新空间（容器）中，等于这两个除了里面的内容一样，但是空间地址不一样了。
开始写正确的string类
先写一个命名空间，把自己设计的类放到你自己写的命名空间中，防止你有时候和std中的string冲突了。
以后自己写代码时最好不要把std库里面的东西都释放出来，自己写东西也设计一个命名空间。
传统版本：
namespace tom
{
class string
{
public:
//构造函数
string(const char* str="")
:_size(strlen(str))
,_capacity(_size)
{
_str=new char[_capacity+ 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 (this != &s)
{
char* Str = new char[strlen(s._str) + 1];
if (Str)
{
strcpy(Str, s._str);
delete[] _str;
_str = Str;
_size = s._size;
_capacity = s._capacity;
}
else
{
cout << "赋值失败" << endl;
}
}
}
~string()
{
if (_str)
{
delete[] _str;
_str = NULL;
}
}
private:
char* _str;
size_t _capacity;
size_t _size;
};
这里的构造函数最好是把size和capacity在初始化列表中就初始化了，但是呢，
开空间还在构造函数中完成，不是说不能在初始化列表中完成，而是当你没有初始化string 是传一个‘\0’,
所以给一个缺省值“”，没错不写任何东西，默认里面只有一个‘\0’。
析构函数
设计一个判断如果是空指针就不用处理了。
现代版本：
namespace tom
{
class string
{
public:
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
//构造函数
string(const char* str="")
:_size(strlen(str))
,_capacity(_size)
{
_str=new char[_capacity+ 1];
strcpy(_str, str);
}
/*拷贝构造*/
/*string(const string& s)
:_str(new char[strlen(s._str) + 1])
{
strcpy(_str, s._str);
}*/
string(const string& s)//现代写法
:_str(nullptr)
,_size(0)
,_capacity(0)
{
string tmp(s._str);
/*this->swap(tmp);*/
swap(tmp);
}
//赋值构造
string& operator=(string s)
{
/*delete[] _str;
_str = new char[strlen(s._str) + 1];
strcpy(_str, s._str);*/
//现代写法
swap(s);
return *this;
}
private:
char* _str;
size_t _capacity;
size_t _size;
static const size_t Npos=-1;
};
swap（）
需要自己写一个string：：swap（）函数，为什么非要写一个类的swap呢，用函数库（algorithm.h)内的swap会有三次深拷贝，会降低效率。可是类内部的swap只用交换内置类型就可以了代价小很多。
然后利用传值拷贝形成临时拷贝变量，和this指针内的所有内容交换一下，由于是临时拷贝，出了作用域就会调用析构函数自动析构临时变量。太方便了！（要善于利用特性与机制）
增加关键细节
size（）
设计一个string的size（）函数 这个函数虽然很容易，但是相当重要。
//size
size_t size()const
{
return _size;
}
size（）和lenth（）是一样的所以就不写lenth（）了。
[ ]方括号函数重载
就和字符串，数组的随机访问一样——arr[n] 或者str[n]
其实就是传元素的引用（因为是可以修改的，这时候是不是觉得引用的设计太棒了）
//[]
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
char& operator[](size_t pos) const //const版本
{
assert(pos < _size);
return _str[pos];
}
也一定要设计一个const类型。
扩容
//扩容
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void resize(size_t n, char ch = '\0')
{
if (n <= _size)
{
_str[n] = '\0';
_size = n;
}
else
{
if (n > _capacity)
{
reserve(n);
}
memset(_str + _size, ch, n - _size);
_size = n;
_str[n] = '\0';
}
}
reserve：就是普通的扩容，但是不能初始化。
resize：可以扩容，并且初始化你想要的字符。（还可以缩容）
迭代器
namespace tom
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
typedef char* reverse_iterator;
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
reverse_iterator rbegin()
{
return _str + _size;
}
reverse_iterator rend()
{
return _str;
}
~string()
{
if (_str)
{
delete[] _str;
_str = NULL;
}
}
private:
char* _str;
size_t _capacity;
size_t _size;
static const size_t Npos=-1;
};
}
增、删、查、改
增加的设计
尾插
可以设计成一个尾插一个字母，在设计一个尾插一个字符串。
于是乎设计一个push_back()尾插一个字母.
设计一个append（）尾插一个字符串。
有了append（）既可以设计一个运算符重载“+=”。
void push_pack(char ch)
{
if (_size == _capacity)
{
reserve(_capacity==0?4:_capacity * 2);
//扩容一定要写这个判断，
//因为刚开始是一个空字符串的话capacity=0，
//乘二还是0.
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
void append(const char* str)
{
int len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size+len);
}
strcpy(_str + _size, str);
_size += len;
}
string& operator+=(const char ch)
{
push_pack(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
这里的“+=”函数一定要重载一下（pushback（）和append（））。
删除
//删除
string& erase(size_t pos=0 , size_t len=Npos)
{
assert(pos < _size);
if (len==Npos||pos+len>=_size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
return *this;
}
有了erase函数就可以函数服用设计一个pop_back()函数
void pop_back()
{
if (_size > 0)
{
this->erase(_size - 1, 1);
}
}
查找
查找一个字符还是很简单的，循环判断就可以了。
size_t find(char ch)
{
for (size_t i = 0; i < _size; i++)
{
if (ch == _str[i])
{
return i;
}
}
return Npos;
}
还可以设计一个查找字符串。再加一个小功能，指定位置开始查找，如果不给位置，再给个缺省值也行。（缺省值pos为0）
//查询整个字符串是否存在
size_t find(const char* s,size_t pos=0)
{
const char* ptr = strstr(_str + pos, s);
if(ptr==nullptr)
{
return Npos;
}
return ptr - _str;
}
这个返回的位置就是ptr（肯定是大于等于_str）减去_str的值。.
更改
可以插入一个字符或者一个字符串。
//插入
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
size_t end = _size+1;
while (end > pos)
{
_str[end] = _str[end - 1];
--end;
}
_str[pos] = ch;
++_size;
return *this;
}
string& insert(size_t pos, const char* s)
{
assert(pos <= _size);
size_t len = strlen(s);
if (_size+len >= _capacity)
{
reserve(_size+len);
}
size_t end = _size +len;
while (end > pos)
{
_str[end] = _str[end - len];
--end;
}
//strcpy(_str + pos, s); 绝不能用，因为会把\0 也复制过去的。
strncpy(_str + pos, s,len);
_size+=len;
return *this;
}
有了这个插入函数就可以再设计一下push_back():
void push_pack(char ch)
{
insert(_size,ch);
}
void append(const char* str)
{
insert(_size,str);
}
这就简洁许多了，要学会复用。
其实学会服用，面试的时候真的可以在十分钟之内写完string类。
