【C++修炼秘籍】string

---

目录

---

前言

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

而C++中的string类相比C语言的字符串使用更加简单、方便、快捷，基本很少有人去使用C库中的字符串操作函数
 

---

一、标准库里的string

1、字符串是表示字符序列的类
2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作
单字节字符字符串的设计特性。
3. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信
息，请参阅basic_string)。
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits
和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
5. 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。
 

二、string常用接口功能简介（具体使用和底层转到模拟实现）

1、string类的常见构造函数

(constructor)函数名称	功能说明
string() （重点）	构造空的string类对象，即空字符串
string(const char* s) （重点）	用C-string来构造string类对象
string(size_t n, char c)	string类对象中包含n个字符c
string(const string&s) （重点）	拷贝构造函数

2、string类对象的容量操作

函数名称	功能说明
size（重点）	返回字符串有效字符长度
length	返回字符串有效字符长度
capacity	返回空间总大小
empty （重点）	检测字符串释放为空串，是返回true，否则返回false
clear （重点）	清空有效字符
reserve （重点）	为字符串预留空间**
resize （重点）	将有效字符的个数该成n个，多出的空间用字符c填充

❗️ 注意：

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类对象的访问及遍历操作

函数名称	功能说明
operator[] （重 点）	返回pos位置的字符，const string类对象调用
begin+ end	begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭 代器
rbegin + rend	begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭 代器
范围for	C++11支持更简洁的范围for的新遍历方式

4、 string类对象的修改操作 

函数名称	功能说明
push_back	在字符串后尾插字符c
append	在字符串后追加一个字符串
operator+= (重点)	在字符串后追加字符串str
c_str(重点)	返回C格式字符串
find + npos(重点)	从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
rfind	从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
substr	在str中从pos位置开始，截取n个字符，然后将其返回

❗️ 注意：

1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。

5、 string类非成员函数

函数	功能说明
operator+	尽量少用，因为传值返回，导致深拷贝效率低
operator>> （重点）	输入运算符重载
operator<< （重点）	输出运算符重载
getline （重点）	获取一行字符串
relational operators （重点）	大小比较

三、string的模拟实现

模拟实现仅是简单地实现功能，主要是加深使用；所有接口均在如下类中实现；

#pragma once//防止冲突，设置命名空间
namespace my{class string{public:private:char* _str;size_t _size;//数据大小size_t _capacity//空间大小;};
}

 1、string的构造函数

 1.1string()     //生成空字符串

        //生成空字符串string(){_str = new char[1];_str[0] = '\0';_size = _capacity = 0;}

空的时候最少要开一个，本次模拟实现的底层是用C的字符串，必须存放一个"\0"标记字符串结尾； 

1.2   string(const char* str)     //用C - string来构造string类对象 

	//用C - string来构造string类对象string(const char* str){_size = strlen(str);_capacity = _size;_str = new char[_capacity + 1];strcpy(_str, str);}

1.3string(const string&s)    //拷贝构造函数

        //拷贝构造string(const string&s){	_str = new char[s._capacity + 1];_capacity = s._capacity;_size = s._size;strcpy(_str, s._str);}

 2、string类对象的容量操作

2.1size    //返回字符串有效长度

		size_t size()const{return _size;}

 2.2capacity    // 返回空间总大小

        size_t capacity()const{return _capacity;}

2.3empty   //检测字符串释放为空串，是返回true，否则返回false 

	bool empty()const{return this->_size == 0;}

2.4clear   //清空有效字符 

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

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

2.5resver  //为字符串预留空间

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

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

2.6resize     //将有效字符的个数该成n个，多出的空间用字符c填充 

      void resize(size_t n, char ch = '\0'){if (n > _size){reserve(n);for (size_t i = _size; i < n; ++i){_str[i] = ch;}_size = n;_str[_size] = '\0';}else{_str[n] = '\0';_size = n;}}

resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。

注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大
小，如果是将元素个数减少，底层空间总大小不变。

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

 3.1operator[]        //返回pos位置的字符，const string类对象调用

模拟实现

	char& operator[](size_t pos){return _str[pos];}

    char& operator[](size_t pos)const{return _str[pos];}

 使用示例：

void func(const string& s){for (size_t i = 0; i < s.size(); i++){s[i]++;}}
int main(){	string s1("hellow world");for (int i = 0; i < s1.size(); i++){s1[i]++;}func(s1);
}

 为什么实现这个const版本呢，就是为了应对func函数所对应的使用情况；我们知道，const的权限不能放大只能缩小；

 3.2迭代器和范围for遍历

模拟实现

在string中，我们可以把迭代器当作一个原生指针；

        //迭代器typedef char* iterator;

        iterator begin(){return _str;}iterator end(){return _str+size();}

  使用示例：

        string s1("hellow world");//迭代器打印string::iterator it = s1.begin();while (it != s1.end()){std::cout << *it;++it;}std::cout << std::endl;//范围for打印for (auto& e : s1){std::cout << e;}std::cout << std::endl;

其实范围for的迭代器的的底层就是替换成迭代器 ；

当把类中的begin()屏蔽后，范围for的报错是：

 在反汇编中也清晰看到就是调用的迭代器

4、 string类对象的修改操作  

4.1push_back   //在字符串后尾插字符c

模拟实现 

        void push_back(char ch){if (_size == _capacity){size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newCapacity);}_str[_size] = ch;++_size;_str[_size] = '\0';}

4.2append   //在字符串后追加一个字符串 

模拟实现 

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

 4.3operator+=   //追加字符串

模拟实现

追加一个字符 

	    string& operator+=(char ch){push_back(ch);return *this;}

追加一个字符串 

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

 4.5c_str   //返回C格式字符串

模拟实现

        const char* c_str() const{return _str;}

 4.6find   //从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置

模拟实现 

 查找单个字符

	size_t find(char ch, size_t pos = 0) const{assert(pos < _size);while (pos < _size){if (_str[pos] == ch){return pos;}++pos;}return npos;}

查找字符串 

        size_t find(const char* str, size_t pos = 0) const{assert(pos < _size);const char* ptr = strstr(_str + pos, str);if (ptr == nullptr){return npos;}else{return ptr - _str;}}

---