STL库：string

---

1.STL库对于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)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作

简言之：

1. string 是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作 string 的常规操作
3. string 在底层实际是 basic_string 模板类的别名 typedef basic_string string;
4. 不能操作多字节或者变长字符的序列

---

2.string常用接口的掌握

2.1 string的构造接口

string类的构造函数接口很多，记住以下常用的就可以：

1. string(); // 默认构造，构造空的string类对象，即空字符串""

2. string (const string& str); // 拷贝构造，用已有的string类对象去构造string类对象

3. string (const char* s); // 用c-string来构造string类对象

4. string (const char* s, size_t n); // 用c-string前n个字符来构造string类对象

5. string (size_t n, char c); // 用n个c字符来构造string对象

6. template // 用迭代器[first,last)范围内的字符序列构造string类对象

   string (InputIterator first, InputIterator last);

接口使用举例：

// string constructor
#include <iostream>
#include <string>int main()
{std::string s0 ("Initial string");                  //string(const char* s);std::string s1;                                    // string();---空串里放了一个字符\0std::string s2 (s0);                               // string(cosnt string& str);std::string s4 ("A character sequence");           // string(const char* s);std::string s5 ("Another character sequence", 12); // string(const char* s,size_t n);std::string s6 (10, 'x');                          // string(size_t n,char c);std::string s7 (s0.begin(), s0.begin() + 7);       // string(InputIterator first,InputIterator last);return 0;
}

注意：空串并不是没有，而是第一个字符放的\0，存储空间不为0

---

2.2 string的容量操作接口

1. size：返回字符串有效长度(为了统一设计，所有容器都是用size表示有效元素个数，而抛弃了使用length)
2. length：返回字符串有效字符长度（这是早期提供的接口）
3. resize：将字符串大小调整为 n 个有效字符的长度
4. capacity：返回有效字符的最大容量（即已分配 size 的大小）
5. reverse：更改容量（capacity）的大小
6. clear：清空字符串的内容，变为空字符串（size 变为 0，不改变 capacity 的大小）
7. empty：检测字符串是否为空串，是返回 true，否则返回 false

对于容量操作我们主要看resize、reverse：

1.resize函数的两种重载形式：

//resize的两种重载形式
void resize (size_t n);
void resize (size_t n, char c);//举例代码
void Test1()
{string s("hello");// 将s中有效字符个数增加到10个，多出位置用'a'进行填充// "helloaaaaa"s.resize(10, 'a');cout << s.size() << endl;     // 10cout << s.capacity() << endl; // 15cout << s << endl;            // s: "helloaaaaa"// 将s中有效字符个数增加到20个，多出位置用缺省值'\0'进行填充// 如果resize参数大于原有 capacity 大小，会进行增容// "helloaaaaa\0\0\0\0\0\0\0\0\0\0"s.resize(20);cout << s.size() << endl;     // 15cout << s.capacity() << endl; // 31cout << s << endl;            // s: "helloaaaaa"// 如果resize参数x原有 capacity 大小// 将s中有效字符个数缩小到2个// "he"s.resize(2);cout << s.size() << endl;     // 2cout << s.capacity() << endl; // 31cout << s << endl;            // s: "he"// 将s的内容清空，注意清空时只是将size置0，不改变capacity的大小s.clear();cout << s.size() << endl;     // 0cout << s.capacity() << endl; // 31cout << s << endl;            // s: ""return 0;
}

2.reserve函数的形式：

//reserve函数的形式
void reserve (size_t n = 0);//举例代码
void Test2()
{string s("hellohellohello");// 如果reserve参数大于原有 capacity 大小，会进行增容s.reserve(20);cout << s.size() << endl;     // 15cout << s.capacity() << endl; // 31// 测试reserve参数小于原有 capacity 大小，是否会将空间缩小呢？// VS2019下，如果字符串有效长度size大于参数10，不会缩小，如果字符串长度小于参数10，会缩小// 当然，这个也和编译器平台有关系s.reserve(10);cout << s.size() << endl;     // 15cout << s.capacity() << endl; // 31（VS2019）
}

3.思考：reverse扩容的大小：

void Test3()
{string s;cout << "initial value: " << s.capacity() << endl;size_t sz = s.capacity();for (size_t i = 0; i < 500; i++){s.push_back('a');if (s.capacity() != sz){sz = s.capacity();cout << "capacity changed: " << sz << endl;}}
}

结论：VS下是1.5倍扩容，Linux下是2倍扩容

---

2.3 string的访问操作接口

string的访问操作通常使用[]运算重载来实现，就行数组下标一样

operator[]：返回对字符串中 pos 位置处的字符的引用（string 类对象支持随机访问）（一般物理地址是连续的才支持）

//operator[]函数的两种重载形式
char& operator[] (size_t pos);
const char& operator[] (size_t pos) const;//注意：operator[] 函数会自动检查越界（pos 必须小于 size），不像下标一样随机检查

---

2.4 string的迭代器遍历操作接口

1. begin(iterator)：返回指向第一个有效字符的迭代器
2. rbegin(reverse_iterator)：反向迭代器（可以反向遍历对象）
3. end：返回指向字符串末尾字符的迭代器（即最后一个有效字符的下一个位置）
4. rend：反向迭代器
5. 范围for：C++11支持更简洁的范围 for 的新遍历方式（底层其实是被替换成迭代器，所以支持迭代器就支持范围 for）

1.string迭代器的使用举例：

//普通迭代器和const迭代器
iterator begin();             // 可读可写
const_iterator begin() const; // 只读//举例代码
void test(const std::string& s)
{// const对象必须要用const迭代器std::string::const_iterator it = s.begin();while (it != s.end()) {std::cout << *it;it++;}
}int main()
{std::string s1;std::string s2("hello");// for+operator[]遍历for (size_t i = 0; i < s.size(); ++i)cout << s2[i] << endl;// 正向迭代器遍历// 注意：这里不建议写成it < s2.end()，比如链式结构的容器，就没法用了// 所以统一写成 it != s2.end()std::string::iterator it = s2.begin();while (it != s2.end()) {std::cout << *it;it++;}// 反向迭代器遍历for (std::string::reverse_iterator rit = s2.rbegin(); rit != s2.rend(); ++rit)std::cout << *rit;for (auto rit = s2.rbegin(); rit != s2.rend(); ++rit) // 用auto简化代码std::cout << *rit;// 范围for遍历，支持迭代器的容器就支持范围forfor (auto& e : s2) {std::cout << e;}return 0;
}

---

2.5 string的修改操作接口

1. operator+=：在当前字符串末尾追加字符串（追加 string / char* / char 类型的都可以）
2. append：在当前字符串末尾追加字符串
3. push_back：将一个字符附加到字符串的末尾（尾插）（void push_back (char c);）
4. swap：交换两个字符串的内容（注意：还存在一个具有相同名称的非成员函数 swap）
5. c_str：返回指向 C 格式字符串的数组的指针（const char* c_str() const;）
6. find：从 pos 位置开始往后找字符，返回该字符在字符串中的位置，如果未找到返回 npos
7. rfind：从 pos 位置开始往前找字符，返回该字符在字符串中的位置，如果未找到返回 npos
8. npos：作为返回值，通常用于表示不匹配（npos是一个静态成员变量 static const size_t npos = -1; ）
9. substr：在字符串中从 pos 位置开始，截取 len 个字符，然后将其作为新的 string 类对象返回

insert、erase不介绍，因为要挪动字符，时间效率太低

追加内容举例代码：

void Test4()
{string s1("hello");string s2("world");s1 += ' ';   // 追加字符s1 += s2;    // 追加string类对象s1 += "!!!"; // 追加字符串
}//c_str举例代码
void Test7()
{string s("hello");printf("%s\n", s.c_str());
}

find函数介绍：

// 从pos位置开始往后找，默认从第一个字符的位置（即pos = 0）开始找
size_t find (const string& str, size_t pos = 0) const;
size_t find (const char* s, size_t pos = 0) const;
size_t find (const char* s, size_t pos, size_t n) const; // 从pos位置往后匹配n个字符
size_t find (char c, size_t pos = 0) const;void Test6()
{// 取出url中的协议、域名、uristring url("http://www.cplusplus.com/reference/");size_t pos1 = url.find("://");if (pos1 != string::npos) {cout << url.substr(0, pos1 - 0) << endl;}size_t pos2 = pos1 + 3;            // 'w'的位置size_t pos3 = url.find('/', pos2); // '/'的位置，从pos2开始查找if (pos3 != string::npos){cout << url.substr(pos2, pos3 - pos2) << endl;}cout << url.substr(pos3) << endl;
}

substr函数介绍：

// len: 从pos位置开始，要截取字符的个数
string substr (size_t pos = 0, size_t len = npos) const; // 若len缺省，默认截取到字符串最后void Test5()
{// 取出文件1的后缀string file1("test.txt");size_t pos = file1.find(".");if (pos != string::npos){cout << file1.substr(pos) << endl; // .txt// cout << file.substr(pos, file1.size() - pos) << endl;}// 取出文件2的后缀string file2("test.txt.zip");size_t rpos = file2.rfind(".");if (rpos != string::npos){cout << file2.substr(rpos) << endl; // .zip}
}

---

2.6 string的非成员函数重载接口

1. std::operator>>：流提取运算符重载
2. std::operator<<：流插入运算符重载
3. std::getline：获取一行字符串，直到遇到换行符 ‘\n’
4. relational operators：关系运算符，进行大小比较
5. std::operator+：尽量少用，因为是传值返回，导致深拷贝效率低
6. std::swap：交换两个字符串的值

//getline的介绍
// istream& getline (istream& is, string& str);
string s;
getline(cin, s);

---

2.7 string的特殊判断接口

C语言头文件<ctype.h>中处理字符的接口：

1.字符串处理函数：

• int isalpha(int c)：检查字符是否为字母，是返回非零(true)，不是则返回0(false)
• int isdigit(int c)：检查字符是否为十进制数字，是返回非零(true)，不是则返回0(false)

2.字符转换函数：

• int tolower(int c)：把字母转换成小写字母，返回转换之后的字符
• int toupper(int c)：把字母转换成大写字母，返回转换之后的字符

C++头文件中处理字符的接口：

1.函数 std::to_string（C++11）：将数值转换为字符串，返回 string 类对象

2.函数 std::stoi（C++11）：将字符串转换为整数，返回 int 整数

C++头文件中反转排序接口：

1.函数 std::reverse：反转范围 [first,last) 中元素的顺序

// 传一段迭代器区间 [first, last)
template <class BidirectionalIterator> // 双向迭代器
void reverse (BidirectionalIterator first, BidirectionalIterator last);

2.函数 std::sort：将 [first,last) 范围内的元素按升序排序

// 传一段迭代器区间 [first, last)，默认排升序，若要排降序，需要传仿函数
template <class RandomAccessIterator, class Compare> // 随机访问迭代器
void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

---

3.string的模拟实现

3.1 string类的结构实现

#include<iostream>
#include<cstring>
#include<cassert>
using namespace std;namespace winter
{class string{private:char* _str;       // 指向字符数组size_t _size;     // 有效字符数size_t _capacity; // 有效字符容量，不包含最后作标识的'\0'static const size_t npos;public:/*******************************************************/// 迭代器typedef char* iterator;typedef const char* const_iterator;iterator begin() { return _str; } // 返回指向第一个字符的迭代器iterator end() { return _str + _size; } // 返回指向最后一个字符下一个字符的迭代器const_iterator begin() const { return _str; } // 返回指向第一个字符的迭代器const_iterator end() const { return _str + _size; } // 返回指向最后一个字符下一个字符的迭代器/*******************************************************/// 默认成员函数：string(const char* str = ""); // 默认构造函数void swap(string& s); // 交换两个对象的内容string(const string& s); // 拷贝构造函数（深拷贝）string& operator=(string s); // 赋值运算符重载（深拷贝）~string(); // 析构函数/*******************************************************/// 访问元素，[]运算符重载char& operator[](size_t pos);             // 可读可写const char& operator[](size_t pos) const; // 只读不能写/*******************************************************/// 容量操作：// 获取字符串有效元素个数size_t size() const { return _size; } // 获取字符串容量（有效字符的最大容量）size_t capacity() const { return _capacity; } // 清空有效字符void clear() {_str[0] = '\0';_size = 0;}// 更改容量（capacity）的大小void reserve(size_t n); // 调整字符串有效字符的长度void resize(size_t n, char ch = '\0'); /*******************************************************/// 修改操作：string& insert(size_t pos, const char ch); // 在pos位置插入一个字符string& insert(size_t pos, const char* str); // 在pos位置插入一个字符串void push_back(const char ch); // 尾插一个字符void append(const char* str); // 在当前字符串末尾追加一个字符串string& operator+=(const char ch); // 当前字符串末尾追加一个字符/字符串string& operator+=(const char* str);string& operator+=(const string& s);        string& erase(size_t pos = 0, size_t len = npos); // 删除从pos位置开始的len个字符/*******************************************************/// String operations// 从pos位置开始查找字符，若找到，则返回该字符的下标，若没找到，则返回npossize_t find(char ch, size_t pos = 0) const;// 从pos位置开始查找子串，若找到，则返回该子串首字符的下标，若没找到，则返回npossize_t find(const char* str, size_t pos = 0) const;// 返回指向 C 格式字符串的数组的指针char* c_str() const { return _str; }};const size_t string::npos = -1;
};

---

3.2 string的默认成员函数模拟实现

1.默认构造函数

// 默认构造函数
string(const char* str = "")  // 空串并不是什么都没有，第一个字符为'\0':_size(strlen(str)),_capacity(_size)
{_str = new char[_capacity + 1]; // 多开一个空间是存放'\0'的strcpy(_str, str);              // 拷贝数据
}

2.交换容器内容swap函数

// s1.swap(s2);
void swap(string& s)
{// 函数名冲突，指定去调用全局域里面的::swap::swap(_str, s._str);::swap(_size, s._size);::swap(_capacity, s._capacity);
}

3.拷贝构造函数

// 拷贝构造函数（深拷贝）
// s2(s1)
string(const string& s):_str(nullptr) // 当前对象是一个正在构造的对象，成员变量还未初始化，是一个随机值，所以先置空,_size(0),_capacity(0)
{string tmp(s._str); // 拿s的内容，调用构造函数构造临时对象tmpthis->swap(tmp);    // 将临时对象tmp和当前对象的成员变量分别进行交换
}

4.赋值运算符重载

// 赋值运算符重载（深拷贝）
// s1 = s2
string& operator=(string s)
{this->swap(s); // 将拷贝构造的对象s和当前对象的成员变量分别进行交换return *this;  // 返回当前对象
}

5.析构函数

// 析构函数
~string()
{delete[] _str;_str = nullptr;
}

---

3.3 string的浅拷贝、深拷贝问题

需要「深拷贝」的类，其内部往往是很复杂的，是需要用户显式定义拷贝构造函数来完成「深拷贝」的

浅拷贝举例代码：

namespace winter
{class string{private:char* _str;public:// 构造函数string(const char* s):_str(new char[strlen(s) + 1]){strcpy(_str, s);}// 析构函数~string(){delete[] _str;_str = nullptr;}};void test(){string s1("hello"); // 用一个常量字符串去构造string类对象s1string s2(s1); // s2调用编译器默认生成的拷贝构造函数}
}

通过调试可以看到：编译器默认生成的拷贝构造函数是「浅拷贝」，会导致两个 string 对象中的字符指针 _str 指向的是同一个字符数组。（因为浅拷贝只拷贝了 _str 数组指针的 4 个字节的内容）

所以在上述类中必须要显式定义拷贝构造函数，否则编译器默认生成的拷贝构造函数无法正常完成拷贝

• 总结：上述 string 类没有显式定义其拷贝构造函数与赋值运算符重载函数，此时编译器会默认生成一个，当用 s1 构造 s2 时，编译器会调用默认生成的拷贝构造函数。最终导致：s1 和 s2 共用同一块内存空间，在调用析构函数清理对象资源时，同一块空间被释放多次，引起程序崩溃，这种拷贝方式是浅拷贝，而我们实际需要的是深拷贝
• 浅拷贝：也称位拷贝，编译器只是将对象中的数据「按字节序」拷贝过来。如果对象中管理的有其它资源（比如堆上的资源），那就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而另一些对象不知道该资源已经被释放，以为还有效，就继续对资源进行操作（比如增删查改），此时就会发生违规访问
• 深拷贝：给每个对象独立分配资源，保证多个对象之间不会因为共享资源问题而造成多次释放资源，导致程序崩溃
• 浅拷贝引发的问题：同一块空间会被析构多次，一个对象修改会影响另外一个对象

---

3.4 string的拷贝构造的深拷贝实现

string的拷贝构造的深拷贝实现有两种写法：传统写法、现代写法

1.拷贝构造深拷贝传统写法：

//浅拷贝
string(const char* s):_str(new char[strlen(s) + 1])
{strcpy(_str, s);
}// 显式定义拷贝构造函数（深拷贝）
string(const string& s) // 保护形参不被改变，加引用防止无穷递归:_str(new char[strlen(s._str) + 1])  // 给新对象申请一段和原对象一样大小的空间
{strcpy(_str, s._str); // 把原对象的数据一一拷贝给新对象
}//测试代码
void test()
{string s1("hello"); // 用一个常量字符串去构造string类对象s1string s2(s1); // s2调用编译器默认生成的拷贝构造函数
}

2.深拷贝的现代写法：

// 拷贝构造函数（深拷贝）
string(const string& s):_str(nullptr) // 当前对象是一个正在构造的对象，成员变量还未初始化，是一个随机值，所以先置空
{string tmp(s._str);   // 拿s的内容，调用构造函数构造临时对象tmpswap(_str, tmp._str); // 将临时对象tmp和当前对象的成员变量_str进行交换
}//测试代码
void test()
{string s1("hello"); // 用一个常量字符串去构造string类对象s1string s2(s1); // s2调用编译器默认生成的拷贝构造函数
}

---

3.5 string的赋值运算符重载函数的深拷贝实现

string的赋值运算符重载函数的深拷贝实现分为：传统写法、现代写法

需要「深拷贝」的类，其内部往往是很复杂的，是需要用户显式定义赋值运算符重载函数来完成「深拷贝」的

1.赋值运算符重载函数的深拷贝传统写法：

// 显式定义赋值运算符重载（深拷贝）
string& operator=(const string& s)
{if (this != &s) // 防止自己给自己赋值{char* tmp = new char[strlen(s._str) + 1]; // 重新开辟一块和s一样大小的空间delete[] _str;                            // 释放自己的空间_str = tmp;strcpy(_str, s._str);                     // 把s的数据拷贝过来}return *this;
}

2.赋值运算符重载函数的深拷贝现代写法：

通过参数间接调用拷贝构造函数，将「拷贝构造出来的 string 类对象 s」和「当前对象」的成员变量分别进行交换即可，这样当前对象就拿到了自己想要的内容，当函数调用结束后，拷贝构造出来的对象 s 出了作用域会被自动析构

// 赋值运算符重载（深拷贝）
// s1 = s2
// 写法一：
string& operator=(const string& s) // 传引用
{if (this != &s) // 防止自己给自己赋值{string tmp(s._str);   // 拿s的内容，调用构造函数构造临时对象tmpswap(_str, tmp._str); // 将临时对象tmp和当前对象的成员变量_str进行交换}return *this;
}// 写法二：
string& operator=(string s) // 重点：传值
{// 传参时，调用拷贝构造函数，拷贝构造了一个string类对象s// 将拷贝构造出来的string类对象s和当前对象的成员变量_str进行交换swap(_str, s._str);return *this; // 返回当前对象
}

---

3.6 string的迭代器模拟实现

class string
{private:char* _str;       // 指向字符数组size_t _size;     // 有效字符数size_t _capacity; // 有效字符容量，不包含最后作标识的'\0'static const size_t npos;public:/*******************************************************/// 迭代器// iterator是内嵌类型，在stirng类域里面定义的类型typedef char* iterator;typedef const char* const_iterator;iterator begin() { return _str; } // 返回指向第一个字符的迭代器iterator end() { return _str + _size; } // 返回指向最后一个字符下一个字符的迭代器const_iterator begin() const { return _str; } // 返回指向第一个字符的迭代器const_iterator end() const { return _str + _size; } // 返回指向最后一个字符下一个字符的迭代器// ...// ...
};
const size_t string::npos = -1;//测试代码
void test3()
{string s1("hello world");// iterator是内嵌类型，在stirng类域里面定义的类型// 告诉编译器，要到string类域里面去找string::iterator it = s1.begin();while (it != s1.end()){cout << *it;it++;}cout << endl;// 范围for的原理就是被替换成迭代器for (auto e : s1){cout << e;}cout << endl;
}

---

3.7 string的访问操作运算符重载模拟实现

//对于普通数组来说：越界读一般是检查不出来的，越界写会抽查，可能会检查出来
//对于string类来说：越界读写都会被检查出来，因为[]中进行了严格的检查// 普通版本
char& operator[](size_t pos) // 可读可写
{assert(pos < _size);return _str[pos]; // *(_str + pos)
}//const版本
const char& operator[](size_t pos) const // 只读不能写
{assert(pos < _size);return _str[pos]; // *(_str + pos)
}

---

3.8 string的容量操作函数模拟实现

1.resize函数：调整字符串有效字符的长度

// 调整字符串有效字符的长度
void resize(size_t n, char ch = '\0')
{// 要调整的有效字符的长度小于原有 _size 大小if (n < _size){_size = n;          // 更新有效字符个数_str[_size] = '\0'; // 补上字符串结束标志'\0'}// 要调整的有效字符的长度大于原有 _size 大小else if (n > _size){// 要调整的有效字符的长度大于原有 _capacity 大小，先进行增容if (n > _capacity) reserve(n);// 多出的位置用字符 ch（缺省值'\0'）进行填充for (size_t i = _size; i < n; i++){_str[i] = ch;}_size = n;          // 更新有效字符个数_str[_size] = '\0'; // 补上字符串结束标志'\0'}
}

2.reverse函数：更改容量(capacity)的大小

// 更改容量（capacity）的大小
void reserve(size_t n)
{if (n > _capacity){// 开辟新空间char* tmp = new char[n + 1];strcpy(tmp, _str);  // 旧空间数据拷贝到新空间// 释放旧空间，使用新空间delete[] _str;_str = tmp;    // 指向新空间_capacity = n; // 更新容量}
}

---

3.9 string的修改操作函数模拟实现

1.insert函数：在pos位置插入一个字符

// 在pos位置插入一个字符串
string& insert(size_t pos, const char* str)
{assert(pos >= 0 && 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];}// 插入字符for (size_t i = 0; i < len; i++){_str[pos++] = str[i];}_size += len; // 更新有效字符个数return *this;
}

2.push_back函数：尾插一个字符

void push_back(const char ch)
{//方法一：// 先检查是否需要扩容if (_size >= _capacity){// 防止是空串""，容量为0，扩容失败size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity;reserve(newcapacity); // 扩2倍容}_str[_size] = ch;   // 尾插字符_size++;            // 有效字符个数+1_str[_size] = '\0'; // 补上字符串结束标志'\0'//方法二： 复用 insert 函数的代码 insert(_size, ch);
}

3.append函数：在当前字符串末尾追加一个字符串

void append(const char* str)
{//方法一：// 先检查是否需要扩容size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len); // 扩容}strcpy(_str + _size, str); // 尾插字符串（strcpy会拷贝'\0'，并在该点停止）_size += len;              // 有效字符个数+len//方法二：复用 insert 函数的代码 insert(_size, str);
}

4.+=运算符重载函数：在当前字符串末尾追加一个字符或字符串

string& operator+=(const char ch)
{push_back(ch);return *this;
}
string& operator+=(const char* str)
{append(str);return *this;
}
string& operator+=(const string& s)
{append(s._str);return *this;
}

5.erase函数：删除从 pos 位置（包含 pos 位置）开始的 len 个字符

erase删除分为两种情况：

1.情况一：

• 如果 len 缺省，表示从 pos 位置开始，后面的字符删除完
• 如果 pos + len >= _size，表示删除 [ pos, _size - 1 ] 区间的字符

2.情况二：

string& erase(size_t pos = 0, size_t len = npos)
{assert(pos >= 0 && pos < _size);// 1. 从pos位置开始，后面的字符删除完，这是一个O(1)的操作if (len == npos || pos + len >= _size){_str[pos] = '\0';_size = pos;}// 2. 从pos位置开始，后面的字符删除一部分，这是一个O(n)的操作else{strcpy(_str + pos, _str + pos + len);_size -= len;}return *this;
}

---

3.10 string的字符串操作函数模拟实现

1.find函数：从 pos 位置开始查找字符，若找到，返回该字符第一次出现的下标；若没找到，返回npos

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

2.find函数：从 pos 位置开始查找子串，若找到，返回该字符第一次出现的下标；若没找到，返回npos

size_t find(const char* str, size_t pos = 0) const
{assert(pos >= 0 && pos < _size);// 在原串中去匹配子串str// 匹配成功，返回子串str首字符的地址// 匹配失败，返回空指针const char* p = strstr(_str + pos, str);if (p) return p - _str; // 通过子串str首字符的地址，计算出首字符的下标else return npos;
}

---

3.11 string的特殊函数模拟实现

1.流插入<<运算符重载

// 流插入运算符重载
ostream& operator<<(ostream& out, const string& s)
{// 遍历string类对象 s ，一个一个字符的插入for (size_t i = 0; i < s.size(); i++){out << s[i];}return out;
}void test6()
{// 一般场景下，以下两种输出没有差别string s1("hello");cout << s1 << endl;         // 编译器当成自定义类型对象处理，匹配该类型重载的<<运算符cout << s1.c_str() << endl; // C_str()返回char*，编译器当成字符数组处理（内置类型）// 但是这种场景下有区别string s2("hello");s2.resize(10);s2[9] = 'x'; // 最后一个字符设为'x'// s2 = "hello\0\0\0\0x"cout << s2 << endl;         // 输出所有有效字符，"hello\0\0\0\0x"cout << s2.c_str() << endl; // 遇到'\0'终止，"hello"
}

2.流提取>>运算符重载

// 流提取运算符重载
istream& operator>>(istream& in, string& s)
{// 一个一个字符输入// 遇到空格或者换行符终止输入char ch;in >> ch; // 从流中获取一个字符while (ch != ' ' && ch != '\n'){s += ch;  // 把提取的字符追加到sting类对象 s 中去in >> ch; // 继续从流中获取下一个字符}return in;
}void test7()
{string s1;cin >> s1; // operator>>(cin, s1);cout << s1 << endl;
}

流提取运算符重载函数中，改成用 get() 函数获取字符：但还是存在一个小问题

// 流提取运算符重载
istream& operator>>(istream& in, string& s)
{// 一个一个字符输入// 遇到空格或者换行符终止输入char ch;ch = in.get(); // 从流中获取一个字符while (ch != ' ' && ch != '\n'){s += ch;       // 把提取的字符追加到sting类对象 s 中去ch = in.get(); // 继续从流中获取下一个字符}return in;
}void test6()
{string s1;cin >> s1; // operator>>(cin, s1);cout << s1 << endl;
}
void test7()
{string s1("hello");cin >> s1; // operator>>(cin, s1);cout << s1 << endl;
}

正确写法：

class string
{private:// ...
public:// ...void clear() // 清空所有有效字符{_str[0] = '\0';_size = 0;}// ...
};// 流提取运算符重载
istream& operator>>(istream& in, string& s)
{// 先清空所有有效字符s.clear();// 一个一个字符输入// 遇到空格或者换行符终止输入char ch;ch = in.get(); // 从流中获取一个字符while (ch != ' ' && ch != '\n'){s += ch;       // 把提取的字符追加到sting类对象 s 中去ch = in.get(); // 继续从流中获取下一个字符}return in;
}

3.getline函数:获取一行字符串，直到遇到换行符 ‘\n’

istream& getline(istream& in, string& s)
{// 先清空所有有效字符s.clear();// 一个一个字符的输入// 遇到换行符终止输入char ch;ch = in.get(); // 从流中获取一个字符while (ch != '\n'){s += ch;       // 把获取的字符追加到string类对象 s 中去ch = in.get(); // 继续从流中获取下一个字符}return in;
}

4.关系运算符>重载：关系运算符，进行大小比较

// 比较两个对象的大小（按字符ascii码比较）
// s1 > s2
bool operator>(const string& s1, const string& s2)
{// 指针 i 和 j 分别指向两个字符串的第一个字符size_t i = 0, j = 0;for (; i < s1.size() && j < s2.size(); i++, j++) // 同时遍历两个字符串{if (s1[i] != s2[j]) return s1[i] > s2[j];}if (i == s1.size() && j == s2.size()) return false; // 同时被遍历完，说明 s1 = s2else if (i == s1.size()) return false; // s1先被遍历完，说明 s1 < s2else if (j == s2.size()) return true;  // s2先被遍历完，说明 s1 > s2
}// s1 == s2
bool operator==(const string& s1, const string& s2)
{// 指针 i 和 j 分别指向两个字符串的第一个字符size_t i = 0, j = 0;for (; i < s1.size() && j < s2.size(); i++, j++) // 同时遍历两个字符串{if (s1[i] != s2[j]) return false;}if (i == s1.size() && j == s2.size()) return true; // 同时被遍历完，说明 s1 = s2else return false; // 有一个字符串没被遍历完
}// 下面的关系运算符重载，全都可以复用上面的代码// s1 != s2
bool operator!=(const string& s1, const string& s2)
{return !(s1 == s2);
}// s1 >= s2
bool operator>=(const string& s1, const string& s2)
{return s1 > s2 || s1 == s2;
}// s1 < s2
bool operator<(const string& s1, const string& s2)
{return !(s1 >= s2);
}// s1 <= s2
bool operator<=(const string& s1, const string& s2)
{return !(s1 > s2);
}

---

4.string类对象的大小计算

举例：

int main()
{string s1("xxx");              // 3个有效字符string s2("xxxxxxxxxxxxxxxx"); // 16个有效字符//我的VS2019得出都是28cout << sizeof(s1) << endl; // 输出：28cout << sizeof(s2) << endl; // 输出：28return 0;
}

思考：VS2019 下测试，输出28，按照我们上面模拟实现的版本应该是12，为什么会是28呢？

这其实和 VS 下 PJ 版本的 STL string 的实现有关：

1. 如果有效字符个数 < 16，不会去堆上开空间，而是存到一个名叫 _buf 的数组空间上，即存到对象中
2. 如果有效字符个数 >= 16，则会存到 _str 指向的堆空间上
3. 这样做可以减少内存碎片，提高效率

// VS下string的实现，大概是这样样子
class string
{private:char _buf[16];char* _str;size_t _size;size_t _capacity;
// ...
};

补充：Linux下输出8，所以当我们计算 string 类对象大小时，不要总不同而觉得奇怪，因为各家实现的版本可能会有所差异

---

5.写时拷贝的了解

首先回顾一下浅拷贝引发的问题：

• 同一块空间会被析构（释放）多次
• 一个对象修改会影响另外一个对象

为了解决这两个问题：

1. 为了应对同一块空间会被析构多次这个问题，提出了引用计数
   • 引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成 1，每增加一个对象使用该资源，就给计数增加 1，当某个对象被销毁时，先给该计数减 1，然后再检查是否需要释放资源，如果计数为 1，说明该对象是资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源
2. 为了应对一个对象修改会影响另外一个对象这个问题，提出了写时拷贝计数
   • 写时拷贝就是一种拖延症，是在「浅拷贝」的基础之上增加了引用计数的方式来实现的
   • 多个对象共用同一块内存空间，哪个对象去写数据，哪个对象就再进行深拷贝，本质是一种延迟深拷贝。当然，如果不进行写数据，那就不用进行深拷贝，提高了效率
   • 但这种方案也是有副作用的，现在基本上也被放弃了

写时拷贝的验证：

#include<iostream>
#include<string>
int main()
{std::string s1("hello world");std::string s2(s1);              // 拷贝构造printf("%p\n", s1.c_str()); // c_str()函数返回其指向字符数组的地址printf("%p\n", s2.c_str());// 修改s2[0] = 'x';printf("%p\n", s1.c_str());printf("%p\n", s2.c_str());return 0;
}

运行结果（VS2019 下 PJ 版本的 STL）：没有用写时拷贝技术，直接深拷贝

运行结果（Linux 下 SGI 版本的 STL）：这个早期15年的版本用了写时拷贝技术，加上了引用计数

STL库：string相关推荐

1. C++ STL库 string类型常见操作

   #include <iostream> using namespace std; int main() {/* 初始化 1 个 字符串(默认为空串, 即"") */st ...

2. STL库中string类内存布局的探究

   在STL中有着一个类就是string类,他的内存布局和存储机制究竟是怎么样的呢? 这就是建立好的string 可以看出,图中用黄色框框标注的部分就是主要区域 我们用来给string对象进行初始化的字符 ...

3. C++STL库：String介绍

   C++STL库 学习方法:使用STL的三个境界:能用,明理,能扩展. 今天我们开启一个新主题:C++数据结构之STL库,我们将介绍STL库里常用库的用法与实现过程. 常用库 库名称 所需头文件 数据结 ...

4. STL 的string类怎么啦？

   STL 的string类怎么啦? 陈皓 前言 上个周末在和我的同学爬香山闲聊时,同学说到STL中的string类曾经让他备受折磨,几年前他开发一个系统前对string类还比较清楚,然后随着程序的复杂度 ...

5. C++11 中STL库中新增内容

   C++ 11一个比较显著的变化是以前boost库中的一些函数被正式标准化合入到STL中了,本文就简单的介绍一下. 引用包装器(Reference Wrapper) 当模板函数参数为泛型类型的时候,无法 ...

6. c++中algorithm头文件、STL库简介及使用说明

   c++中algorithm头文件.STL库简介及使用说明 c++中algorithm头文件是STL的算法部分,里边定义了各种算法,比如sort之类的.加上algorithm就可以使用stl库里的各种算 ...

7. C++STL之string (转)

   在学习c++STL中的string,在这里做个笔记,以供自己以后翻阅和初学者参考. 1:string对象的定义和初始化以及读写 string s1;      默认构造函数,s1为空串 string ...

8. [c++]巧用stl库-啤酒与尿布

   [c++]<-巧用stl库-> 啤酒与尿布 前言 大家好,楼主计算机专业大学狗一枚.<啤酒与尿布>是专业课的一道课后习题,觉得我个人思路比较新颖,在此分享.能力一般,水平有限, ...

9. 例题5-3安迪的第一个字典 UVa10815--C++STL库映射set的应用

   前言 不定期更新C++的STL库以及算法练习的笔记 分享给大家 也是督促自己不断努力学习算法与程序设计 学习算法之前,要想高效简洁的写好代码,还需要熟练掌握STL库的一些方法和数据结构 参考书籍: & ...

最新文章

1. 【Ubuntu】Ubuntu14.04添加163的源
2. 《FlaskWeb开发：基于Python的Web应用开发实战》笔记
3. DeepLink用法及源码解析
4. javascript 面向对象编程小记
5. Java线程间通信-回调的实现方式
6. 盘阵多路径学习（转）
7. 从GitHub存储库下载单个文件夹或目录
8. YUI：globle object
9. 模块参考资料-Cat.1模块选型手册-
10. c语言零基础自学软件下载,C语言入门学习下载-C语言入门学习app下载v1.0-52PK下载中心...
11. 如何提取mp4中的音频？
12. 即时通讯系统集成开发
13. 如果光猫+hadoop，有化学反应吗？
14. Python+OpenCV手势识别Mediapipe（基础篇）
15. 汉信码(Hanxin Code)与QR码(QR Code)的终极对决
16. 用Springboot写饼状图
17. 电脑重新分区后文件怎么恢复？流水的难题铁打的办法
18. 渗透测试sec123笔记
19. Struts2的常量及配置：
20. css 文字两端对齐

热门文章

1. 灰度重心法提取中心线遇到的问题
2. iOS应用开发入门（1）——第一个iOS应用
3. Uni-App - 接口 - 第三方登录（H5+ APP）（Hcoder 版）
4. 前端局部刷新的几种方式
5. java组件叠加显示,如何让上层的组件一直在上层显示
6. 小程序源码：喝酒神器新UI版本带特效和音效,-多玩法安装简单
7. AlphaStar 实战技巧分析
8. C#用于登录数据库的方法
9. Socket的超时时间
10. freemarker模板生成pdf文件