C++STL详解—— string类的模拟实现
Posted 2021dragon
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++STL详解—— string类的模拟实现相关的知识，希望对你有一定的参考价值。
文章目录
string类各函数接口总览
namespace cl
{
//模拟实现string类
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
//默认成员函数
string(const char* str = ""); //构造函数
string(const string& s); //拷贝构造函数
string& operator=(const string& s); //赋值运算符重载函数
~string(); //析构函数
//迭代器相关函数
iterator begin();
iterator end();
const_iterator begin()const;
const_iterator end()const;
//容量和大小相关函数
size_t size();
size_t capacity();
void reserve(size_t n);
void resize(size_t n, char ch = '\\0');
bool empty()const;
//修改字符串相关函数
void push_back(char ch);
void append(const char* str);
string& operator+=(char ch);
string& operator+=(const char* str);
string& insert(size_t pos, char ch);
string& insert(size_t pos, const char* str);
string& erase(size_t pos, size_t len);
void clear();
void swap(string& s);
const char* c_str()const;
//访问字符串相关函数
char& operator[](size_t i);
const char& operator[](size_t i)const;
size_t find(char ch, size_t pos = 0)const;
size_t find(const char* str, size_t pos = 0)const;
size_t rfind(char ch, size_t pos = npos)const;
size_t rfind(const char* str, size_t pos = 0)const;
//关系运算符重载函数
bool operator>(const string& s)const;
bool operator>=(const string& s)const;
bool operator<(const string& s)const;
bool operator<=(const string& s)const;
bool operator==(const string& s)const;
bool operator!=(const string& s)const;
private:
char* _str; //存储字符串
size_t _size; //记录字符串当前的有效长度
size_t _capacity; //记录字符串当前的容量
static const size_t npos; //静态成员变量（整型最大值）
};
const size_t string::npos = -1;
//<<和>>运算符重载函数
istream& operator>>(istream& in, string& s);
ostream& operator<<(ostream& out, const string& s);
istream& getline(istream& in, string& s);
}
注：为了防止与标准库当中的string类产生命名冲突，模拟实现时需放在自己的命名空间当中。
默认成员函数
构造函数
构造函数设置为缺省参数，若不传入参数，则默认构造为空字符串。字符串的初始大小和容量均设置为传入C字符串的长度（不包括’\\0’）
//构造函数
string(const char* str = "")
{
_size = strlen(str); //初始时，字符串大小设置为字符串长度
_capacity = _size; //初始时，字符串容量设置为字符串长度
_str = new char[_capacity + 1]; //为存储字符串开辟空间（多开一个用于存放'\\0'）
strcpy(_str, str); //将C字符串拷贝到已开好的空间
}
拷贝构造函数
在模拟实现拷贝构造函数前，我们应该首先了解深浅拷贝：
浅拷贝：拷贝出来的目标对象的指针和源对象的指针指向的内存空间是同一块空间。其中一个对象的改动会对另一个对象造成影响。
深拷贝：深拷贝是指源对象与拷贝对象互相独立。其中任何一个对象的改动不会对另外一个对象造成影响。
很明显，我们并不希望拷贝出来的两个对象之间存在相互影响，因此，我们这里需要用到深拷贝。下面提供深拷贝的两种写法：
写法一：传统写法
传统写法的思想简单：先开辟一块足以容纳源对象字符串的空间，然后将源对象的字符串拷贝过去，接着把源对象的其他成员变量也赋值过去即可。因为拷贝对象的_str与源对象的_str指向的并不是同一块空间，所以拷贝出来的对象与源对象是互相独立的。
//传统写法
string(const string& s)
:_str(new char[strlen(s._str) + 1]) //_str申请一块刚好可以容纳s._str的空间
, _size(0)
, _capacity(0)
{
strcpy(_str, s._str); //将s._str拷贝一份到_str
_size = s._size; //_size赋值
_capacity = s._capacity; //_capacity赋值
}
写法二：现代写法
现代写法与传统写法的思想不同：先根据源字符串的C字符串调用构造函数构造一个tmp对象，然后再将tmp对象与拷贝对象的数据交换即可。拷贝对象的_str与源对象的_str指向的也不是同一块空间，是互相独立的。
//现代写法
string(const string& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
string tmp(s._str); //调用构造函数，构造出一个C字符串为s._str的对象
swap(tmp); //交换这两个对象
}
注：swap成员函数的模拟实现在文章的后面。
赋值运算符重载函数
与拷贝构造函数类似，赋值运算符重载函数的模拟实现也涉及深浅拷贝问题，我们同样需要采用深拷贝。下面也提供深拷贝的两种写法：
写法一：传统写法
赋值运算符重载函数的传统写法与拷贝构造函数的传统写法几乎相同，只是左值的_str在开辟新空间之前需要先将原来的空间释放掉，并且在进行操作之前还需判断是否是自己给自己赋值，若是自己给自己赋值，则无需进行任何操作。
//传统写法
string& operator=(const string& s)
{
if (this != &s) //防止自己给自己赋值
{
delete[] _str; //将原来_str指向的空间释放
_str = new char[strlen(s._str) + 1]; //重新申请一块刚好可以容纳s._str的空间
strcpy(_str, s._str); //将s._str拷贝一份到_str
_size = s._size; //_size赋值
_capacity = s._capacity; //_capacity赋值
}
return *this; //返回左值（支持连续赋值）
}
写法二：现代写法
赋值运算符重载函数的现代写法与拷贝构造函数的现代写法也是非常类似，但拷贝构造函数的现代写法是通过代码语句调用构造函数构造出一个对象，然后将该对象与拷贝对象交换；而赋值运算符重载函数的现代写法是通过采用“值传递”接收右值的方法，让编译器自动调用拷贝构造函数，然后我们再将拷贝出来的对象与左值进行交换即可。
//现代写法1
string& operator=(string s) //编译器接收右值的时候自动调用拷贝构造函数
{
swap(s); //交换这两个对象
return *this; //返回左值（支持连续赋值）
}
但这种写法无法避免自己给自己赋值，就算是自己给自己赋值这些操作也会进行，虽然操作之后对象中_str指向的字符串的内容不变，但是字符串存储的地址发生了改变，为了避免这种操作我们可以采用下面这种写法：
//现代写法2
string& operator=(const string& s)
{
if (this != &s) //防止自己给自己赋值
{
string tmp(s); //用s拷贝构造出对象tmp
swap(tmp); //交换这两个对象
}
return *this; //返回左值（支持连续赋值）
}
但实际中很少出现自己给自己赋值的情况，所以采用“现代写法1”就行了。
析构函数
string类的析构函数需要我们进行编写，因为每个string对象中的成员_str都指向堆区的一块空间，当对象销毁时堆区对应的空间并不会自动销毁，为了避免内存泄漏，我们需要使用delete手动释放堆区的空间。
//析构函数
~string()
{
delete[] _str; //释放_str指向的空间
_str = nullptr; //及时置空，防止非法访问
_size = 0; //大小置0
_capacity = 0; //容量置0
}
迭代器相关函数
string类中的迭代器实际上就是字符指针，只是给字符指针起了一个别名叫iterator而已。
typedef char* iterator;
typedef const char* const_iterator;
注：不是所有的迭代器都是指针。
begin和end
string类中的begin和end函数的实现简单的可怕，begin函数的作用就是返回字符串中第一个字符的地址：
iterator begin()
{
return _str; //返回字符串中第一个字符的地址
}
const_iterator begin()const
{
return _str; //返回字符串中第一个字符的const地址
}
end函数的作用就是返回字符串中最后一个字符的后一个字符的地址（即’\\0’的地址）：
iterator end()
{
return _str + _size; //返回字符串中最后一个字符的后一个字符的地址
}
const_iterator end()const
{
return _str + _size; //返回字符串中最后一个字符的后一个字符的const地址
}
在明白了string类中迭代器的底层实现，再来看看我们用迭代器遍历string的代码，其实就是用指针在遍历字符串而已。
string s("hello world!!!");
string::iterator it = s.begin();
while (it != s.end())
{
cout << *it << " ";
it++;
}
cout << endl;
在string的介绍中我们还说到，可以用范围for来遍历string，可能很多初学者都会觉得范围for是个很神奇的东西，只需要一点点代码就能实现string的遍历。
实际上范围for并不神奇，因为在代码编译的时候，编译器会自动将范围for替换为迭代器的形式，也就是说范围for是由迭代器支持的，现在我们已经实现了string类的迭代器，自然也能用范围for对string进行遍历：
string s("hello world!!!");
//编译器将其替换为迭代器形式
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
容量和大小相关函数
size和capacity
因为string类的成员变量是私有的，我们并不能直接对其进行访问，所以string类设置了size和capacity这两个成员函数，用于获取string对象的大小和容量。
size函数用于获取字符串当前的有效长度（不包括’\\0’）。
//大小
size_t size()const
{
return _size; //返回字符串当前的有效长度
}
capacity函数用于获取字符串当前的容量。
//容量
size_t capacity()const
{
return _capacity; //返回字符串当前的容量
}
reserve和resize
reserve和resize这两个函数的执行规则一定要区分清楚。
reserve规则：
1、当n大于对象当前的capacity时，将capacity扩大到n或大于n。
2、当n小于对象当前的capacity时，什么也不做。
//改变容量，大小不变
void reserve(size_t n)
{
if (n > _capacity) //当n大于对象当前容量时才需执行操作
{
char* tmp = new char[n + 1]; //多开一个空间用于存放'\\0'
strncpy(tmp, _str, _size + 1); //将对象原本的C字符串拷贝过来（包括'\\0'）
delete[] _str; //释放对象原本的空间
_str = tmp; //将新开辟的空间交给_str
_capacity = n; //容量跟着改变
}
}
注意：代码中使用strncpy进行拷贝对象C字符串而不是strcpy，是为了防止对象的C字符串中含有有效字符’\\0’而无法拷贝（strcpy拷贝到第一个’\\0’就结束拷贝了）。
resize规则：
1、当n大于当前的size时，将size扩大到n，扩大的字符为ch，若ch未给出，则默认为’\\0’。
2、当n小于当前的size时，将size缩小到n。
//改变大小
void resize(size_t n, char ch = '\\0')
{
if (n <= _size) //n小于当前size
{
_size = n; //将size调整为n
_str[_size] = '\\0'; //在size个字符后放上'\\0'
}
else //n大于当前的size
{
if (n > _capacity) //判断是否需要扩容
{
reserve(n); //扩容
}
for (size_t i = _size; i < n; i++) //将size扩大到n，扩大的字符为ch
{
_str[i] = ch;
}
_size = n; //size更新
_str[_size] = '\\0'; //字符串后面放上'\\0'
}
}
empty
empty是string的判空函数，我们可以调用strcmp函数来实现，strcmp函数是用于比较两个字符串大小的函数，当两个字符串相等时返回0。
//判空
bool empty()
{
return strcmp(_str, "") == 0;
}
注意：两个字符串相比较千万不能用 == 。
修改字符串相关函数
push_back
push_back函数的作用就是在当前字符串的后面尾插上一个字符，尾插之前首先需要判断是否需要增容，若需要，则调用reserve函数进行增容，然后再尾插字符，注意尾插完字符后需要在该字符的后方设置上’\\0’，否则打印字符串的时候会出现非法访问，因为尾插的字符后方不一定就是’\\0’。
//尾插字符
void push_back(char ch)
{
if (_size == _capacity) //判断是否需要增容
{
reserve(_capacity == 0 ? 4 : _capacity * 2); //将容量扩大为原来的两倍
}
_str[_size] = ch; //将字符尾插到字符串
_str[_size + 1] = '\\0'; //字符串后面放上'\\0'
_size++; //字符串的大小加一
}
注：增容时以二倍的形式进行增容，避免多次调用push_back函数时每次都需要调用reserve函数。
实现push_back还可以直接复用下面即将实现的insert函数。
//尾插字符
void push_back(char ch)
{
insert(_size, ch); //在字符串末尾插入字符ch
}
append
append函数的作用是在当前字符串的后面尾插一个字符串，尾插前需要判断当前字符串的空间能否容纳下尾插后的字符串，若不能，则需要先进行增容，然后再将待尾插的字符串尾插到对象的后方，因为待尾插的字符串后方自身带有’\\0’，所以我们无需再在后方设置’\\0’。
//尾插字符串
void append(const char* str)
{
size_t len = _size + strlen(str); //尾插str后字符串的大小（不包括'\\0'）
if (len > _capacity) //判断是否需要增容
{
reserve(len); //增容
}
strcpy(_str + _size, str); //将str尾插到字符串后面
_size = len; //字符串大小改变
}
实现append函数也可以直接复用下面即将实现的insert函数。
//尾插字符串
void append(const char* str)
{
insert(_size, str); //在字符串末尾插入字符串str
}
operator+=
+=运算符的重载是为了实现字符串与字符、字符串与字符串之间能够直接使用+=运算符进行尾插。
+=运算符实现字符串与字符之间的尾插直接调用push_back函数即可。
//+=运算符重载
string& operator+=(char ch)
{
push_back(ch); //尾插字符串
return *this; //返回左值（支持连续+=）
}
+=运算符实现字符串与字符串之间的尾插直接调用append函数即可。
//+=运算符重载
string& operator+=(const char* str)
{
append(str); //尾插字符串
return *this; //返回左值（支持连续+=）
}
insert
insert函数的作用是在字符串的任意位置插入字符或是字符串。
insert函数用于插入字符时，首先需要判断pos的合法性，若不合法则无法进行操作，紧接着还需判断当前对象能否容纳插入字符后的字符串，若不能则还需调用reserve函数进行扩容。插入字符的过程也是比较简单的，先将pos位置及其后面的字符统一向后挪动一位，给待插入的字符留出位置，然后将字符插入字符串即可。
//在pos位置插入字符
string& insert(size_t pos, char ch)
{
assert(pos <= _size); //检测下标的合法性
if (_size == _capacity) //判断是否需要增容
{
reserve(_capacity == 0 ? 4 : _capacity * 2); //将容量扩大为原来的两倍
}
char* end = _str + _size;
//将pos位置及其之后的字符向后挪动一位
while (end >= _str + pos)
{
*(end + 1) = *(end);
end--;
}
_str[pos] = ch; //pos位置放上指定字符
_size++; //size更新
return *this;
}
insert函数用于插入字符串时，首先也是判断pos的合法性，若不合法则无法进行操作，再判断当前对象能否容纳插入该字符串后的字符串，若不能则还需调用reserve函数进行扩容。插入字符串时，先将pos位置及其后面的字符统一向后挪动len位（len为待插入字符串的长度），给待插入的字符串留出位置，然后将其插入字符串即可。
//在pos位置插入字符串
string& insert(size_t pos, const char* str)
{
assert(pos <= _size); //检测下标的合法性
size_t len = strlen(str); //计算需要插入的字符串的长度（不含'\\0'）
if (len + _size > _capacity) //判断是否需要增容
{
reserve(len + _size); //增容
}
char* end = _str + _size;
//将pos位置及其之后的字符向后挪动len位
while (end >= _str + pos)
{
*(end + len) = *(end);
end--;
}
strncpy(_str + pos, str, len); //pos位置开始放上指定字符串
_size += len; //size更新
return *this;
}
注意：插入字符串的时候使用strncpy，不能使用strcpy，否则会将待插入的字符串后面的’\\0’也插入到字符串中。
erase
erase函数的作用是删除字符串任意位置开始的n个字符。删除字符前也需要判断pos的合法性，进行删除操作的时候分两种情况：
1、pos位置及其之后的有效字符都需要被删除。
这时我们只需在pos位置放上’
以上是关于C++STL详解—— string类的模拟实现的主要内容，如果未能解决你的问题，请参考以下文章
[C/C++]详解STL容器2--vector的功能和模拟实现(迭代器失效,memcpy拷贝问题)
C++初阶：STL —— stringstring类 | 浅拷贝和深拷贝(传统写法和现代写法) | string类的模拟实现
C++初阶：STL —— stringstring类 | 浅拷贝和深拷贝(传统写法和现代写法) | string类的模拟实现