写在前面

在本篇文章中，我们主要介绍了 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对象）。

1. 默认构造

string();

string的默认构造函数是使用一个空字符串来构造的。

2. 拷贝构造

string (const string& str);

使用一个已经存在的string对象来初始化。

3. 使用一个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对象，就像使用指针遍历数组一样。

1. 使用迭代器遍历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;
}

运行结果如下：

2. 使用非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;
}

运行结果：

反向迭代器，也是如此，这里就不再进行演示。

3. 支持了迭代器，就支持了范围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个：

1. size()：返回字符串有效字符长度。

size_t size() const;

2. empty() ：检测字符串释放为空串，是返回true，否则返回false。

bool empty() const;

3. clear()：清空有效字符。

void clear();

4. reserve：为字符串预留空间，不改变有效元素个数。

void reserve (size_t n = 0);

reserve在扩容的时候，如果传入的参数n小于string当前的容量，那么该函数什么也不干，也就是说reserve函数不会进行缩容；如果传入的参数n大于string当前的容量，该函数改变容量大小,将容量增加到至少是n，这可能会导致原地增容（如果内存块的尾部有足够的空间），或者会进行异地增容并拷贝数据（如果内存块的尾部没有足够的空间）。

5. 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);
}

至此，本片文章就结束了，若本篇内容对您有所帮助，请三连点赞，关注，收藏支持下。

创作不易，白嫖不好，各位的支持和认可，就是我创作的最大动力，我们下篇文章见！

如果本篇博客有任何错误，请批评指教，不胜感激 ！！！