C++ string类操作全解析（含模拟实现）

目录

1. 为什么要学习string类

1.1 C语言中的字符串

2. 标准库中的string类

2.1 string类的常用接口说明 

3. string类的模拟实现

1.string类的基本框架：

2.构造、析构、拷贝构造、复制重载的实现

3.string类的接口实现

4. 写时拷贝

---

 如果大家对C++的学习感兴趣，欢迎来观摩下本人的总结专栏：

C++语法专栏：

https://blog.csdn.net/2302_79440910/category_13027387.html

数据结构专栏：

https://blog.csdn.net/2302_79440910/category_13026083.html

1. 为什么要学习string类

1.1 C语言中的字符串

  C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数， 但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可 能还会越界访问。

  在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本 都使用string类，很少有人去使用C库中的字符串操作函数。

2. 标准库中的string类

在使用string类时，必须包含#include头文件以及using namespace std;

string是表示字符串的字符串类，该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。

2.1 string类的常用接口说明 

1. string类对象的常见构造

void Teststring()
{string s1; // 构造空的string类对象s1string s2("hello bit"); // 用C格式字符串构造string类对象s2string s3(s2); // 拷贝构造s3
}

2. string类对象的容量操作

注意：

1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一 致，一般情况下基本都是用size()。

2. clear()只是将string中有效字符清空，不改变底层空间大小。

3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字 符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的 元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大 小，如果是将元素个数减少，底层空间总大小不变。

4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于 string的底层空间总大小时，reserver不会改变容量大小。

3. string类对象的访问及遍历操作

遍历：

  string s = "abc";for (char c : s) {cout << c; // 输出"abc"}

4. string类对象的修改操作

注意：

1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般 情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。

2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。

5. string类非成员函数

其中，由于cin默认以空格作为分隔符，只能读取单个单词，而getline可以读取包含空格的完整行内容。这使得在需要输入姓名、地址等包含空格的字符串时更加方便。使用方式如下：

#include <iostream>
#include <string>
using namespace std;int main() {string name;int age;// 使用cin读取整数后，换行符留在缓冲区cout << "请输入您的年龄: ";cin >> age;// 使用getline读取整行，包括空格cout << "请输入您的姓名: ";getline(cin, name); // 会自动跳过cin留下的换行符cout << "姓名: " << name << endl;cout << "年龄: " << age << endl;return 0;
}

3. string类的模拟实现

1.string类的基本框架：

#include<iostream>
#include<assert.h>
using namespace std;namespace bit
{class string{public:private:char* _str;int _size;int _capacity;const static size_t npos;//对于静态成员变量，是不能给缺省值的，但只有const static int是例外};

2.构造、析构、拷贝构造、复制重载的实现

 经典的string类问题：看下面这个简单的string代码：

// 为了和标准库区分，此处使用String
class String
{
public:/*String():_str(new char[1]){*_str = '\0';}*///String(const char* str = "\0") 错误示范//String(const char* str = nullptr) 错误示范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;
};// 测试
void TestString()
{String s1("hello bit!!!");String s2(s1);
}

说明：上述String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用s1构 造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块 空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。

  浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共 享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为 还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。

  如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情 况都是按照深拷贝方式提供。

下面给出正确的string类这几个函数的实现：

namespace bit
{class string{public:typedef char* iterator;string(const char* str = ""){if (str == nullptr){return;}_size = _capacity = strlen(str);_str = new char[_size + 1];strcpy(_str, str);}string(const string& str):_size(str._size),_capacity(_size){if (this != &str){_str = new char[_size + 1];strcpy(_str, str._str);}}string& operator=(const string& str){if (this != &str){int sz = str._size;if (_str) delete[](_str);_str = new char[sz + 1];strcpy(_str, str._str);_size  = sz;_capacity = str._capacity;}return *this;}~string(){delete[] _str;_str = nullptr;_size = _capacity = 0;}private:char* _str;int _size;int _capacity;const static size_t npos;//对于静态成员变量，是不能给缺省值的，但只有const static int是例外};

  对于构造函数，我们实现的是一个全缺省的默认构造，如果传入了c语言字符串，就会给_str分配相同大小的空间，然后将参数字符串拷贝过来。如果没传字符串，也就是按空串处理，空串实际是有一个‘\0’的，所以按照函数逻辑，最终string被初始化成了一个容量和有效字符数为0、只含有一个'\0'的空串；

  对于析构函数：由于字符串的空间是我们申请的资源，所以一定要delete释放！

  对于拷贝构造和赋值重载，上面的写法是传统写法，思路是给字符串开辟同样大小的空间并将参数字符串的值拷贝过来；

  现代写法如下：

string(const string& str):_size(str._size),_capacity(_size)
{if (this != &str){string s(str._str);swap(_str, s._str);}}
string& operator=(string str)
{if (this != &str){_size = str._size;_capacity = str._capacity;swap(_str, str._str);}return *this;
}

思路：如果是自己给自己赋值就直接返回，否则，将有效个数和容量拷贝过来，对于指向资源的指针，直接进行交换即可。

分析两种写法：

核心任务是将右值（s）的内容复制到左值（当前对象）。传统做法是先释放左值的资源，再分配新内存并复制右值的数据，但这种方法存在两个问题：

• 需要两次动态内存分配（释放旧内存+分配新内存），效率低；
• 若分配新内存失败（抛异常），会导致左值处于“无效状态”（已释放旧内存，新内存未分配成功）。
• 而代码中的做法是用swap交换当前对象的内部指针（_str）和右值对象的内部指针：

swap(_str, s._str); // 交换当前对象和右值对象的内部指针
return *this;       // 返回当前对象的引用

交换后，当前对象持有右值对象的原有数据，而右值对象持有当前对象的原有数据（后续会被销毁，右值对象只是一个临时对象，所以销毁也无所谓）。这种方式相当于“偷”了右值对象的数据，避免了深拷贝。

3.string类的接口实现

（1）简单接口

iterator begin()
{return _str;
}
iterator end()
{return _str + _size;
}
const char* c_str()
{return _str;
}
int size()const
{return _size;
}
char& operator[](size_t pos)
{assert(pos >= 0 && pos < _size);return _str[pos];
}

（2）reserve扩容

void reserve(int n)
{if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}
}

  reserve的特点是扩容目标大于当前容量才执行，思路是用new申请一个指定大小的空间，然后将原数据拷贝进新的空间，然后将原数据释放掉，指向新空间，更新容量大小；

（3）push_back尾插

void push_back(const char c)
{if (_size == _capacity){int newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}_str[_size++] = c;_str[_size] = '\0';
}

插入之前要先检查扩容，扩容时如果字符串为空，就给4个字节；在插入字符后，不要忘记在最后添加'\0'；

（5）append拼接字符串

void append(const char* str)
{int len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}strcpy(_str + _size, str);_size += len;
}

思路：先看看当前的容量够不够拼接后字符串的长度，如果不够就扩容，然后将字符串复制到末尾即可，更新一下_size;

(6)"+="拼接字符、字符串

复用前面的函数即可；

string& operator+=(char c)
{push_back(c);return *this;
}
string& operator+=(const char* str)
{append(str);return *this;
}

（7）在指定位置插入字符、字符串

void insert(size_t pos, char c)
{assert(pos >= 0 && pos < _size);if (_size == _capacity){int newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}for (int i = _size+1; i > pos; i--){_str[i] = _str[i - 1];}_str[pos] = c;_size++;
}
void insert(size_t pos, const char* str)
{assert(pos >= 0 && pos < _size);int len = strlen(str);if (_capacity < _size + len){reserve(_size + len);}for (int i = _size + len; i > pos+len-1; i--){_str[i] = _str[i - len];}memcpy(_str + pos, str,len);_size += len;
}

  两者的思路类似：都是先检查下标的合法性和检查容量是否要扩容，然后移动元素，赋值元素，注意拷贝字符串的时候，要用memcpy而不是strcpy，因为strcpy会添加'\0'；

（8）指定位置删除指定长度的字符串

void erage(int pos, size_t len = npos)
{assert(pos >= 0 && pos < _size);assert(_size > 0);if (len == npos || len >= _size - pos){_str[pos] = 0;_size = pos;}else{strcpy(_str + pos, _str + pos + len);_size -= len;}
}

该函数默认情况下会将pos及后面的字符全部删除；

思路：先检查下下标是否合理，以及是否有剩余字符；

如果是默认情况或者指定长度大于pos后面的长度，就直接让pos处为0即可；

否则就将待删除字符串后面的字符串拼接过来；

（9）查找字符、字符串

int find(char c, int pos)
{assert(pos < _size);for (int i = pos; i < _size; i++){if (_str[i] == c){return i;}}return npos;
}
int find(const char* str, int pos)
{assert(pos < _size && pos>=0);char* s = strstr(_str + pos, str);if (str == nullptr) return npos;return s - _str;
}

（10）截取字符串

string substr(int pos = 0, int len = npos)
{if (len == npos || len > _size - pos){return string(_str + pos);}string str;str.reserve(len);for (int i = 0; i < len; i++){str+= _str[pos + i];}return str;}

该函数默认情况下会将pos后面的字符串全部截取；

如果是默认情况或者剩余空间少于截取长度，就直接创建一个string对象返回；

否则，也是创建一个临时string对象，预留上len的空间大小，将字符一个个拼接过来，注意这里不能用str[i]，因为预留空间只是改变容量，不是改变有效字符个数，所以用下标访问会越界！

（11）比较字符串大小

bool operator<(const string& str)const
{return strcmp(_str, str._str) < 0;
}
bool operator<=(const string& str)const
{return *this < str && *this == str;
}
bool operator==(const string& str)const
{return strcmp(_str, str._str) == 0;
}
bool operator>(const string& str)const
{return !((*this) <= str);
}
bool operator>=(const string& str)const
{return !(*this < str);
}
bool operator!=(const string& str)const
{return !(*this == str);
}

内容清空：

void clear()
{_str[0] = 0;_size = 0;
}

（12）>>和<<的重载

const size_t string:: npos = -1;
ostream& operator<<(ostream& out, string& str)
{for (int i = 0; i < str.size(); i++){out << str[i];}return out;
}
istream& operator>>(istream& in, string& str)
{str.clear();char ch;in.get(ch);while (ch != ' ' && ch != '\n'){str += ch;in.get(ch);}return in;
}

为了保证操作数的顺序正确，我们要在类外重载；

4. 写时拷贝

写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。

引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给 计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该 对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。

浅拷贝不是会因为共享同一片资源导致多次释放而崩溃吗，有了引用计数之后，就不会多次释放了！