STL_string 常用的用法

                         string里常用的函数与讲解使用

                                     ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑

                           （点击进入c++关于string 的各个函数的全面讲解使用/英文版）

Iterators（迭代器）:

begin与end：

类似下标，字符串的首未；

	//迭代器 iterator   可读可写
	string::iterator it1 = s1.begin();  //it1 不是指针，有些类似指针
	cout << "s1:";
	while (it1 < s1.end())
	{
		*it1 += 1;  //可读可写   当有const 修饰的时候，就不可写！
		cout << *it1++ << " ";
	}

    //输出 s1:i b m m p ! h p v ! s j ! e f   

当const修饰后：

//const_iterator   只读 不可写 :const 给限制住
 const string T2 = "hallo gou ri de";
string::const_iterator it2 = T2.begin();  
cout << "s7:";
while (it2 < T2.end())
{
	//*it2 += 1;  //编译不过！ const修饰可读而不可写
	cout << *it2++ << " ";
}

//输出：  T2:h a l l o   g o u   r i   d e

反向迭代器：

//反向迭代器	 普通版本：reverse_iterator   用法与iterator一样 
//				cosnt修饰：cosnt_reverse_iterator   只读不可改！
//					 注意：使用反向迭代的话  要在begin与end 前加上一个r作为与iterator区分；
string s1("hallo gou ri de");
string::reverse_iterator rt2 = s1.rbegin();
while (rt2 != s1.rend())
{
	cout << *rt2++ << " ";
}
//输出 ：e d   i r   u o g   o l l a h

 Capacity（容量）：

（长度）size   /   length   ：

        返回字符串的长度；

（不常用）max_size：

        返回字符串可以达到的最大长度

（容量）resize：

（可以用于管理字符串空间大小）

void resize (size_t n);
void resize (size_t n, char c);

resize函数用于调整字符串的长度为n个字符。

如果n小于当前字符串长度，当前值会缩短至前n个字符，去除第n个字符之后的字符。

如果n大于当前字符串长度，会在当前内容末尾插入足够多的字符以达到长度为n。如果指定了字符c，新添加的元素会初始化为c的副本，否则新元素会初始化为值初始化的字符（空字符）。

该函数有两个参数：

一是n，表示新的字符串长度，以字符数量表示，类型为size_t，与std::string的成员类型size_type相同；

二是可选参数c，用于在字符串扩展时填充新添加的字符空间的字符。函数无返回值。

（容量）capacity： 

size_t capacity() const;capacity函数返回当前为字符串分配的存储空间大小，以字节为单位。

    这个容量不一定等于字符串的长度，它可以等于或大于字符串长度，额外的空间允许在向字符串添加新字符时进行优化操作。需要注意的是，这个容量并不意味着对字符串长度的限制。当容量耗尽且需要更多空间时，字符串对象会自动扩展（重新分配存储空间）。字符串长度的理论上限由成员函数max_size给出。字符串的容量可以在对象被修改的任何时候发生改变，即使这种修改意味着尺寸减小或者容量尚未耗尽（这与std::vector容器中对容量的保证不同）。字符串的容量可以通过调用成员函数reserve显式地改变。该函数无参数，返回值为当前为字符串分配的存储容量大小，类型为size_t，与std::string的成员类型size_type相同。

（容量）reserve:

void reserve (size_t n = 0);

函数用于请求调整字符串的容量以适应计划的尺寸变化，使其能够容纳最多n个字符。

  reserve如果n大于当前字符串的容量，该函数会使容器增加其容量至n个字符（或更多）。在其他情况下，它被视为一个非约束性的请求来缩小字符串容量，但容器实现可以自由地进行优化并使字符串的容量大于n。这个函数对字符串的长度没有影响，也不能改变其内容。

    该函数有一个参数n，表示计划的字符串长度，注意最终的字符串容量可能等于或大于n，参数类型为size_t，与std::string的成员类型size_type相同。函数无返回值。

（清空）clear:

void clear();

clear函数会清空字符串的内容，使其变为一个空字符串（长度为 0 个字符）。该函数无参数，也无返回值。

当 str_clear()清空后 该字符串空间还存在！

（判断） empty：

bool empty() const;

empty函数用于判断字符串是否为空，即判断其长度是否为 0。这个函数不会以任何方式修改字符串的值。如果要清空字符串的内容，可以使用string::clear函数。该函数无参数，返回值为布尔类型，如果字符串长度为 0 则返回true，否则返回false。

（优化空间）shrink_to_fit：

void shrink_to_fit();

shrink_to_fit函数请求字符串减少其容量以适应其实际大小。但这个请求是非约束性的，容器实现可以自由地进行优化并使字符串的容量大于其实际大小。这个函数对字符串的长度没有影响，也不能改变其内容。该函数无参数，也无返回值。

Element access（元素访问）：

（访问）operator[]：

char& operator[] (size_t pos);
const char& operator[] (size_t pos) const;

  1.operator[]：可以通过这个运算符获取字符串中指定位置的字符，并返回该字符的引用。如果字符串是常量限定的且位置等于字符串长度，会返回指向空字符的引用。参数是位置值，第一个字符位置为 0，返回值根据字符串是否为常量限定分别为const char&或char&。

      2.at()：与operator[]类似，但会进行边界检查。如果访问的位置超出范围，会抛出std::out_of_range异常。

    这些方法允许对字符串中的单个字符进行访问和（在非常量情况下）修改。但在处理多字节字符集或可变长度字符集（如 UTF-8）时，需要注意这些函数是以字节为单位进行操作，而不一定对应实际的编码字符。

（访问）at：

char& at (size_t pos);
const char& at (size_t pos) const;

at函数用于获取字符串中指定位置的字符，并返回该字符的引用。

这个函数会自动检查给定的位置pos是否是字符串中一个有效字符的位置（即pos是否小于字符串长度），如果不是，则会抛出std::out_of_range异常。

参数pos表示字符串中字符的位置，第一个字符位置用 0 表示，参数类型为size_t，与std::string的成员类型size_type相同。

如果pos不是一个有效字符的位置，会抛出越界异常！！！

如果字符串对象是常量限定的，函数返回const char&；否则，返回char&。

(访问末尾值引用)back：

char& back();
const char& back() const;

back函数用于返回字符串中最后一个字符的引用。但这个函数不能在空字符串上调用。

  该函数无参数。如果字符串对象是常量限定的，函数返回const char&；否则，返回char&。

(访问首部值引用) front：

 char& front();
const char& front() const;

front函数用于返回字符串中第一个字符的引用。与string::begin不同，它直接返回对第一个字符的引用，而不是一个迭代器。这个函数不能在空字符串上调用。该函数无参数。如果字符串对象是常量限定的，函数返回const char&；否则，返回char&。

Modifiers（修改器）：

（常用+=）operator+=：

string (1)	string& operator+= (const string& str);
c-string (2)	string& operator+= (const char* s);
character (3)	string& operator+= (char c);

这个函数用于向字符串末尾追加内容，有以下几种重载形式：

1. string& operator+=(const string& str)：将一个字符串对象的值复制并追加到当前字符串的末尾。
2. string& operator+=(const char* s)：将一个以空字符结尾的字符序列（C 风格字符串）复制并追加到当前字符串的末尾。
3. string& operator+=(char c)：将一个字符追加到当前字符串的末尾。

        该函数通过在当前字符串值的末尾追加额外的字符来扩展字符串，类似于成员函数append，但提供了不同的语法方式。参数分别为要追加的字符串对象、C 风格字符串指针和单个字符。

 （追加，部分截取）append：

append函数用于在字符串末尾追加内容，有多种重载形式：

1. string& append (const string& str)：将另一个字符串对象str的值复制并追加到当前字符串末尾。
2. string& append (const string& str, size_t subpos, size_t sublen)：个人理解简记：参数1：string st；参数2：x，从sr的x下标开始；参数3：size，复制的大小size。（x必须为size_类型>=0,size可比字符串大）从字符串str中截取一部分子串进行追加。子串从位置subpos开始，长度为sublen个字符，如果str长度不足或sublen为string::npos，则尽可能多地复制到末尾。如果subpos大于str的长度，会抛出out_of_range异常。
3. string& append (const char* s)：将一个以空字符结尾的 C 风格字符串s复制并追加到当前字符串末尾。
4. string& append (const char* s, size_t n)：将指针s所指向的字符数组中的前n个字符复制并追加到当前字符串末尾。
5. string& append (size_t n, char c)：将字符c重复n次后追加到当前字符串末尾。
6. template <class InputIterator> string& append (InputIterator first, InputIterator last)：将一个范围[first, last)内的字符序列复制并追加到当前字符串末尾，要求输入迭代器指向的元素类型可转换为char。如果输入迭代器是整数类型，会进行类型转换以使用形式 5。
7. 还可以接受初始化列表对象，将其中的每个字符复制并追加到当前字符串末尾。

参数包括要追加的字符串对象、子串的起始位置和长度、C 风格字符串指针、要复制的字符数量、单个字符、输入迭代器对以及初始化列表对象等。

(末尾追加一个字符)push_back:

void push_back (char c);

push_back函数用于在字符串末尾添加一个字符。参数是要添加到字符串末尾的字符c。该函数无返回值，只是将给定的字符添加到字符串中，使字符串的长度增加一。

（（可部分）替换赋值）assign：

assign函数用于为字符串赋予新的值，替换其当前内容。它有多种重载形式：

1. string& assign (const string& str)：将另一个字符串对象str的值复制给当前字符串。
2. string& assign (const string& str, size_t subpos, size_t sublen)：从字符串str中截取一部分子串赋值给当前字符串。子串从位置subpos开始，长度为sublen个字符，如果str长度不足或sublen为string::npos，则尽可能多地复制。个人简记：原str的字符串会被替换成新的str，原str的字符会清空；
3. string& assign (const char* s)：将一个以空字符结尾的 C 风格字符串s复制给当前字符串。
4. string& assign (const char* s, size_t n)：将指针s所指向的字符数组中的前n个字符复制给当前字符串。
5. string& assign (size_t n, char c)：用字符c重复n次后赋值给当前字符串。
6. template <class InputIterator> string& assign (InputIterator first, InputIterator last)：将一个范围[first, last)内的字符序列复制给当前字符串。
7. 接受初始化列表对象，将其中的每个字符按顺序复制给当前字符串。
8. 移动赋值形式，获取另一个字符串对象str的内容，str被置于未指定但有效的状态。

（串中_插入）insert：

insert函数用于在字符串中插入额外的字符，有多种重载形式：

1. string& insert (size_t pos, const string& str)：在指定位置pos前插入另一个字符串对象str的副本。
2. string& insert (size_t pos, const string& str, size_t subpos, size_t sublen)：从字符串str中截取一部分子串在指定位置pos前插入。子串从位置subpos开始，长度为sublen个字符，如果str长度不足或sublen为string::npos，则尽可能多地复制。
3. string& insert (size_t pos, const char* s)：在指定位置pos前插入一个以空字符结尾的 C 风格字符串s的副本。
4. string& insert (size_t pos, const char* s, size_t n)：在指定位置pos前插入指针s所指向的字符数组中的前n个字符的副本。
5. string& insert (size_t pos, size_t n, char c)：在指定位置pos前插入字符c重复n次的副本。
6. iterator insert (iterator p, char c)：在迭代器p所指位置前插入字符c。
7. template <class InputIterator> void insert (iterator p, InputIterator first, InputIterator last)：在迭代器p所指位置前插入一个范围[first, last)内的字符序列的副本。
8. 接受初始化列表对象，在指定位置前插入其中的每个字符的副本。

如果大于字符串长度会抛出out_of_range异常，第一个字符位置用 0 表示

返回值：返回一个引用到字符串的签名，返回*this；返回迭代器的签名，返回一个指向插入的第一个字符的迭代器。成员类型iterator是一个随机访问迭代器类型，指向字符串的字符。

（删_部分）erase：

erase函数用于从字符串中删除部分字符，减少其长度，有以下几种重载形式：

1. string& erase (size_t pos = 0, size_t len = npos)：从字符串中删除从位置pos开始、长度为len个字符的部分（如果字符串长度不足或len为string::npos，则尽可能多地删除。默认参数下会删除字符串中的所有字符，类似于成员函数clear）。
2. iterator erase (iterator p)：删除迭代器p所指向的字符。
3. iterator erase (iterator first, iterator last)：删除一个范围[first, last)内的字符序列。

参数包括：对于第一种重载形式，pos表示要删除的第一个字符的位置（如果大于字符串长度会抛出out_of_range异常，第一个字符位置用 0 表示），len表示要删除的字符数量；对于第二种重载形式，参数为要删除的字符的迭代器；对于第三种重载形式，参数为要删除的字符范围的起始和结束迭代器。

(（部分（可迭代器））替换赋值 )replace:

replace函数用于替换字符串中的一部分内容，有多种重载形式：

1. string& replace (size_t pos, size_t len, const string& str)或string& replace (iterator i1, iterator i2, const string& str)：用另一个字符串对象str的值替换从位置pos开始、长度为len个字符的部分，或者替换迭代器i1和i2之间的部分。
2. string& replace (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen)：从另一个字符串对象str中截取一部分子串，从位置pos开始、长度为len个字符的部分进行替换。子串从位置subpos开始，长度为sublen个字符，如果str长度不足或sublen为string::npos，则尽可能多地复制。
3. string& replace (size_t pos, size_t len, const char* s)或string& replace (iterator i1, iterator i2, const char* s)：用一个以空字符结尾的 C 风格字符串s的值替换从位置pos开始、长度为len个字符的部分，或者替换迭代器i1和i2之间的部分。
4. string& replace (size_t pos, size_t len, const char* s, size_t n)或string& replace (iterator i1, iterator i2, const char* s, size_t n)：用指针s所指向的字符数组中的前n个字符替换从位置pos开始、长度为len个字符的部分，或者替换迭代器i1和i2之间的部分。
5. string& replace (size_t pos, size_t len, size_t n, char c)或string& replace (iterator i1, iterator i2, size_t n, char c)：用字符c重复n次后替换从位置pos开始、长度为len个字符的部分，或者替换迭代器i1和i2之间的部分。
6. template <class InputIterator> string& replace (iterator i1, iterator i2, InputIterator first, InputIterator last)：用一个范围[first, last)内的字符序列替换迭代器i1和i2之间的部分。
7. 接受初始化列表对象，用其中的每个字符按顺序替换相应部分。

参数包括要替换的字符串对象、起始位置pos（如果大于字符串长度会抛出out_of_range异常，第一个字符位置用 0 表示）、要替换的字符数量len、子串的起始位置和长度、C 风格字符串指针、要复制的字符数量、单个字符、输入迭代器对等。

（交换）swap：

void swap (string& str);//无法与char* c交换；只能string 类；

swap函数用于交换两个字符串对象的内容。它接受另一个字符串对象str作为参数，调用这个成员函数后，当前对象的值变为调用前str的值，而str的值变为调用前当前对象的值。注意，存在一个同名的非成员函数swap，它重载了算法，具有类似这个成员函数的优化行为。该函数无返回值。

(末尾删除，长度-1)pop_back:

void pop_back();pop_back函数用于删除字符串的最后一个字符，从而有效地将字符串的长度减少一。该函数无参数，也无返回值。

String operations（字符串操作）:

（返回字符串）str.c_str()：

c_str函数返回一个指向以空字符结尾的字符数组（即 C 风格字符串）的指针，该数组表示当前字符串对象的值。这个数组包含构成字符串对象值的相同字符序列，并且在末尾有一个额外的终止空字符（'\0'）。但程序不应该修改这个序列中的任何字符。返回的指针可能会因对该对象进一步调用其他修改成员函数而失效。该函数无参数，返回值是指向字符串对象值的 C 风格字符串表示的指针。

（不懂）str.data()：

看不懂，先不写这个。懂了再说。

（不懂）get_allocator：

也不懂；

（拷贝覆盖）copy：

size_t copy (char* s, size_t len, size_t pos = 0) const;

功能：将字符串对象的子字符串复制到指定的字符数组中。

参数：

• s：指向字符数组的指针，该数组应包含足够的存储空间用于复制的字符。
• len：要复制的字符数量，如果字符串较短，则尽可能多地复制字符。
• pos：要复制的第一个字符的位置，若此值大于字符串长度，会抛出越界异常。注意，字符串中的第一个字符用 0 表示，而非 1。

返回值：复制到由s指向的数组中的字符数量，可能等于len或length()-pos（如果字符串值比pos + len短）。size_t是一种无符号整数类型，与std::string的成员类型size_type相同。

（查找_子串也可）find（）：

个人理解：没找到返回-1，可以找字串，如果有多个字串，返回查找到的第一个下标

                  可指定位置往后继续寻找字串；

函数形式：

1. size_t find (const string& str, size_t pos = 0) const；
2. size_t find (const char* s, size_t pos = 0) const；
3. size_t find (const char* s, size_t pos, size_t n) const；
4. size_t find (char c, size_t pos = 0) const。

功能：在字符串中搜索由参数指定的序列的首次出现。

参数说明：

• 对于第一种形式，str是要搜索的另一个字符串，pos是要开始搜索的位置，若此值大于字符串长度，函数永远找不到匹配项，第一个字符用 0 表示，值为 0 意味着搜索整个字符串。
• 对于第二种形式，s是指向字符数组的指针，期望是一个以空字符结尾的序列，要匹配的序列长度由第一个空字符的出现确定。
• 对于第三种形式，s是指向字符数组的指针，pos是开始搜索的位置，n是要匹配的字符序列的长度。
• 对于第四种形式，c是要搜索的单个字符，pos是开始搜索的位置。

返回值：第一个匹配项的第一个字符的位置。如果未找到匹配项，则函数返回string::npos。size_t是一种无符号整数类型，与std::string的成员类型size_type相同。

（逆序查找）rfind：

用法与find大致一样！查找顺序相反；

函数形式：

1. size_t rfind (const string& str, size_t pos = npos) const；
2. size_t rfind (const char* s, size_t pos = npos) const；
3. size_t rfind (const char* s, size_t pos, size_t n) const；
4. size_t rfind (char c, size_t pos = npos) const。

功能：在字符串中搜索由参数指定的序列的最后一次出现。

参数说明：

• 对于第一种形式，str是要搜索的另一个字符串，pos是要开始搜索的位置，任何大于或等于字符串长度的值（包括string::npos）意味着搜索整个字符串，第一个字符用 0 表示。
• 对于第二种形式，s是指向字符数组的指针，若未指定参数n，则期望是一个以空字符结尾的序列，要匹配的序列长度由第一个空字符的出现确定。
• 对于第三种形式，s是指向字符数组的指针，pos是开始搜索的位置，n是要匹配的字符序列的长度。
• 对于第四种形式，c是要搜索的单个字符，pos是开始搜索的位置。

（查找（用法有点抽象））find_first_of：

函数形式：

1. size_t find_first_of (const string& str, size_t pos = 0) const；
2. size_t find_first_of (const char* s, size_t pos = 0) const；
3. size_t find_first_of (const char* s, size_t pos, size_t n) const；
4. size_t find_first_of (char c, size_t pos = 0) const。

功能：在字符串中搜索第一个与参数中指定的任何字符匹配的字符。

            返回最先出现的字符下标；任何字符匹配！注意，没有的话就会返回string::npos

参数说明：

• 对于第一种形式，str是包含要搜索的字符的另一个字符串，pos是要开始搜索的位置，若此值大于字符串长度，函数永远找不到匹配项，第一个字符用 0 表示，值为 0 意味着搜索整个字符串。
• 对于第二种形式，s是指向字符数组的指针，若未指定参数n，则期望是一个以空字符结尾的序列，要匹配的字符序列长度由第一个空字符的出现确定。
• 对于第三种形式，s是指向字符数组的指针，pos是开始搜索的位置，n是要搜索的字符数量。
• 对于第四种形式，c是要搜索的单个字符，pos是开始搜索的位置。
• 注意，只要序列中的一个字符匹配就足够了，若要匹配整个序列可使用string::find函数。

（逆序查找）find_last_of： 

         用法与find_first_of()一样，区别：从后往前查找；

(创建_初始化)substr:

返回值：string 类

函数形式：string substr (size_t pos = 0, size_t len = npos) const。

功能：返回一个新构造的字符串对象，其值初始化为当前字符串对象的一个子字符串的副本。子字符串是从当前字符串对象的pos位置开始，长度为len个字符（或者直到字符串末尾，以先到者为准）。

参数说明：

• pos是要作为子字符串开始复制的第一个字符的位置。如果此值等于字符串长度，函数返回一个空字符串。如果此值大于字符串长度，会抛出越界异常。第一个字符用 0 表示，而非 1。
• len是子字符串中要包含的字符数量。如果字符串较短，会尽可能多地使用字符。值为string::npos表示直到字符串末尾的所有字符。

返回值：一个包含当前字符串对象子字符串的字符串对象。size_t是一种无符号整数类型，与std::string的成员类型size_type相同。

（比较）compare：

功能：比较字符串对象（或子字符串）与参数指定的字符序列。

函数形式：

1. int compare (const string& str) const；
2. int compare (size_t pos, size_t len, const string& str) const；
3. int compare (const char* s) const；
4. int compare (size_t pos, size_t len, const char* s) const；
5. int compare (size_t pos, size_t len, const char* s, size_t n) const。

参数说明：

• 对于第一种形式，str是另一个用于比较的字符串对象。
• 对于第二种形式，除了str外，pos是被比较字符串的第一个字符的位置，若此值大于字符串长度，会抛出越界异常，第一个字符用 0 表示。len是被比较字符串的长度，如果字符串较短，会尽可能多地使用字符，值为string::npos表示直到字符串末尾的所有字符。
• 对于第三种形式，s是指向字符数组的指针，期望是一个以空字符结尾的序列，其长度由第一个空字符的出现确定，用于作为比较字符串。
• 对于第四种形式，与第三种类似，但指定了被比较字符串的pos和len。
• 对于第五种形式，除了pos、len和s外，n是要比较的字符数量。

返回值：一个有符号整数，指示两个字符串之间的关系：

• 返回值为 0，表示两个字符串相等。
• 返回值小于 0，表示要么第一个不匹配的字符在被比较字符串中值更低，要么所有比较的字符都匹配但被比较字符串更短。
• 返回值大于 0，表示要么第一个不匹配的字符在被比较字符串中值更高，要么所有比较的字符都匹配但被比较字符串更长。size_t是一种无符号整数类型，与std::string的成员类型size_type相同。