文章目录
写在前面
在本篇文章中，我们主要介绍了 C++ 中的 string 类的使用以及如何进行模拟实现。string 类是 C++ 标准库提供的一个重要组件，用于处理字符串，具有丰富的功能和便利的接口。我们首先介绍了 string 类的基本用法，紧接着详细讲解了string 类的模拟实现。在这个过程中，我们深入分析了 string 类的内部实现原理，包括字符串的存储结构、构造函数和析构函数的实现等。通过模拟实现 string 类，我们可以加深对C++ 中类的设计和实现的理解，同时也能提升我们的编程能力。
string模拟实现源码
1. string类的使用
string类是定义在<string>这个头文件中的。
我们可以先看下库里面对于string类的实现都提供了哪些接口，如下图所示：
这是string类的文档，点击蓝色字体就能跳转：string类的文档介绍。
通过上面图片我们就可以看出，C++标准库对于string类提供了非常多的接口，之前就有一个大佬统计过一个小小的 string 类居然有 106 个成员接口函数，当然我们不会全部来介绍，我们挑一些重点的、经常使用的来介绍，在上面图片中，我已经标注过了。下面我们来一一介绍。
1.1 string类的构造
在C++98中，大概提供了如下几个构造函数：
在上面这么多构造函数中，我们最常用的就是第一个（默认构造）、第二个（拷贝构造）以及第4个（使用一个C字符串来构造string对象）。
- 默认构造
string();
string的默认构造函数是使用一个空字符串来构造的。
- 拷贝构造
string (const string& str);
使用一个已经存在的string对象来初始化。
- 使用一个C字符串来构造string对象
string (const char* s);
1.2 string类的迭代器
在C++中，string 类提供了迭代器（iterator）来支持对字符串的序列式访问。通过迭代器，我们可以遍历字符串中的每个字符，进行读取或修改操作。这样的设计模式增加了代码的可读性和灵活性，同时与 STL(标准模板库)的其他容器类保持了一致的接口风格。
string类的迭代器类型
- 正向迭代器（iterator）：正向遍历容器中的元素。
- 反向迭代器（reverse_iterator）：逆向遍历容器中的元素。
- 常量迭代器（const_iterator）：与iterator类似，但是不能通过这种类型的迭代器修改其指向的元素，适用于只读访问。
- 常量反向迭代器（const_reverse_iterator）：与reverse_iterator类似，但不允许修改所指向的元素。
在C++的string类中，标准库提供了几个重要的成员函数来获取字符串的迭代器。这些迭代器使我们能够以顺序或逆序的方式遍历字符串中的字符。
具体来说，我们通常会使用以下四个函数来获得迭代器：
- begin(): 返回指向字符串第一个字符的迭代器。
- end(): 返回指向字符串末尾（\0字符后面的位置）的迭代器，不是最后一个字符。
- rbegin(), rend(): 返回反向迭代器，分别指向字符串的最后一个字符和第一个字符前的位置。
因此，我们使用迭代器的方式遍历string对象，就像使用指针遍历数组一样。
- 使用迭代器遍历string对象
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("hello word");
//正向遍历
string::iterator it = s.begin();
while (it != s.end())
{
cout << *it << ' ';//像使用指针一样使用迭代器遍历
++it;
}
cout << endl;
//反向遍历
string::reverse_iterator rit = s.rbegin();
while (rit != s.rend())
{
cout << *rit << ' ';
++rit;
}
cout << endl;
return 0;
}
运行结果如下：
- 使用非const迭代器还可以修改其指向的元素，例如我们使用迭代器修改string对象。
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("hello word");
//正向迭代器
string::iterator it = s.begin();
while (it != s.end())
{
cout << (*it)++ << ' ';//像使用指针一样使用迭代器修改string对象
++it;
}
cout << endl;
it = s.begin();
while (it != s.end())
{
cout << *it << ' ';
++it;
}
cout << endl;
return 0;
}
运行结果：
反向迭代器，也是如此，这里就不再进行演示。
- 支持了迭代器，就支持了范围for。因此，我们就可以使用范围for来访问和修改string类对象。
范围for循环是C++11标准引入的一种新的循环构造，允许遍历任何容器或数组的元素，它会自动迭代和自动判断结束。
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("hello word");
//范围for修改string对象
for (auto& e : s)
{
e += 1;
}
//范围for遍历string对象
for (auto e : s)
{
cout << e << ' ';
}
cout << endl;
return 0;
}
运行结果：
原理：范围for循环背后，编译器会自动转换为使用迭代器的代码。
1.3 string类对象的容量操作
与string类对象的容量操作相关的成员函数，我们下面重点介绍如下5个：
- size()：返回字符串有效字符长度。
size_t size() const;
2. empty() ：检测字符串释放为空串，是返回true，否则返回false。
bool empty() const;
- clear()：清空有效字符。
void clear();
4. reserve：为字符串预留空间，不改变有效元素个数。
void reserve (size_t n = 0);
reserve在扩容的时候，如果传入的参数n小于string当前的容量，那么该函数什么也不干，也就是说reserve函数不会进行缩容；如果传入的参数n大于string当前的容量，该函数改变容量大小,将容量增加到至少是n，这可能会导致原地增容（如果内存块的尾部有足够的空间），或者会进行异地增容并拷贝数据（如果内存块的尾部没有足够的空间）。
- resize()：将有效字符的个数该成n个，多出的空间用字符c填充。
void resize (size_t n);
void resize (size_t n, char c);
resize()函数用于改变字符串的大小，并且可以根据需要进行容量的调整。具体来说可以分为以下三种情况：
- 如果传入的参数n小于当前字符串的size，resize()函数将字符串的大小为缩减为n，并且丢弃超出部分的字符。
- 如果传入的参数n大于当前字符串的size，并且小于或等于当前字符串的capacity，resize()函数会将字符串的大小增加到n，并且多出的空间用字符c填充。
- 如果传入的参数n大于当前字符串的capacity，resize()函数会进行扩容，并且会将字符串的大小增加到n。
也就是说，resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大
小，如果是将元素个数减少，底层空间总大小不变。
1.4 string类对象的修改操作
（1）push_back:在字符串后面追加一个字符。
void push_back (char c);
（2）append：既可以在字符串后面追加一个字符串，也可以追加n个字符。apped函数库里面重载了好多个，我们这里只介绍一个最常用的。
string& append (const char* s);
string& append (size_t n, char c);
（3）operator+=：在字符串后面既可以追加一个字符也可以追加字符串str，这个函数也是我们最长使用的。
在string尾部追加字符时，push_back / append / operator+= 三种的实现方式差不多，一般情况下string类的+=操作用的比较多，因为+=操作不仅可以连接单个字符，还可以连接字符串。
（4）c_str：返回C格式字符串。
const char* c_str() const;
（5）find：从字符串pos位置开始往后找字符c，返回该字符在字符串中第一次出现的位置。找不到返回string::npos。
size_t find (char c, size_t pos = 0) const;
注意：npos是定义在string类中的静态变量，其定义如下：
static const size_t npos = -1;
（5）rfind：从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置。找不到返回string::npos。和find使用方法一样，只是查找方式不同，这里就不在赘述。
size_t rfind (char c, size_t pos = npos) const;
（6）substr：在str中从pos位置开始，截取n个字符，然后将其返回。
string substr (size_t pos = 0, size_t len = npos) const;
1.5 string类对象的非成员函数
（1）operator+：将两个字符串拼接成一个。尽量少用，因为返回值采用的传值返回，是深拷贝，效率低。
string operator+ (const string& lhs, const string& rhs);
（2）operator<< 和 operator>>：string对象的输入和输出。
istream& operator>> (istream& is, string& str);
ostream& operator<< (ostream& os, const string& str);
（4）getline：获取一行字符串。
istream& getline (istream& is, string& str);
- cin 对象默认以空格、制表符或换行符作为分隔符，因此无法直接读取一行字符串，而是在遇到空格、制表符或换行符时停止读取。
- 这可能导致只能读取一行字符串的一部分，而无法获取完整的一行。
- 为了解决这个问题，可以使用 getline(cin, str) 函数来获取完整的一行字符串。该函数会读取从当前输入流中获取的一行文本，并存储在给定的字符串 str 中，直到遇到换行符为止。这样就可以确保获取到完整的一行输入。
2. string类的模拟实现
我们模拟实现string不是为了写一个更好的出来，而是帮助我们理解string类的内部工作原理。
而在模拟实现的过程中，为了不和库里面的string冲突，我们把string类实现在我们的命名空间zzb中。
首先我们先给出string类的定义。
namespace zzb
{
class string
{
public:
private:
char* _str;
size_t _size;
size_t _capacity;//最多能存储的有效字符数
public:
statci const size_t npos;
};
const size_t npos = -1;
}
2.1 模拟实现string类的默认成员函数
（1）默认构造函数
库里面的string，对于string类的构造函数重载了好多个，而我们是作为学习者来模拟实现，没必要搞的这么复杂，我们实现一个全缺省的构造函数即可，即使用一个字符串来初始化我们的string类。
代码如下：
string(const char* str = "")
:_size(strlen(str))
{
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
这个构造函数的参数 str 我们了缺省值""，这也就意味着如果用户不提供参数，默认创建一个空字符串对象。
（2）拷贝构造函数：使用一个已经创建的string对象来初始化另一个对象。
在拷贝构造函数的实现中，我们不能直接拷贝传进来的对象，因为我们想要的是两个string对象中的_str应该分别指向各自的空间，而不是指向同一块空间。因此我们这里要实现深拷贝，即在堆上重新申请空间然后再拷贝数据，而不是简单地共享数据的指针。同时也避免了在析构时导致同一块空间被释放两次，导致程序崩溃的问题。
代码如下：
string(const string& s)
:_size(s._size)
,_capacity(s._capacity)
{
_str = new char[_capacity + 1];
strcpy(_str, s._str);
}
（3）赋值运算符重载：一个string对象赋值给另一个string对象。operator=实现步骤如下：
- 首先检查是否自己给自己赋值，即检查当前对象和右操作数是否是同一个对象，如果是，直接返回当前对象，避免一些没必要的操作。
- 申请新空间，并拷贝右侧操作数对象中_str的数据到刚申请的新空间中区。
- 释放当前对象原有的内存空间，避免造成内存泄漏。
- 当前对象的_str指向新空间，同时拷贝右侧操作数对象的_size 和 _capacity。
- 返回当前对象的引用，以支持链式赋值。
代码如下：
string& operator=(const string& s)
{
//判断是否自己给自己赋值
if (this != &s)
{
//开辟空间，拷贝
char* tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
//释放旧空间
delete[] _str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}
return *this;
}
（4）析构函数：完成string对象中资源的清理。
在这个析构函数中，我们使用 delete[] 来释放 _str 指针所指向的空间，以确保string 对象在销毁时，动态申请的空间能够得到正确释放，避免内存泄漏的问题。
代码如下：
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
2.2 模拟实现string类的迭代器
string 类的迭代器提供了一种访问 string 对象中字符的方式，它是定义在 string 类中的一种类型。为了简化实现过程，我们选择使用原生指针来模拟 string 类的迭代器。这样可以更直观地理解迭代器的工作原理，同时也减少了实现的复杂性。
迭代器的定义如下：
typedef char* iteartor;
typedef const char* const_iteartor;
对于string类，库里面定义了好几种迭代器，比如正向迭代器，反向迭代器等。这里我们只实现了正向迭代器的const版本和非const版本。
要使用迭代器访问字符串，我们需要提供两个成员函数begin()和end()，其中begin()用来获取字符串的起始迭代器，而end()用来获取字符串的结束迭代器，最后一个字符的下一个位置。
具体实现如下：
//迭代器
iteartor begin()
{
return _str;
}
iteartor end()
{
return _str + _size;
}
//const迭代器
const_iteartor begin() const
{
return _str;
}
const_iteartor end() const
{
return _str + _size;
}
2.3 模拟实现string类对象的容量相关的成员函数
（1）capacity：返回最多存储的有效字符个数。
size_t capacity() const
{
return _capacity;
}
（2）size：返回当前字符串的长度。
size_t size() const
{
return _size;
}
（3）empty：判断字符串是否为空。
bool empty() const
{
return _size == 0;
}
（4）clear：清空字符串，只是将字符串清空了，不会清理空间。
void clear()
{
_size = 0;
_str[_size] = '\0';
}
（5）reserve：申请空间。
注意：该函数不会进行缩容操作，当传入的n小于当等于前容量时该函数啥也不干，当传入的n大于当前容量时，该函数完成开辟空间+拷贝数据。
void reserve(size_t n = 0)
{
//检查
if (n > _capacity)
{
//开辟空间
char* tmp = new char[n + 1];
//拷贝数据
for (size_t i = 0; i <= _size; ++i)
{
tmp[i] = _str[i];
}
delete[] _str;
_str = tmp;
_capacity = n;
}
}
（6）resize：将当前字符串的长度增加或减少到n。
注意：我们根据传入的n，可以分为以下三种情况：
- n <= _size：直接将_size减少到n，在_size位置放置’\0’。
- n > _size && n <= _capacity：将_szie位置到n-1位置用传进的字符填充，然后将_size变为n。
- n > _capacity：先扩容，在填充。
void resize(size_t n, char ch = '\0')
{
if (n <= _size)
{
_size = n;
}
else
{
if (n > _capacity)
{
reserve(n);
}
memset(_str + _size, ch, n - _size);
_size = n;
}
_str[_size] = '\0';
}
2.4 模拟实现string类对象的修改相关的成员函数
（1）push_back：向字符串后面追加一个字符。
注意：在追加之前要先进行容量检查，如果容量不够要进行增容。
void push_back(char ch)
{
//判断是否需要扩容
if (_size + 1 > _capacity)
{
reserve(_capacity * 2);
}
_str[_size++] = ch;
_str[_size] = '\0';
}
（2）append：向字符串后面追加一个字符串。
注意：在追加之前要先进行容量检查，如果容量不够要进行增容。
string& append(const char* str)
{
//判断是否需要扩容
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, str);
_size = _size + len;
return *this;
}
（3）operator+=：向字符串后面追加一个字符或者一个字符串，因此这里使用了函数重载。
上面我们实现的push_back可以实现向字符串后面追加一个字符，append可以实现向字符串后面追加一个字符串，因此operator+=实现的过程中，直接对这两个函数进行复用。
//追加一个字符
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
//追加一个字符串
string& operator+=(const char* str)
{
append(str);
return *this;
}
（4）insert: 在pos位置插入一个字符或者字符串。
- 在pos位置插入一个字符
注意：在挪动数据的时候，是将 i - 1位置上的数据挪到 i 位置上。i > pos循环就继续
void insert(size_t pos, char ch)
{
assert(pos <= _size);
//检查扩容
if (_size + 1 > _capacity)
{
reserve(_capacity == 0 ? 4 :_capacity * 2);
}
//挪动数据
for (size_t i = _size + 1; i > pos; --i)
{
_str[i] = _str[i - 1];
}
//插入数据
_str[pos] = ch;
//更新字符串长度
++_size;
}
- 在pos位置插入一个字符串。
假设在字符串"hello word!“的第3个位置插入字符串"xxx”。
注意：在挪动数据的时候，是将 i - len位置上的数据挪到 i 位置上。i 大于等于 pos + len循环继续。
void insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);
//检查扩容
if (_size + len > _capacity)
{
reserve(_size + len);
}
//挪动数据
for (size_t i = _size + len; i >= pos + len; --i)
{
_str[i] = _str[i - len];
}
//插入数据
strncpy(_str + pos, str, len);
_size += len;
}
（5）erase: 从pos位置开始删除len个字符，不指定len默认从pos位置开始删完。
void erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
//全删
if (len >= _size - pos)
{
_str[pos] = '\0';
_size = pos;
}
else
{
//删除pos位置开始的len个字符
for (int i = pos + len; i <= _size; ++i)
{
_str[i - len] = _str[i];
}
_size -= len;
}
}
（6）swap: 交换两个string对象。
为什么算法库里实现了swap，这里还要提供swap函数呢？
void swap(string& s)
{
//交换他们的成员变量即可
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
2.5 模拟实现string类对象的查找和访问相关的成员函数
（1）find：从pos位置开始查找一个字符或者字符串。找到了返回其下标，找不到返回npos。
size_t find(char ch, size_t pos = 0)
{
assert(pos < _size);
for (size_t i = pos; i < _size; ++i)
{
if (ch == _str[i]) return i;
}
return npos;
}
size_t find(const char* str, size_t pos = 0)
{
assert(pos < _size);
char* ps = strstr(_str, str);
if (ps)
{
return ps - _str;
}
return npos;
}
（2）c_str：返回C形式的字符串。
const char* c_str() const
{
return _str;
}
（3）substr：从pos位置取len个字符的字串，不传len，默认取到字符串结尾。
string substr(size_t pos = 0, size_t len = npos) const
{
string tmp;
if (len >= _size - pos)
{
for (size_t i = pos; i < _size; ++i)
{
tmp += _str[i];
}
}
else
{
for (size_t i = pos; i < pos + len; ++i)
{
tmp += _str[i];
}
}
return tmp;
}
（4）operator[]：返回第i个字符的引用，可用来访问和修改字符串。const版本的只能读，不能写。
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
2.6 模拟实现string类对象的非成员函数
（1）operator<< 和 operator>>：流插入和流提取操作符的重载，用于string对象的输入输出。
ostream& operator<<(ostream& out,const string& s)
{
for (auto e : s)
{
out << e;
}
return out;
}
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch = in.get();
//避免频繁扩容
char buff[128];
int i = 0;
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == 127)
{
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
if (i > 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
（2）getline：读取输入的一行字符。
istream& getline(istream& in, string& s)
{
s.clear();
char ch = in.get();
char buff[128];
int i = 0;
while (ch != '\n')
{
buff[i++] = ch;
if (i == 127)
{
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
if (i > 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
（3）比较运算符重载：为了支持字符串和对象比较，库里面将比较运算符重载成了全局函数。
我们这里实现成全局的或者成员函数都可以。我们这里也先择实现为全局的。
bool operator>(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) > 0;
}
bool operator==(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator>=(const string& s1, const string& s2)
{
return s1 > s2 || s1 == s2;
}
bool operator<(const string& s1, const string& s2)
{
return !(s1 >= s2);
}
bool operator<=(const string& s1, const string& s2)
{
return !(s1 > s2);
}
bool operator!=(const string& s1, const string& s2)
{
return !(s1 == s2);
}
至此，本片文章就结束了，若本篇内容对您有所帮助，请三连点赞，关注，收藏支持下。
创作不易，白嫖不好，各位的支持和认可，就是我创作的最大动力，我们下篇文章见！
如果本篇博客有任何错误，请批评指教，不胜感激 ！！！
103
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
