C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数， 但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
1.string类
1.string类是表示字符序列的类
2.标准的string类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
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. 不能操作多字节或者变长字符的序列。
在使用string类时，必须包含#include<string>头文件以及using namespace std
2.string类的接口
2.1 成员函数
string构造函数
| 函数名称 | 功能说明 |
| string() | 默认构造函数，创建一个空字符串。 |
| string(const char* str) | 使用C风格的字符串s构造一个string对象。 |
| string(const string& str) | 拷贝构造函数，用一个已有的string对象来构造新的对象。 |
| string(size_t n, char c) | 用字符c重复n次构造新的字符串。 |
| string(const char* str, size_t n) | 创建一个字符串对象，其内容是由 C 风格的字符串 str 的前 n 个字符给定的 |
| string(const string& str, size_t pos, size_t n = npos) | 创建一个字符串对象，其内容是字符串对象 str 中从位置 pos 开始的 n 个字符 |
| template <class InputIterator> string(InputIterator begin, InputIterator end) | 创建一个字符串对象，其内容是由迭代器对 [begin, end) 中的字符序列给定的 |
下面是这些接口的测试：
#include <iostream>
#include <string>
using namespace std;
int main()
{
// 1.string()
string s1; // 构造空的string类对象s1
// 2.string(const char* str)
string s2("Hello World\n"); // 用C格式字符串构造string类对象s2
string s3 = "Hello World";
// 3.string(const string& str)
string s31(s3); // 拷贝构造s3
cout << s31 << endl; // Hello World
// 4.string(size_t n, char c)：用字符c重复n次构造新的字符串。
string s4(3, 'a');
cout << s4 << endl; // aaa
// 5.string(const char* str, size_t n) ：创建一个字符串对象，其内容是由 C 风格的字符串 str 的前 n 个字符给定的
string s5("Hello World", 5); // 取字符串前5个
cout << s5 << endl; // Hello
// 6.string(const string& str, size_t pos, size_t n = npos) ：创建一个字符串对象，其内容是字符串对象str中从位置pos开始的 n 个字符
string s6(s3, 6, 3); // 从s3的第6个字符开始取后三个字符
cout << s6 << endl; // Wor
string s7(s3, 6, 13); // 取13个字符，超过了，就有多少取多少
cout << s7 << endl; // World
string s8(s3, 1); // 取1后面的所有字符
cout << s8 << endl; // ello World
for (size_t i = 0; i < s2.size(); i++)
{
s2[i]++;
}
cout << s2 << endl; // Ifmmp!Xpsme */
// 7.template <class InputIterator> string(InputIterator begin, InputIterator end)：创建一个字符串对象，其内容是由迭代器对 [begin, end) 中的字符序列给定的
char arr[] = {'H', 'e', 'l', 'l', 'o'};
string str(begin(arr), end(arr)); // Hello
cout << str << endl;
return 0;
}string赋值运算
| 函数名称 | 功能说明 |
| string& operator=(const string& str)； | 将一个字符串对象 str 赋值给当前的字符串对象，返回当前字符串对象的引用。 |
| string& operator=(const char* s) | 将一个 C 风格的字符串 s 赋值给当前的字符串对象，返回当前字符串对象的引用。 |
| string& operator=(char c) | 将一个字符 c 赋值给当前的字符串对象，返回当前字符串对象的引用。 |
#include <iostream>
#include <string>
using namespace std;
int main()
{
// 1.string& operator=(const string& str)
string str1 = "Hello";
string str2 = "World";
str1 = str2; // 将 str2 的值赋给 str1
cout << str1 << endl; // 输出：World
// 2.string& operator=(const char* s)
string str3 = "Hello";
str3 = "World"; // 将 C 风格字符串 "World" 赋给 str
cout << str3 << endl; // 输出：World
// string& operator=(char c)
string str4 = "Hello";
str4 = 'W'; // 将字符 'W' 赋给 str
cout << str4 << endl; // 输出：W
return 0;
}string析构函数
string 类的析构函数会自动被编译器生成，无需手动实现。当一个 string 类型的对象生命周期结束时，其析构函数会被自动调用，用于释放对象占用的内存空间。
string 类的析构函数没有任何参数，也没有返回值。它会自动释放对象占用的内存，包括对象所持有的动态内存和任何由 string 对象分配的缓冲区。
例如，当一个 string 类型的对象超出作用域、被 delete 运算符释放或者存储它的容器被销毁时，其析构函数会被自动调用。
2.2 string对象访问以及迭代器
string的遍历方式
| 函数名称 | 功能说明 |
| char& operator[](size_t pos) const char& operator[](size_t pos) const |
返回pos位置的字符，const string类对象调用 |
| iterator begin() const_iterator begin() const iterator end() const_iterator end() const |
begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器 |
| iterator rbegin() const_iterator rbegin() const iterator rend() const_iterator rend() const |
begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器 |
| 范围for | C++11支持更简洁的范围for的新遍历方式 |
// string的遍历
// begin()+end() for+[] 范围for
// 注意：string遍历时使用最多的还是for+下标 或者 范围for(C++11后才支持)
// begin()+end()大多数使用在需要使用STL提供的算法操作string时，比如：采用reverse逆置string
void Teststring3()
{
string s1("hello World");
const string s2("hello World2");
cout << s1 << " " << s2 << endl; // hello World hello World2
cout << s1[0] << " " << s2[0] << endl; // h H
s1[0] = 'H';
cout << s1 << endl; // Hello World
// s2[0] = 'h'; 代码编译失败，因为const类型对象不能修改
}
void Teststring4()
{
string s("hello world");
// 3种遍历方式：
// 需要注意的以下三种方式除了遍历string对象，还可以遍历是修改string中的字符，
// 另外以下三种方式对于string而言，第一种使用最多
// 1. for+operator[]
for (size_t i = 0; i < s.size(); ++i)
cout << s[i] << " ";
cout << endl;
// 2.迭代器
string::iterator it = s.begin();
while (it != s.end())
{
cout << *it << " ";
++it;
}
cout << endl;
// string::reverse_iterator rit = s.rbegin();
// C++11之后，直接使用auto定义迭代器，让编译器推到迭代器的类型
auto rit = s.rbegin();
while (rit != s.rend())
{
cout << *rit << " ";
rit++;
}
cout << endl;
// 3.范围for
for (auto ch : s)
cout << ch << " ";
cout << endl;
}迭代器的使用
int main()
{
string s1("Hello World");
// 遍历和读写容器的数据
string::iterator it = s1.begin(); //H e l l o W o r l d
while (it != s1.end())
{
cout << *it << " ";
it++;
}
cout << endl;
// 反向迭代器
string s2("Hello World");
string::reverse_iterator rit = s2.rbegin();
while (rit != s2.rend())
{
cout << *rit << " "; //d l r o W o l l e H
rit++;
}
cout << endl;
return 0;
}const_迭代器的使用
int main()
{
const string s("Hello World");
// 遍历和读容器的数据，不能写
// string::iterator it = s.begin(); //err s为const，迭代器也应该是const
string::const_iterator it = s.begin();
while (it != s.end())
{
//*it+=1;//err,const不能改变数据
cout << *it << " "; // H e l l o W o r l d
it++;
}
cout << endl;
// 反向const迭代器,
string::const_reverse_iterator rit = s.rbegin();
// auto rit = s.rbegin(); //用auto类型代替string::const_reverse_iterator，auto编译器自动识别类型
while (rit != s.rend())
{
cout << *rit << " "; //d l r o W o l l e H
++rit; //反向迭代器这里也是++，而不是--
}
cout << endl;
return 0;
}at
在访问字符串时，如果指定的索引超出了字符串的范围，就会抛出异常
| char& at(size_t pos); | 返回一个引用，可以用于读取或修改字符串中指定位置的字符。 |
| const char& at(size_t pos) const; | 返回的是一个 const 引用，因此只能用于读取字符串中指定位置的字符，不能修改它。 |
#include <iostream>
#include <string>
using namespace std;
int main()
{
string str = "Hello World";
char first_char = str.at(0);
char last_char = str.at(str.length() - 1);
cout << "First character:" << first_char << endl; // First character:H
cout << "Last character:" << last_char << endl; // Last character:d
string str1 = "Hello World";
const char &ch = str.at(0);
// ch = 'E'; //编译错误：尝试修改常量引用
const string str2 = "Hello World";
// str.at(0) = 'E'; //编译错误：尝试修改常量字符串
//string s1("Hello World");
//s1[100]; // 出错assert
s1.at(100); // 超过索引范围，抛异常
return 0;
}back和front
| char& back(); const char& back() const; |
front函数返回一个对字符串第一个字符的引用，如果字符串为空，会导致未定义行为。 |
| char& front(); const char& front() const; |
back函数返回一个对字符串最后一个字符的引用，如果字符串为空，也会导致未定义行为。 |
#include <iostream>
#include <string>
using namespace std;
int main()
{
string str = "Hello World";
char c1 = str.front();
char c2 = str.back();
cout << c1 << endl; //H
cout << c2 << endl; //d
return 0;
}2.3 string容量操作
| 函数名称 | 功能说明 |
| size_t size() const | 返回字符串有效字符长度 |
| size_t length() const | 返回字符串有效字符长度 |
| size_t max_size() const | 返回字符串最大可能的大小，即 std::allocator_traits<allocator_type>::max_size() 的返回值。 |
| void resize(size_t n) void resize(size_t n, char c) |
将有效字符的个数该成n个，多出的空间用字符c填充 |
| size_t capacity() const | 返回空间总大小 |
| void reserve(size_t n = 0) | 为字符串预留空间 |
| void clear() | 清空有效字符 |
| bool empty() const | 检测字符串释放为空串，是返回true，否则返回false |
| void shrink_to_fit() | 请求字符串减小为其当前大小，可能会导致内存重新分配 |
size/length/capacity/clear/empty/resize
// size/length/capacity/clear/resize/empty
void Teststring()
{
// 注意：string类对象支持直接用cin和cout进行输入和输出
string s("Hello,World!");
cout << s.size() << endl; // 12
cout << s.length() << endl; // 12
cout << s.capacity() << endl; // 15 显示15，其实容量是16，少一个\0
cout << s << endl;
// 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
s.clear();
cout << s.size() << endl; // 0
cout << s.capacity() << endl; // 15
// 将s中有效字符个数增加到10个，多出位置用'a'进行填充
// “aaaaaaaaaa”
s.resize(10, 'a');
cout << s.size() << endl; // 10
cout << s.capacity() << endl; // 15
// 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充
// "aaaaaaaaaa\0\0\0\0\0"
// 注意此时s中有效字符个数已经增加到15个
s.resize(15);
cout << s.size() << endl; // 15
cout << s.capacity() << endl; // 15
cout << s << endl; // aaaaaaaaaa
// 将s中有效字符个数缩小到5个
s.resize(5);
cout << s.size() << endl; // 5
cout << s.capacity() << endl; // 15 size缩小，不会改变capacity
cout << s << endl; // aaaaa
cout << s.max_size() << endl; // 9223372036854775807
cout << s.empty() << endl; // 0
s.clear();
cout << s.empty() << endl; // 1
}
int main()
{
Teststring();
return 0;
}reserve
测试reserve是否会改变string中有效元素个数
void Teststring()
{
string s;
// 测试reserve是否会改变string中有效元素个数
s.reserve(100);
cout << s.size() << endl; //0
cout << s.capacity() << endl; //100
// 测试reserve参数小于string的底层空间大小时，是否会将空间缩小
s.reserve(50);
cout << s.size() << endl; //0
cout << s.capacity() << endl; //50
// reserve无法缩容到
s="Hello World";
s.reserve(1);
cout<<s.size()<<endl; //11
cout<<s.capacity()<<endl; //15
s.reserve(17);
cout<<s.capacity()<<endl; //30 reserve默认扩容2倍，不同编译器下结果不同
s.reserve(1);
cout<<s.capacity()<<endl; //15 reserve缩容不会缩小到字符串有效长度的空间还小，只能缩容之前reserve过的空闲空间
}reserve不会改变string中有效元素个数
reserve参数小于string空间时，会使空间变小，但不会小于有效元素个数大小
reserve默认扩容2倍，不同编译器下结果不同
利用reserve提高插入数据的效率，避免增容的开销
测试代码：利用reserve提高插入数据的效率，避免增容带来的开销
// 利用reserve提高插入数据的效率，避免增容带来的开销
void TestPushBack()
{
string s;
size_t sz = s.capacity();
cout << "making s grow:\n";
for (int i = 0; i < 100; ++i)
{
s.push_back('c');
if (sz != s.capacity())
{
sz = s.capacity();
cout << "capacity changed: " << sz << '\n';
}
}
}
// 构建vector时，如果提前已经知道string中大概要放多少个元素，可以提前将string中空间设置好
void TestPushBackReserve()
{
string s;
s.reserve(100);
size_t sz = s.capacity();
cout << "making s grow:\n";
for (int i = 0; i < 100; ++i)
{
s.push_back('c');
if (sz != s.capacity())
{
sz = s.capacity();
cout << "capacity changed: " << sz << '\n';
}
}
}
resize和reserve的区别
int main()
{
string s1("Hello World");
// 扩容
s1.reserve(100);
cout << s1.size() << endl; // 11
cout << s1.capacity() << endl; // 100
string s2("Hello World");
// 扩容+初始化
s2.resize(100); // 默认填充0
cout << s2.size() << endl; // 100
s2.resize(100, 'x'); // 填充x
cout << s2.size() << endl; // 100
cout << s2.capacity() << endl; // 100
// 比size小，就不是扩容，就是删除，size会变，但capacity不变
// 缩容不支持原地缩容
s2.resize(5);
cout << s2.size() << endl; //5
cout << s2.capacity() << endl; //100
return 0;
}string的resize会改变其大小并且可能会改变其内容，而reserve仅仅是为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不会改变容量大小。
2.4 string修改操作
operator+=
int main()
{
string str = "Hello";
char c = ' ';
//string& operator+=(char c);
str += c;
//string& operator+=(const char* s);
str += 'w';
//string& operator++(const string& str);
str += "orld";
cout << str << endl;
return 0;
}push_back/pop_back
int main()
{
string str = "Hello";
str.push_back('a');
cout << str << endl; //Helloa
str.pop_back();
cout << str << endl; //Hello
return 0;
}append
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main()
{
// 1.string& append(const string& str)
string str = "hello";
string appendstr = " world!";
str.append(appendstr);
cout << str << endl; // hello world!
// 2.string& append(const string& str, size_t subpos, size_t sublen)
// 将给定字符串str的子串（从索引subpos开始，长度为sublen）添加到当前字符串的末尾。
string str1 = "hello";
string appendStr1 = " world!";
str1.append(appendStr1, 0, 5); // 添加另一个字符串的子串，即" worl"
cout << str1 << endl; // 输出：hello worl
// 3.string& append(const char* s)
string str2 = "hello";
const char *cstr = " world!";
str2.append(cstr); // 添加完整的字符数组，即" world!"
cout << str2 << endl; // 输出：hello world!
// 4.string& append(const char* s, size_t n)
// 将给定的字符数组s的前n个字符添加到当前字符串的末尾。
string str3 = "hello";
const char *cstr3 = " world!";
str3.append(cstr3, 7); // 添加" world!"的前7个字符，即" world"
cout << str3 << endl; // 输出：hello world
// 5. string& append(size_t n, char c)
// 将字符c重复n次添加到当前字符串的末尾。
string str4 = "hello";
str4.append(3, '!'); // 添加3个感叹号
cout << str4 << endl; // 输出：hello!!!
// 6.
// template<class InputIterator>
// void append(InputIterator first, InputIterator last);
// 作用是将从first到last区间中的所有元素添加到当前std::string对象的末尾。
vector<char> vec{'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!'};
string str5;
str5.append(vec.begin(), vec.end());
cout << str5 << endl; // hello,world!
return 0;
}assign
可以用于将一个字符串替换成新的字符串
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main()
{
// 1.string& assign(const string& str)
string s1 = "Hello";
string s2;
s2.assign(s1);
cout << s2 << endl; // Hello
// 2.string& assign(const std::string& str, size_t subpos, size_t sublen)
// 将字符串对象设置为另一个字符串对象str的子串，子串从subpos开始，长度为sublen。
string s3 = "Hello World!";
string s4;
s4.assign(s3, 6, 5); //
cout << s4 << endl; // World
// 3.string& assign(const char*s)
string s5;
const char *cstr = "Hello World!";
s5.assign(cstr); //
cout << s5 << endl; // Hello World!
// 4.string& assign(const char* s, size_t n)
string s6;
const char *cstr1 = "Hello World!";
s6.assign(cstr1, 5);
cout << s6 << endl; // Hello
// 5.string& assign(size_t n, char c)
string s7;
s7.assign(5, 'a');
cout << s7 << endl; // aaaaa
// 6.template <class InputIterator>
// string &assign(InputIterator first, InputIterator last);
// 将字符串对象设置为迭代器[first, last)所指范围内的字符序列的副本。
string s8;
vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
s8.assign(vec.begin(), vec.end());
cout << s8 << endl; // Hello
return 0;
}insert / erase
int main()
{
string s1("World");
s1.insert(0, "hello");
cout << s1 << endl; //
// s1.insert(5, " "); //在s1第五个位置插入空格
// s1.insert(5,' '); //err
// s1.insert(5, 1, ' '); // 在s1第五个位置插入1个字符
s1.insert(s1.begin() + 5, ' ');
cout << s1 << endl;
// insert/erase不推荐经常使用，能少用就少用
// 因为他们可能都存在挪动数据效率低下
string s2("Hello World");
// s2.erase(5, 1); //删除第五个位置1个字符
s2.erase(s2.begin() + 5); // 删除第五个位置后面的字符
cout << s2 << endl;
s2.erase(5, 30); // 超过字符串长度，删除所有的
s2.erase(5); // 删除所有的用这种方式
cout << s2 << endl;
return 0;
}
replace
替换字符串
int main()
{
string s1("Hello World");
s1.replace(5, 1, "%%d");
cout << s1 << endl; //Hello%%dWorld
string s2("Hello World i love you");
size_t num = 0;
for (auto ch : s2)
{
if (ch == ' ')
num++;
}
// 提前开空间，避免replace时扩容
s2.reserve(s2.size() + 2 * num);
size_t pos = s2.find(' ');
while (pos != string::npos)
{
s2.replace(pos, 1, "%20");
pos = s2.find(' ', pos + 3); // pos+3的位置是越过了%20
}
cout << s2 << endl; //Hello%20World%20i%20love%20you
return 0;
}
swap
为什么C++库里面已经有swap函数了，为什么string里还有swap
库里的库函数深拷贝，效率低
int main()
{
string newStr = "Hello,World";
string s1 = newStr;
cout << newStr << endl; // Hello,World
string s2("xxxxx");
s1.swap(s2);
cout << s1 << endl; // xxxxx
cout << s2 << endl; // Hello,World
swap(s1, s2);
cout << s1 << endl; // Hello,World
cout << s2 << endl; // xxxxx
return 0;
}
2.5 string操作
c_str
返回C格式字符串
int main()
{
string s1("Hello World");
cout << s1 << endl;
// c_str 是指针
cout << s1.c_str() << endl;
cout << (void *)s1.c_str() << endl;
s1 += '\0';
s1 += '\0';
s1 += "xxxxx";
cout << s1 << endl; // Hello Worldxxxxx
cout << s1.c_str() << endl; // Hello World C语言方式打印，遇到\0结束
// c_str 用于C语言方式字符串
string filename("test.cpp");
FILE *fout = fopen(filename.c_str(), "read");
char ch = fgetc(fout);
while (ch != EOF)
{
cout << ch;
ch = fgetc(fout);
}
fclose(fout);
return 0;
}data
返回指向string对象中存储的字符数组的指针，即返回一个C风格的字符串指针。
int main()
{
string str = "Hello, world!";
const char *cstr = str.data();
cout << "The string is: " << str << endl; //The string is: Hello, world
cout << "The C-style string is: " << cstr << endl; //The C-style string is: Hello, world!
// 修改字符串
string new_str(cstr);
new_str[0] = 'h';
cout << "The modified C-style string is: " << new_str.c_str() << endl; //The modified C-style string is: hello, world!
cout << "The modified string is: " << new_str << endl; //The modified string is: hello, world!
return 0;
}copy
int main()
{
// size_t copy (char* s, size_t len, size_t pos = 0) const;
// 其中，c是一个指向目标字符数组的指针，len是要复制的字符数，pos是开始复制的位置，默认值为 0。
string str = "Hello World!";
char buf[6];
size_t n = str.copy(buf, 5, 6);
buf[n] = '\0';
cout << buf << endl; // World
return 0;
}find/rfind
find 函数返回子字符串第一次出现的位置，如果子字符串未找到，则返回 npos。
rfind 方法返回子字符串最后一次出现的位置，如果子字符串未找到，则返回npos
npos是string里面的一个静态成员变量
static const size_t npos = -1;
int main()
{
string str1 = "Hello World,Hello World";
string str2 = "Wor";
cout << str1.find(str2) << endl; // 6
cout << str1.rfind(str2) << endl; // 18
cout << str1.find("Wor") << endl; // 6
cout << str1.rfind("Wor") << endl; // 18
const char *substr = "Wor";
cout << str1.find(substr) << endl; // 6
cout << str1.rfind(substr) << endl; // 18
cout << str1.find('d') << endl; // 10
cout << str1.rfind('d') << endl; // 22
return 0;
}find_first/last_of和find_first/last_not_of
用于在字符串中查找第一次/最后一次出现指定字符集合中任何一个字符的位置。
用于再字符串中查找第一次/最后一次不是出现指定字符集合中任何一个字符的位置
int main()
{
string str = "Hello World,Hello World";
cout << str.find_first_of("aeiou") << endl; // 查找"aeiou"第一次出现的位置，Hello World e为1
cout << str.find_last_of("aeiou") << endl; // 最后出现"aeiou"的位置是19
cout << str.find_first_not_of("aeiou") << endl; // 查找第一次不是"aeiou"出现的位置 为0 H一开始就不是
cout << str.find_last_not_of("aeiou") << endl; // 查找最后一次不是的位置 22 为d
return 0;
}substr
用于返回字符串中指定位置和长度的子字符串。
int main()
{
string str = "Hello, world!";
string substr1 = str.substr(7, 5); // 从位置7开始提取长度为5的子字符串，得到"world"
string substr2 = str.substr(0, 5); // 从位置0开始提取长度为5的子字符串，得到"Hello"
string substr3 = str.substr(7); // 从位置7开始提取到字符串末尾的子字符串，得到"world!"
cout << substr1 << endl; // 输出"world"
cout << substr2 << endl; // 输出"Hello"
cout << substr3 << endl; // 输出"world!"
return 0;
}compare
用于比较两个字符串的成员函数，它返回一个整数值，表示两个字符串的大小关系
- 如果当前字符串对象小于
str，则返回一个负数（通常是 -1）。- 如果当前字符串对象等于
str，则返回 0。- 如果当前字符串对象大于
str，则返回一个正数（通常是 1）。
int main() {
string str1 = "apple";
string str2 = "banana";
string str3 = "apple";
int result1 = str1.compare(str2);
int result2 = str1.compare(str3);
cout << "str1 vs str2: " << result1 << endl; // 输出-1
cout << "str1 vs str3: " << result2 << endl; // 输出0
return 0;
}2.6 非成员函数接口
getline
istream& getline (istream& is, string& str, char delim);此函数将输入流对象 is 中的文本读取到 str 字符串中，直到遇到分隔符 delim 或文件结尾。如果 delim 参数被省略，则默认使用换行符 \n 作为分隔符。
int main()
{
string name;
cout << "Please enter your name: ";
getline(cin, name);
cout << "Hello, " << name << "!" << endl;
return 0;
}3.string模拟实现
3.1经典string类问题
上面已经对string类进行了简单的介绍，大家只要能够正常使用即可。在面试中，面试官总喜欢让学生自己 来模拟实现string类，最主要是实现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共用同一块内存空间，在释放时同一块 空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。
3.2 浅拷贝和深拷贝
浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共 享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为 还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。
就像一个家庭中有两个孩子，但父母只买了一份玩具，两个孩子愿意一块玩，则万事大吉，万一不想分享就 你争我夺，玩具损坏。
可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。父母给每个孩 子都买一份玩具，各自玩各自的就不会有问题了。
如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。文章来源：https://www.toymoban.com/news/detail-437776.html
文章来源地址https://www.toymoban.com/news/detail-437776.html
3.3 string模拟实现代码(常用接口)
#pragma once
#include <iostream>
#include <string.h>
#include <assert.h>
using namespace std;
namespace phw
{
class string
{
private:
friend ostream &operator<<(ostream &out, const phw::string &s);
friend istream &operator>>(istream &in, phw::string &s);
public:
// 带参构造函数
// string(const char* str = nullptr) //不可以 给空指针，strlen会报错
// string(const char* str = '\0') //\0 char转换成指针，也是空指针
// string(const char* str = "\0") //可以,给常量字符串，strlen不会报错
string(const char *str = "") // 空字符串默认是\0
: _size(strlen(str))
{
_capacity = _size == 0 ? 3 : _size; // 最少给3个字节空间
_str = new char[_capacity + 1]; // new _capacity+1 capacity是字符串容量，存放的有效字符大小，不是空间，空间还有一个\0
strcpy(_str, str);
}
// 拷贝构造
string(const string &s)
: _size(s._size),
_capacity(s._capacity)
{
//_str自己开空间
_str = new char[s._capacity + 1];
strcpy(_str, s._str);
}
// 赋值是对已经定义的对象进行赋值
// 有一种情况是，原对象的空间远大于要赋值的对象，那么就会出现空间浪费
// 所以首先应该delete掉原空间的内存，在进行赋值
string &operator=(const string &s)
{
if (this != &s)
{
// delete[]_str; //赋值提前把旧空间释放，防止浪费空间
//_str = new char[s._capacity + 1];
// strcpy(_str, s._str);
//_size = s._size;
//_capacity = s._capacity;
// 下面的写法更加安全
char *tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}
return *this;
}
// 迭代器相关
typedef char *iterator;
typedef const char *const_iterator;
iterator begin()
{
return _str;
}
const_iterator begin() const
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator end() const
{
return _str + _size;
}
// 获取字符串
const char *c_str()
{
return _str;
}
//[]通过下标来访问字符
char &operator[](size_t pos)
{
return _str[pos];
}
// 访问const类型的数组
const char &operator[](size_t pos) const
{
return _str[pos];
}
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
~string()
{
delete[] _str;
_size = 0;
_capacity = 0;
}
void Print(const string &s)
{
for (size_t i = 0; i < s.size(); i++)
{
cout << s._str[i] << " ";
}
cout << endl;
// 这里不支持范围for了，为什么？ 因为这里s是const对象，只能调用const迭代器
string::const_iterator it = s.begin();
while (it != s.end())
{
//(*it)++; //err. const迭代器指向的内容不能修改
it++;
}
// 这里没有定义const迭代器，就会报错，范围for的底层就是迭代器
for (auto ch : s)
{
cout << ch << " ";
}
cout << endl;
}
// 不修改成员变量数据的函数，最好加上const
bool operator==(const string &s) const
{
return strcmp(_str, s._str) == 0;
}
bool operator!=(const string &s) const
{
return !(_str == s._str);
}
bool operator>(const string &s) const
{
return strcmp(_str, s._str) > 0;
}
bool operator>=(const string &s) const
{
return *this > s || *this == s;
}
bool operator<(const string &s) const
{
return !(*this >= s);
}
bool operator<=(const string &s) const
{
return !(*this > s);
}
// 开空间
void reserve(size_t n)
{
if (n > _capacity)
{
char *tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
// 扩容+初始化
void resize(size_t n, char ch = '\0')
{
// 当n小于_size的时候，不需要扩容，也不需要缩容
// n大于_size的时候，并且当n>capacit的时候需要扩容，就直接调用reserve
if (n < _size)
{
// 保留前n个
_size = n;
_str[_size] = '\0';
}
else
{
if (n > _capacity)
{
reserve(n);
}
// 不大于则不需要设置_capacity
// 从_size开始 到需要扩容n开始，初始化\0
size_t i = _size;
while (i < n)
{
_str[i] = ch;
i++;
}
_size = n;
// 将最后的下一个位置也设置为\0
_str[_size] = '\0';
}
}
void push_back(char ch)
{
if (_size + 1 > _capacity)
{
reserve(_capacity * 2);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';
}
// 尾插字符串
void append(const char *str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, str); // 从_str+_size开始拷贝
// strcat(_str, str); //strcat会找\0，效率低下
_size += len;
_str[_size] = '\0';
}
string &operator+=(const char *str)
{
append(str);
return *this;
}
string &operator+=(const char ch)
{
push_back(ch);
return *this;
}
string &insert(size_t pos, char ch)
{
assert(pos <= _size);
if (_size + 1 > _capacity)
{
reserve(_capacity * 2);
}
int end = _size;
// 这里的pos需要改成int pos是无符号类型，和end对比，end会转换成无符号类型
// 当pos的位置是0时，end为无符号类型将永远不会小于0，程序无限循环。
// 需要将pos转换成int，那么end就为int类型
while (end >= (int)pos)
{
_str[end + 1] = _str[end];
end--;
}
_str[pos] = ch;
_size++;
return *this;
}
string &insert(size_t pos, const char *str)
{
assert(pos <= _size);
int len = strlen(str);
int end = _size + len;
if (_size + len > _capacity)
{
reserve(_size + len);
}
while (end > pos + len - 1)
{
_str[end] = _str[end - len];
end--;
}
strncpy(_str + pos, str, len);
_size += len;
return *this;
}
string &erase(size_t pos, size_t len = npos)
{
// 如果要删的个数远超于剩余的个数，就是pos位置后面全部删除，直接在pos位置后面置\0即可
// len == npos必须加上，npos是最大值
if (len == npos || pos + len >= _size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len); // 删除pos+len位置的字符串
_size -= len;
}
return *this;
}
void swap(string &s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
size_t find(char ch, size_t pos = 0)
{
assert(pos < _size);
for (size_t i = 0; i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}
}
// 返回子串str在string中第一次出现的位置
size_t find(const char *str, size_t pos = 0)
{
assert(pos < _size);
// p是str出现在_str+pos出现的位置，返回的是指针
char *p = strstr(_str + pos, str);
if (p == nullptr)
{
return npos;
}
else
{
return p - _str;
}
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
private:
char *_str;
size_t _size;
size_t _capacity; // 真实容量要比_size多1，多一个\0
// 静态成员变量不能给缺省值，但是加上const就可以了，只针对整型
static const size_t npos = -1;
// static const size_t N = 10;
// int _a[N];
};
ostream &operator<<(ostream &out, const phw::string &s)
{
for (size_t i = 0; i < s.size(); i++)
{
out << s[i];
}
return out;
}
istream &operator>>(istream &in, phw::string &s)
{
s.clear(); // 一开始就清理缓冲区
char ch = in.get();
char buff[128];
size_t i = 0;
while (ch != ' ' && ch != '\n')
{
// s += ch; //字符串太长可能会容量不够,用reserve如何控制扩容？ 扩容会频繁调用
buff[i++] = ch;
if (i == 127)
{
buff[127] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
if (i != 0)
{
buff[i] = '\0';
s += buff;
}
// getline实现
/*while (ch != '\n')
{
s += ch;
ch = in.get();
}*/
return in;
}
}#include "string.h"
void test1()
{
phw::string s1;
phw::string s2("Hello World\n");
cout << s1.c_str() << endl;
cout << s2.c_str() << endl; // Hello World
}
void test2()
{
phw::string s1;
phw::string s2("hello world");
phw::string s3(s2); // 编译器默认的构造函数，浅拷贝,s2和s3的str指向了同一个空间，析构会出问题
cout << s2.c_str() << endl; // hello world
cout << s3.c_str() << endl; // hello world
// 不自己写拷贝构造结果是s2变，s3跟着变，因为s2和s3指向同一个空间
// s2[0]++;
// cout << s2.c_str() << endl; //iello world
// cout << s3.c_str() << endl; //iello world
s2[0]++;
cout << s2.c_str() << endl; // iello world
cout << s3.c_str() << endl; // hello world
s1 = s3; // 自己不写还是会报错，因为还是浅拷贝
cout << s1.c_str() << endl; // hello world
cout << s3.c_str() << endl; // hello world
s1 = s1;
}
void test3()
{
phw::string s1("Hello World");
for (size_t i = 0; i < s1.size(); i++)
{
s1[i]++;
}
for (size_t i = 0; i < s1.size(); i++)
{
cout << s1[i] << " "; // I f m m p ! X p s m e
}
cout << endl;
s1.Print(s1); // I f m m p ! X p s m e
phw::string::iterator it = s1.begin();
while (it != s1.end())
{
(*it)--;
it++;
}
it = s1.begin();
while (it != s1.end())
{
cout << *it << " "; // H e l l o W o r l d
it++;
}
cout << endl;
for (auto ch : s1) // 底层就是将*it替换成ch
{
cout << ch << " "; // H e l l o W o r l d
}
cout << endl;
}
// string比较大小
void test4()
{
phw::string s1("hello world");
phw::string s2("hello world");
phw::string s3("xx");
cout << (s1 < s2) << endl; // 0
cout << (s1 == s2) << endl; // 1
cout << (s1 > s2) << endl; // 0
}
void test5()
{
phw::string s1("Hello World");
s1.push_back('a');
s1.append("xxxxxxxxxx");
s1 += 'W';
s1 += "!!!!!!!!!!!!";
cout << s1.c_str() << endl; // Hello WorldaxxxxxxxxxxW!!!!!!!!!!!!
phw::string s2 = "Hello World";
s2.insert(5, 'X');
cout << s2.c_str() << endl; // HelloX World
s2.insert(0, 'A');
cout << s2.c_str() << endl; // AHelloX World
s2.insert(0, "PHW");
cout << s2.c_str() << endl; // PHWAHelloX World
s2.erase(0, 3);
cout << s2.c_str() << endl; // AHelloX World
s2.erase(5, 10);
cout << s2.c_str() << endl; // AHell
}
// 流插入重载必须实现成友元函数？ 不对
void test6()
{
std::string s1("0123456789");
phw::string s2("0123456789");
s1 += '\0';
s2 += '\0';
s1 += "xxxx";
s2 += "xxxx";
cout << s1 << endl; // 0123456789xxxx
cout << s2.c_str() << endl; // 0123456789 遇到\0终止
cout << s2 << endl; // 0123456789xxxx
phw::string s3;
cin >> s3;
cout << s3 << endl;
}
void test7()
{
phw::string s1;
std::string s2;
cout << sizeof(s1) << endl; // 12
cout << sizeof(s2) << endl; // 28
s1 = "hello";
s2 = "hello";
cout << sizeof(s1) << endl; // 12
cout << sizeof(s2) << endl; // 28
// g++ 中x86 4字节 x64 8字节
// g++中存的是指针
}
void test8()
{
string s1 = "Hello World";
int pos = s1.find("Wor", 3);
s1[pos] = 'A'; // Hello Aorld
cout << s1;
}
int main()
{
// test8();
return 0;
}到了这里，关于＜C++_STL＞ string的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
