STL中string类的实现
目录
引入
构造 | 析构函数
构造函数
析构函数
返回指针的c_str()
求字符大小的size()
operator[]
普通对象调用：
const对象调用：
迭代器的实现
范围for
深浅拷贝
浅拷贝的不足
实现深拷贝
赋值的深拷贝
传统写法与现代写法
传统写法
现代写法
练习
增删查改
增容reserve()
尾插字符push_back()
追加字符串append()
贼好用的operator+=
指定位置插 insert()
删除erase()
查找find()
你知道在STL库中，string是怎么实现的吗？其实我们也能写！
本篇将手把手实现string类。通过自己的实现，我们能更好地去理解string类的底层原理。
引入
首先，在string.h里把string的框架搭好：
#pragma once
namespace jzy //为了和STL里的string区分，我们把string放进自定义的命名空间里
{
class string
{
public:
private:
char* _str;
size_t _size; //也可以用int，但库里面一般用size_t
size_t _capacity; //_capacity是有效字符的空间数，不包括\0
};
}构造 | 析构函数
构造函数
构造函数的形参有两种情况，一是有参，二是无参，这两个都要实现。
➡️有参：
string(char* str) //有参：传字符串首元素的地址过来
:_str(new char[strlen(str) + 1]) //记得为末尾的\0开一份空间
, _size(strlen(str))
, _capacity(strlen(str))
{
strcpy(_str, str);
}然而，这个函数在测试时却报错了：
#include"string.h"
using namespace jzy;
void test1()
{
string s1("abc");
}
int main()
{
test1();
return 0;
}报错：
这其实是因为：
abc是位于常量区的常量字符串，被const修饰，不可修改。这就是说，权限比较小。
而它要调用的string函数，形参未被const修饰，是可修改的，权限较大。
就像公司的上下级关系，权限小的不可以调用权限大的，它只能调用平级。
所以，string的形参也要被const修饰。
这个故事告诉我们，能用const就尽量用。
➡️修改后的有参：
class string
{
public:
string(const char* str)
:_str(new char[strlen(str) + 1])
, _size(strlen(str))
, _capacity(strlen(str))
{
strcpy(_str, str);
}➡️无参：
string()
:_str(new char[1]) //尽管无参，仍要为\0开空间
,_size(0)
,_capacity(0)
{
_str[0] = '\0';
}或者，用缺省值将有参/无参 合二为一：
string(const char* str = "\0") //注：这里不能用'\0'，得用"\0"，//单引号表示的是单个字符，类型为char而非char*
:_str(new char[strlen(str) + 1])
, _size(strlen(str))
, _capacity(strlen(str))
{
strcpy(_str, str);
}补：这里的"\0"其实有点画蛇添足。用""就可以了，里面隐含了\0。只要是常量字符串。都暗含了\0，只是看不见。
那这里的"\0"能不能换成nullptr呢？
不能！因为strlen不会检查判空，而是直接访问字符串，直到找到'\0'才会结束。
如果不传参，那默认为nullptr的话，strlen就会访问空指针，使程序崩溃。
析构函数
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}返回指针的c_str()
函数c_str()的作用？
"在C语言中，使用printf直接输出string类型的字符串可能会出现乱码。这是因为printf函数的%s格式化符号期望传入一个char类型的参数，而string类型的字符串实际上是一个对象，不是一个字符指针。所以在使用printf输出string类型的字符串时，应该使用s.c_str()方法将string类型转换为char类型。
而在C++中，使用cout输出string类型的字符串是没有问题的。cout对string类型有特殊的处理方式，可以直接输出string类型的字符串。
此外，也可以通过循环遍历string的每个字符，使用printf逐个输出字符，或者使用cout逐个输出字符，都可以得到相同的结果。
需要注意的是，如果没有包含
头文件，那么默认情况下是不能使用cout输出string类型的字符串的，此时需要使用c_str()方法将string类型转化为char*类型。" （源自 c知道）
简单来说，string类是无法直接被cout或者printf输出的，它需要被转化成char类型才可以。那c_str()做的就是这样一个转化的工作。
c_str()返回的是字符串的首字母地址，此地址只读不写，因此要用const来修饰：
char* c_str()const
{
return _str;
}有了字符串的首元素地址，我们就可以cout输出stirng字符串了。
测试一下：
void test2()
{
string s1("abcdef");
cout << s1.c_str() << endl;
}
求字符大小的size()
size_t size()const //只读不写 就加上const保护
{
return _size;
}operator[]
operator[]是非常好用的接口，它能把字符串当数组一样使用。这么好用的接口，实现起来其实很简单。
普通对象调用：
char operator[](size_t pos)
{
return *(_str + pos);
}等等……直接传值返回的话，会有什么弊端吗？
有的！我们无法直接修改字符，来测试一下：
void test3()
{
string s1("abcdef");
cout << ++s1[0] << endl;
}
传值返回s1[0]，我们得到的并不是s1里的'a'，而是它的拷贝，这导致我们无法修改真正的a。
如果想要对a做修改，那就要传引用返回。
更新版的operator[]：
char& operator[](size_t pos)
{
return *(_str + pos);
}const对象调用：
我们知道，const权限小，不能调用权限大的函数。因此，要再写一份const版的operator[]函数：
const char& operator[](size_t pos) const
{
return *(_str + pos);
}经过const的保护，这个版本的operator[]是只读不写的。
迭代器的实现
之前我们对迭代器的认识为“像指针一样的东西”，那它究竟是不是指针呢？两者又有什么关联呢？别急，实现一遍我们就知道了。
iterator：
begin()：返回第一个字符的位置。
end()：返回最后一个字符的下一个位置。
typedef char* iterator;
iterator& begin() //&可加，也可不加
{
return _str;
}
iterator end() //注意：这里不能加&！
{
return _str + _size;
}这里说明一下，end()为什么不能加&。因为end()指向的不是最后一个字符，而是它的后一个，也就是\0，所以end()处是开区间，是不能取到的。
测试一下：
void test4()
{
string s1("hello");
string::iterator it = s1.begin();
while (it != s1.end())
{
cout << *it << " "; //可读
it++;
}
cout << endl;
for (auto ch : s1)
{
cout << ++ch << " "; //可写
}
}
上面实现的是普通的迭代器，是可读可写的。
现在再实现const_iterator，只读不写的：
const_iterator：
typedef const char* const_iterator;
const_iterator begin()const
{
return _str;
}
const_iterator end()const
{
return _str + _size;
}范围for
之前我们说过，范围for看起来很高级，实际上底层原理很简单，现在我们就来揭秘一下。
其实，只要写了迭代器，那直接就能用范围for，它甚至不需要你去实现。
现在，我们直接在刚刚实现的迭代器后面，使用范围for：
void test4()
{
string s1("hello");
string::iterator it = s1.begin();
while (it != s1.end())
{
cout <<*it<< " ";
it++;
}
cout << endl;
for (auto ch : s1) //再遍历一遍
{
cout << ch << " ";
}
}
这时因为：范围for语句的底层原理是通过迭代器来实现的。编译器会用迭代器 来替换范围for。
范围for会自动调用 对象的begin()和end()方法 来获取迭代器的起始、结束位置，然后通过迭代器来遍历。
迭代器是一个对象，用于遍历和访问元素。范围for通过迭代器来遍历集合，不用再显式地操作指针，使代码更简洁易读。
可见，范围for的确没啥含金量……
深浅拷贝
浅拷贝的不足
之前我们了解过，浅拷贝就是值拷贝，对于内置类型，是按字节的方式直接拷贝的。对于自定义类型，是调用其拷贝构造函数完成拷贝的。
浅拷贝真的够用吗？
答案当然是否定的。如果有成员变量是指针，那拷贝时，仅仅是复制了指针的值而不复制指针指向的空间。
如图，string的浅拷贝：
可见，俩指针指向同一片空间。这就导致，当其中一个指针释放空间时，另一个指针也受到影响。
所以说，有指针成员时，就需要进行深拷贝了。
实现深拷贝
深拷贝是由我们自己实现的，拷贝指针时，不仅仅是复制值，更是要复制一份空间。
现在我们来实现下string的深拷贝：
string(const string& s)
:_str(new char[strlen(s._str) + 1])
,_size(s._size)
,_capacity(s._capacity)
{
strcpy(_str,s._str);
}可以看到，深拷贝的确是新开了空间：
赋值的深拷贝
其实赋值和刚刚说的拷贝构造是一个道理。很多时候，默认的赋值运算符就够用了，
但当涉及资源管理，如指针，就会出现两个指针指向同一块空间的情况。
来看string赋值的崩溃现场：
void test5()
{
string s1("hello");
string s2("111111111111111111111111111");
s1 = s2;
}
那这种场景就需要实现赋值的深拷贝。
我们来实现一下：
string& operator=(const string& s)
{
delete[] _str; //先释放旧空间
_str = new char[strlen(s._str) + 1]; //再开新空间
strcpy(_str, s._str);
_size = s._size;
_capacity = s._capacity;
return *this;
}测试下：
void test5()
{
string s1("hello");
string s2("111111111111111111111111111");
s1 = s2;
}
可见，赋值成功。
❗但是，这并非 赋值运算符 的最终形态。因为还没检测 是否自己给自己赋值。
这里要注意一个点：在实现赋值的深拷贝时，需要检测是否自己给自己赋值。
先来看看如果给自己赋值，会发生什么，
void test5()
{
string s1("hello");
string s2("111111111111111111111111111");
s2 = s2;
}
s2中的字符居然无效了！（被置成了随机值）
这是因为，this 和 形参s 都是s2。一上来this的_str空间就被释放，所以，此时s的 _str空间也被释放了，这俩现在都是随机值。所以，再把s拷给this，就会出现随机值的状况。
所以说，需要检查 是否自己给自己赋值 的情况。
赋值深拷贝的最终形态：
string& operator=(const string& s)
{
if (this != &s)
{
delete[] _str; //先释放旧空间
_str = new char[strlen(s._str) + 1]; //再开新空间
strcpy(_str, s._str);
_size = s._size;
_capacity = s._capacity;
return *this;
}
}传统写法与现代写法
在stirng这里，我们就要学会写同一个功能的两种写法，即传统写法与现代写法。
现代写法 较传统写法的优势目前可能表现不出来，但等我们学到了vector、list时，现代写法就方便多了。
所以，这两种写法，都是有必要掌握的！
下面就用拷贝构造来举例：
传统写法
传统写法，就是老老实实地打工搬砖：开空间、初始化、拷贝：
string(const string& s)
:_str(new char[strlen(s._str) + 1])
,_size(s._size)
,_capacity(s._capacity)
{
strcpy(_str,s._str);
}现代写法
现代写法，则精明多了。这些累活我不自己干，我雇打工人tmp来干：
string(const string& s)
{
string tmp(s._str); //先构造个tmp
swap(_str, tmp._str); //把tmp交换给我
swap(_size, tmp._size);
swap(_capacity, tmp._capacity);
}但是这样写，有一个隐患：
this._str未经初始化，里面是随机值。经过swap，把随机值给了tmp. _str。
在delete tmp时，对随机值指向的空间进行释放，可能会引发崩溃。
如果 _str置空的话，delete就不会释放空指针。所以，要给this. _str初始化。
经过改造：
void swap(string&tmp) //这是写在jzy类域里的swap
{
::swap(_str, tmp._str); //用::调用全局的swap函数
::swap(_size, tmp._size);
::swap(_capacity, tmp._capacity);
}
string(const string& s)
:_str(nullptr) //初始化，更安全
,_size(0)
,_capacity(0)
{
string tmp(s._str);
swap(tmp);
}注：这俩swap不一样，不是函数重载。函数重载的前提是在同一作用域。而这俩swap，一个是类里面的，一个是全局的。
所以说，全局的swap在调用时要加::，不然它会优先去局部域找，找到我们写的那个swap(string&tmp)之后，会认为参数不匹配。
总结一下，现代写法的本质是”拷贝构造新对象+将自己和新对象进行交换“。
练习
现在，在学习了现代写法的思想之后，我们来练习写operator=的现代写法：
void swap(string& tmp)
{
::swap(_str, tmp._str);
::swap(_size, tmp._size);
::swap(_capacity, tmp._capacity);
}
string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s._str);
swap(tmp);
return *this;
}
}增删查改
增容reserve()
reserve”保留“：开若干个空间，先保留在那里，即增容。
void reserve(size_t size)
{
if (size > _capacity) //先检查下要不要增容
{
char* p = new char[size + 1]; //开新空间(为\0多开一个空间)
strcpy(p, _str); //拷数据
delete[] _str; //释放旧空间
_str = p;
_capacity = size;
}
}尾插字符push_back()
void push_back(const char c)
{
if (_size == _capacity) //先检查要不要扩容
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
_str[_size++] = c;
_str[_size] = '\0'; //别忘了最后得加上'\0'
}追加字符串append()
void append(const char* ch)
{
//考虑扩容
size_t total_size = _size + strlen(ch); //先判断容量
if(_capacity < total_size)
{
reserve(total_size);
}
strcpy(_str + _size, ch); //直接把ch拷到\0的位置
_size += strlen(ch);
}贼好用的operator+=
在了解stirng类的方法时，我们就惊叹过，operator+=真的好好用，既能追加字符，又能加字符串。
实际上，追加字符 和 追加字符串 是构成重载的两个函数，现在我们来实现下。
//追加字符
string& operator+=(const char c)
{
push_back(c); //复用了push_back()
return *this;
}
//追加字符串
string& operator+=(const char* ch)
{
append(ch); //复用了append()
return *this;
}指定位置插 insert()
插字符：
string& insert(size_t pos, char c)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
//先把后面的数据往后挪
size_t end = _size - 1;
while (end > pos)
{
_str[end] = _str[end - 1];
end--;
}
//再插入
_str[pos] = c;
_size++;
_str[_size] = '\0';
return *this; //其实这个返回值意义不大
}插字符串：
string& insert(size_t pos, const char* ch)
{
assert(pos <= _size);
size_t total_size = _size + strlen(ch);
if (_capacity < total_size) //先算出一共需要多少空间，不够就开
{
reserve(total_size);
}
size_t end = _size ; //挪数据
size_t span = strlen(ch);
while (end > pos) //这个循环很容易写错！ 不能写end>=pos，减成负数也就是无穷大，很容易越界！
{
_str[end + span] = _str[end];
end--;
}
_str[pos+span] = _str[pos];
strncpy(_str+pos, ch, strlen(ch));
_size += strlen(ch);
return *this;
}删除erase()
void erase(size_t pos, size_t len = npos)
{
assert(len < _size);
if (len == npos||len>_size-pos) //当删到末尾或者不够删时
{
_str[pos] = '\0';
}
else
{
strcpy(_str + pos, _str + pos + len);
_str[_size - len] = '\0';
}
_size -= len;
}关于npos：
npos的类型为size_t，它被设为-1，因为size_t表示无符号数，-1在无符号数中表示 最大值。
npos在字符串中，意味着直到字符串的末尾。在容器中，表示不存在的位置。
我们要在类里声明静态的npos，在类外定义：
//类里
private:
char* _str;
size_t _size;
size_t _capacity;
static size_t npos;
//类外
size_t string::npos = -1;或者，在类里这样写：
private:
char* _str;
size_t _size;
size_t _capacity;
const static size_t npos = -1; //const static在C++中是语法的特殊处理，直接可以当成定义初始化查找find()
查找字符：
size_t find(char c, size_t pos = 0)const //从pos位置开始找c,找到返回下标
{
assert(pos < _size);
for (; pos < _size; pos++)
{
if (_str[pos] == c)
{
return pos;
}
}
return npos;
}查找字符串：
size_t find(const char* s, size_t pos)const //第一个const一定要加！！
{
assert(pos < _size);
const char* ret = strstr(_str + pos, s);
if (ret == nullptr)
{
return npos;
}
return ret-_str;
}这里说明一下，关于左操作数的const为什么一定要加。
在测试时，我们给的例子为：s1.find("day", 0)，这里的”day“是常量字符串，类型为const char*，而不是char *，
所以左操作数的类型也要严格为const char*，才能与常量字符串匹配。