[C++知识库]string类的使用（C++）

string介绍

cplusplus中的介绍

1. 字符串是表示字符序列的对象。
2. 标准字符串类通过类似于标准字节容器的接口为此类对象提供支持，但添加了专门设计用于处理单字节字符字符串的功能。
3. string 类是 basic_string 类模板的实例，它使用 char（即字节）作为其字符类型，具有默认的 char_traits 和分配器类型（有关模板的更多信息，请参阅 basic_string）。
4. 请注意，此类独立于所使用的编码处理字节：如果用于处理多字节或可变长度字符（如 UTF-8）的序列，则此类的所有成员（如长度或大小），以及它的迭代器，仍将按字节操作（不是实际编码的字符）

常用成员函数

构造函数（常用）

int main()
{
	string s1;
	string s2("hello world!");
	string s3(3, 'n');
	string s4(s2);
	cout << s1 << endl;
	cout << s2 << endl;
	cout << s3 << endl;
	cout << s4 << endl;

	return 0;
}

Iterators（迭代器相关）

begin()

iterator begin();
const_iterator begin() const;
返回指向字符串中第一个字符的迭代器

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s("hello world!");
	string::iterator light;
	for (light = s.begin(); light < s.end(); light++)
		cout << *light;

	return 0;
}

end()

iterator end();
const_iterator end() const;
返回指向字符串中最后一个字符后的下一个元素的迭代器。

int main()
{
	string str("hello world!");
	string::iterator it;
	for (it = str.begin(); it < str.end(); it++)
		cout << *it;
	return 0;
}

rbegin()

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
返回指向字符串中最后一个字符的反向迭代器，该字符被视为反向开始。

rbegin指的是将被成员end引用的字符之前的字符。

int main()
{
	string str("hello world!");
	string::reverse_iterator rit;
	for (rit = str.rbegin(); rit < str.rend(); rit++)
		cout << *rit;
	return 0;
}

rend()

reverse_iterator rend();
const_reverse_iterator rend() const;
返回指向字符串中第一个字符之前的元素的反向迭代器，该元素被视为反向结束。

rend指的是将被成员begin引用的字符之前的字符。

int main ()
{
  string str ("now step live...");
  string::reverse_iterator rit;
  for ( rit=str.rbegin() ; rit < str.rend(); rit++ )
    cout << *rit;
  return 0;
}

Capacity(容量相关)

size()

返回字符串长度（不包含’\0’）

length()

string::length is an alias of string::size, returning both the exact same value.
String::length是String::size的别名，返回完全相同的值。

resize()

两种构造方法：
void resize ( size_t n, char c );
void resize ( size_t n );

将字符串内容调整为n个字符。
如果n小于字符串的当前长度，内容将缩减到前n个字符，其余字符将被删除。
如果n大于字符串的当前长度，内容将通过追加c字符的实例来扩展，以达到n个字符的大小。
第二个版本实际上调用:resize(n,char())，因此当一个字符串在不传递第二个参数的情况下被调整为更大的大小时，新的字符位置将用char的默认值填充，即null字符。

capacity()

size_t capacity ( ) const;
返回字符串对象中分配的存储空间的大小。
注意容量不一定等于符合字符串内容的字符数（这可以通过成员大小或长度获得），而是分配空间的容量，等于或大于这个内容大小。
另请注意，此容量不限制字符串的长度。
如果需要更多空间来容纳字符串对象中的内容，则容量会自动扩展，甚至可以通过调用成员保留来显式修改。
字符串对象可以达到的大小的真正限制由成员 max_size 返回。

reserve()

void reserve ( size_t res_arg=0 );
请求修改容量
请求字符串中已分配存储空间的容量至少为res_arg。
这可以扩展或收缩字符串中存储空间的大小，尽管注意，调用该函数后的结果容量不一定等于res_arg，但可以等于或大于res_arg， 因此，在特定的库实现中，减少请求可能会也可能不会实际减少分配的空间。 在任何情况下，它都不会修剪字符串内容(为此，请参阅修改内容的resize或clear)。

注：在vs2019下是按1.5倍容量扩展的，底层会有16字节用来存储字符
底层：

其中初始容量为15。

clear()

void clear();
明确的字符串
字符串内容被设置为空字符串，删除之前的任何内容，因此其大小保持为0个字符

empty()

bool empty ( ) const;
测试字符串是否为空
返回字符串是否为空，即其大小是否为0。
这个函数不会以任何方式修改字符串的内容。 要清除字符串的内容，可以使用成员clear。
返回值
如果字符串大小为0则为True，否则为false。

Element access（元素访问）

operator[]

const char& operator[] ( size_t pos ) const;
char& operator[] ( size_t pos );
获取字符串中的字符
返回字符串中位置pos的字符的引用。
函数实际上返回data()[pos]。
除了at也执行范围检查之外，at成员函数具有与此操作符函数相同的行为。
参数：pos
要检索的字符字符串中的位置。 注意，字符串中的第一个字符的位置是0，而不是1。
Size_t是一个无符号整型。
返回值
在字符串中指定位置的字符。

at

const char& at ( size_t pos ) const;
char& at ( size_t pos );
字符串中的Et字符
返回字符串中位于pos位置的字符。

除了at也执行范围检查，如果pos不是字符串中的实际位置，则抛出类型为out_of_range的异常外，该成员函数的行为与operator[]类似。

参数： pos
要检索的字符字符串中的位置。 注意，字符串中的第一个字符的位置是0。
如果传递的位置超过str的结尾，则抛出out_of_range异常。
Size_t是一个无符号整型。

返回值
在字符串中指定位置的字符。

Modifiers（修饰符）

operator+=

string& operator+= ( const string& str );
string& operator+= ( const char* s );
string& operator+= ( char c );

push_back()

void push_back ( char c );
附加到字符串
将实参的副本附加到字符串。 附加字符到字符串
将单个字符追加到字符串内容，使其大小增加1。

若要一次追加多个字符，可以引用成员append或操作符+=。

新的字符串内容是在调用之前字符串对象中存在的内容，后面跟着参数的内容。

append成员函数提供了类似的功能，并提供了其他选项。

insert()

string& insert ( size_t pos1, const string& str );
string& insert ( size_t pos1, const string& str, size_t pos2, size_t n );
string& insert ( size_t pos1, const char* s, size_t n);
string& insert ( size_t pos1, const char* s );
string& insert ( size_t pos1, size_t n, char c );
iterator insert ( iterator p, char c );
void insert ( iterator p, size_t n, char c );
template< class InputIterator >
void insert ( iterator p, InputIterator first, InputIterator last );

当前字符串内容可以通过在字符串内容的特定位置插入一些额外内容来扩展(这个位置由pos1或p决定，取决于所使用的函数版本)。

传递给函数的参数决定了插入的内容:

string& insert ( size_t pos1, const string& str );
在字符位置pos1处插入整个字符串对象str的副本。

string& insert ( size_t pos1, const string& str, size_t pos2, size_t n );
在字符位置pos1处插入str子字符串的副本。子字符串是str的一部分，从字符位置pos2开始，最多占用n个字符(如果在此之前到达str的末尾，则占用小于n)。

string& insert (size_t pos1, const char* s, size_t n);
在字符位置pos1处插入由s指向的字符数组的前n个字符组成的字符串的副本。

string& insert (size_t pos1, const char * s);
在字符位置pos1插入一个由s指向的以空结尾的字符序列(C字符串)所组成的字符串的副本。该字符序列的长度由第一次出现的空字符决定(由traits.length(s)决定)。

string& insert (size_t pos1, size_t n, char c);
在字符位置pos1处插入由重复字符c (n次)组成的字符串。

iterator insert ( iterator p, char c );
在迭代器p所指向的位置插入字符c的副本，并返回一个指向该字符插入位置的迭代器。

void insert ( iterator p, size_t n, char c );
在迭代器p引用的位置插入由字符c重复n次形成的字符串。

template< class InputIterator >
void insert ( iterator p, InputIterator first, InputIterator last );
在p引用的内部位置插入由迭代器first引用的元素到最后引用的元素之前的字符组成的内容。

erase()

string& erase ( size_t pos = 0, size_t n = npos );
iterator erase ( iterator position );
iterator erase ( iterator first, iterator last );

删除部分字符串内容，缩短字符串长度。
受影响的字符取决于使用的成员函数版本:

string& erase ( size_t pos = 0, size_t n = npos );
删除从位置pos开始的n个字符序列。注意这两个形参都是可选的:如果只有一个实参，函数将删除position pos forward中的所有内容，如果没有实参，函数将删除整个字符串，如member clear。

string& erase ( size_t pos = 0, size_t n = npos );
擦除迭代器位置所引用的字符。只有一个角色受影响。

iterator erase ( iterator first, iterator last );
擦除开头和结尾之间的所有字符。

swap()

void swap ( string& str );
将string对象的内容与string对象str的内容交换，这样在调用这个成员函数之后，这个string对象的内容就是调用之前在str中的内容，而str对象的内容就是在这个string对象中的内容。

注意，具有相同名称的全局函数swap具有相同的行为，并且它作为具有相同名称的算法函数的字符串的专门化。

String operations（字符串操作）

c_str()

char * strcpy ( char * destination, const char * source );
将源指向的C字符串复制到目标指向的数组中，包括结束的空字符。

为了避免溢出，destination指向的数组的大小应该足够长，以包含与source相同的C字符串(包括结束的null字符)，并且不应该在内存中与source重叠。

int main()
{
	string s1("ma jia hao!");
	char* s2 = new char[s1.size() + 1];
	strcpy(s2, s1.c_str());
	cout << "s1:" << s1 << "s2:" << s2 << endl;
	return 0;
}

find()

size_t find ( const string& str, size_t pos = 0 ) const;
size_t find ( const char* s, size_t pos, size_t n ) const;
size_t find ( const char* s, size_t pos = 0 ) const;
size_t find ( char c, size_t pos = 0 ) const;
在字符串中搜索str、s或c中指定的内容，并返回字符串中第一个出现的位置。

当指定pos时，搜索只包含位置pos上或之后的字符，忽略前面位置中任何可能出现的字符。

注意，与成员find_first_of不同，每当要搜索多个字符时，仅匹配其中一个字符是不够的，必须匹配要查找的整个字符序列。

rfind()

size_t rfind ( const string& str, size_t pos = npos ) const;
size_t rfind ( const char* s, size_t pos, size_t n ) const;
size_t rfind ( const char* s, size_t pos = npos ) const;
size_t rfind ( char c, size_t pos = npos ) const;

在字符串中搜索str、s或c中指定的内容，并返回字符串中最后出现的位置。

当指定pos时，搜索只包括字符串开始和位置pos之间的字符，忽略pos之后可能出现的任何字符。

注意：最后一个示例

find_first_of()

size_t find_first_of ( const string& str, size_t pos = 0 ) const;
size_t find_first_of ( const char* s, size_t pos, size_t n ) const;
size_t find_first_of ( const char* s, size_t pos = 0 ) const;
size_t find_first_of ( char c, size_t pos = 0 ) const;
在字符串中搜索属于str、s或c的任何字符，并返回字符串中第一个出现的字符的位置。

当指定了pos时，搜索只包含位置pos上或之后的字符，忽略前面字符位置上可能出现的任何字符。

注意，要匹配一个字符串，只要其中一个字符匹配(任意一个)就足够了。要搜索整个字符序列，请使用find。

find_last_of()

size_t find_last_of ( const string& str, size_t pos = npos ) const;
size_t find_last_of ( const char* s, size_t pos, size_t n ) const;
size_t find_last_of ( const char* s, size_t pos = npos ) const;
size_t find_last_of ( char c, size_t pos = npos ) const;
从字符串末尾开始搜索属于str、s或c的任何字符，并返回字符串中最后出现的字符的位置。

当指定pos时，搜索只包括位置pos上或位置pos之前的字符，忽略它之后字符位置上可能出现的任何字符。

注意，要想匹配，只要有一个字符匹配字符串(任意字符)就足够了。如果要从末尾开始搜索整个字符序列，可以使用rfind。

find_first_not_of()

size_t find_first_not_of ( const string& str, size_t pos = 0 ) const;
size_t find_first_not_of ( const char* s, size_t pos, size_t n ) const;
size_t find_first_not_of ( const char* s, size_t pos = 0 ) const;
size_t find_first_not_of ( char c, size_t pos = 0 ) const;
搜索对象中不属于str、s或c的第一个字符，并返回其位置。

当指定了pos时，搜索只包含位置pos上或之后的字符，忽略前面字符位置中的任何内容。

find_last_not_of()

size_t find_last_not_of ( const string& str, size_t pos = npos ) const;
size_t find_last_not_of ( const char* s, size_t pos, size_t n ) const;
size_t find_last_not_of ( const char* s, size_t pos = npos ) const;
size_t find_last_not_of ( char c, size_t pos = npos ) const;

搜索对象中不属于str、s或c的最后一个字符，并返回其位置。

当指定了pos时，搜索只包含位置pos上或位置pos之前的字符，忽略其之后字符位置中的任何内容。

substr()

string substr ( size_t pos = 0, size_t n = npos ) const;

返回一个字符串对象，其内容初始化为当前对象的子字符串。

这个子字符串是从字符位置pos开始的字符序列，长度为n个字符。

compare()

int compare ( const string& str ) const;
int compare ( const char* s ) const;
int compare ( size_t pos1, size_t n1, const string& str ) const;
int compare ( size_t pos1, size_t n1, const char* s) const;
int compare ( size_t pos1, size_t n1, const string& str, size_t pos2, size_t n2 ) const;
int compare ( size_t pos1, size_t n1, const char* s, size_t n2) const;

将此对象(或其子字符串，称为compared (sub)string)的内容与比较字符串的内容进行比较，比较字符串是根据所传递的参数形成的。

如果比较内容中的所有字符都相等，则成员函数返回0;如果第一个不匹配的字符在对象中与比较字符串中的less比较，则返回负值;反之则返回正值。

请注意，对于字符串对象，字符比较的结果只取决于它的字符代码(即它的ASCII代码)，因此结果具有一些有限的字母或数字顺序意义。

对于其他basic_string类实例化，比较取决于特定的traits::compare函数，其中traits是类模板形参之一。