string类的使用手册

1.构造函数

补充：npos：size_t类型数据的最大值

default (1)	string(); 构造空的string类对象
copy (2)	string (const string& str); 拷贝构造函数（深拷贝）
substring (3)	string (const string& str, size_t pos, size_t len = npos); 在str的pos处开始，拷贝len个字符。如果len为npos（不传参）或str从pos到尾的字符个数小于len，则有多少拷多少
from c-string (4)	string (const char* s); 用C-str来构造string类的对象
from sequence (5)	string (const char* s, size_t n); 拷贝s的前n个字符
fill (6)	string (size_t n, char c); 用n个字符连续的字符c来构造string类的对象
range (7)	template <class InputIterator> string (InputIterator first, InputIterator last); 用从first到last（last取不到）的字符串构造string对象

2.string类的对象的容器操作

2.1 size

返回string的长度。

2.2 lenth

返回string的长度。

2.3 capacity

返回空间总大小

2.4 empty

检测字符串是否为空串，如果是，返回true，反之返回false。

2.5 clear

清空有效字符，使其变为空串

2.6 reserve

预留能容纳n个字符空间，也就是扩容。但是，这个操作不会改变size和内容。

注意：标准并未要求该函数一定要有缩容的功能。

2.7 resize

将有效字符改成n个。

如果n等于size，什么也不做。

如果n大于size，则尾插连续的字符c，使得size与n相等。如果没有指定字符c，则默认c为'\0'

如果n小于size，则保留前n个字符，多余的部分直接去掉。

注意：该函数会将size变成n，改变size的同时也改变了内容。并且，这个操作可能改变capacity

3.迭代器

定义：迭代器不一定是指针，但迭代器有类似于指针的供能。迭代器也有指向性，可以指向某一块空间；迭代器也可以解引用，用于访问迭代器指向的空间。

string类的迭代器有四种。

iterator	a random access iterator to char (convertible to const_iterator) 正向迭代器访问char类型（iterator类型迭代器可转换成const_iterator）
const_iterator	a random access iterator to const char 正向常迭代器访问const_char类型
reverse_iterator	reverse_iterator<iterator> 反向迭代器访问char类型(reverse_iterator可转换成const_reverse_iterator)
const_reverse_iterator	reverse_iterator<const_iterator> 反向常迭代器访问const_char类型

上述未具体说明的迭代器都不可以相互转换

正向迭代器和反向迭代器的区别：

1.正向迭代器左小右大，逆向迭代器左大右小

2.正向迭代器+n将向右偏移n份空间，逆向迭代器+n将向左偏移n份空间

3.1 begin

返回指向第一个字符的正向（常）迭代器

3.2 end

返回指向最后一个字符的正向（常）迭代器

3.3 rbegin

返回指向最后一个字符的逆向（常）迭代器

3.4 rend

返回指向第一个字符的逆向（常）迭代器

3.5 operator[]

取出string对象的第pos个字符的引用。（由于取出的是引用，所以可以通过这种方法在string对象中写入数据）

有了迭代器以及对[]的重载，可以做出以下遍历。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;
int main()
{
	string A = "asdfg";
	for (string::iterator it = A.begin(); it < A.end(); it++)//正向
		cout << *it;
	cout << endl;
 
	for (string::reverse_iterator it = A.rbegin(); it < A.rend(); it++)//逆向
		cout << *it;
	cout << endl;
	for (size_t i = 0; i < A.size(); i++)//正向
		cout << A[i];
	cout << endl;
	for (int i = A.size() - 1; i >= 0; i--)//逆向
		cout << A[i];
	cout << endl;
	return 0;
}

4.修改

4.1 push_back

后增一个字符，使size+1，可能改变capacity（取决于是否右扩容）

4.2 oprator+=

string (1)	string& operator+= (const string& str); 后增一个string对象
c-string (2)	string& operator+= (const char* s); 后增一个C-string
character (3)	string& operator+= (char c); 后增一个字符

4.3 append

string (1)	string& append (const string& str); 后增一个string对象
substring (2)	string& append (const string& str, size_t subpos, size_t sublen); 在str的subpos处取sublen个连续的字符（如果sublen比可取的字符数量多或sublen为npos，则有多少取多少），后增到string对象中
c-string (3)	string& append (const char* s); 后增一个C-string
buffer (4)	string& append (const char* s, size_t n); 后增s的前n个字符
fill (5)	string& append (size_t n, char c); 后增n个连续的字符c
range (6)	template <class InputIterator> string& append (InputIterator first, InputIterator last); 后增一个从first到last（last处取不到）的字符串

4.4 insert

string (1)	string& insert (size_t pos, const string& str); 在string对象的pos处插入str
substring (2)	string& insert (size_t pos, const string& str, size_t subpos, size_t sublen); 从str的pos处取subpos个字符（如果sublen比可取的字符数量多或sublen为npos，则有多少取多少），插入到string对象的pos处
c-string (3)	string& insert (size_t pos, const char* s); 在string对象的pos处插入s
buffer (4)	string& insert (size_t pos, const char* s, size_t n); 在string对象的pos处插入s的前n个字符
fill (5)	string& insert (size_t pos, size_t n, char c); void insert (iterator p, size_t n, char c); 在string对象的pos或p处插入连续个字符c（注意:使用insert插入一个字符时，必须写上需插入字符的数量，也就是1，这个设计很阴间，小心一点别写错了）
single character (6)	iterator insert (iterator p, char c); 在string对象的p处插入字符c
range (7)	template <class InputIterator> void insert (iterator p, InputIterator first, InputIterator last); 在p处插入一个从first到last（last处取不到）的一个字符串

4.5 erase

sequence (1)	string& erase (size_t pos = 0, size_t len = npos); 从pos处开始删除len个字符（如果len比可删除的字符还要多或者len为npos，有多少删多少）
character (2)	iterator erase (iterator p); 删除p处的一个字符
range (3)	iterator erase (iterator first, iterator last); 将string对象的first到last（last处取不到）删除

sequence (1)

 string& erase (size_t pos = 0, size_t len = npos);
从pos处开始删除len个字符（如果len比可删除的字符还要多或者len为npos，有多少删多少）

character (2)

iterator erase (iterator p);
删除p处的一个字符

range (3)

     iterator erase (iterator first, iterator last);
将string对象的first到last（last处取不到）删除

4.6 assign

为string对象指定一个新的字符串，替换当前内容。

注意：这里功能类似于构造函数（初始化），但这不是初始化。

string (1)	string& assign (const string& str); 用对象str构造string对象
substring (2)	string& assign (const string& str, size_t subpos, size_t sublen); 取str从subpos开始的sublen个字符（如果sublen比可取的字符数量多或sublen为npos，则有多少取多少），构造string对象
c-string (3)	string& assign (const char* s); 用C-string构造string对象
buffer (4)	string& assign (const char* s, size_t n); 取s开始的前n个字符，构造string对象
fill (5)	string& assign (size_t n, char c); 用连续的n个字符c构造string对象
range (6)	template <class InputIterator> string& assign (InputIterator first, InputIterator last); 用从first到last（last指向的位置取不到）的子串构造string对象

4.7 replace

string (1)	string& replace (size_t pos, size_t len, const string& str); string& replace (iterator i1, iterator i2, const string& str);
substring (2)	string& replace (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen);
c-string (3)	string& replace (size_t pos, size_t len, const char* s); string& replace (iterator i1, iterator i2, const char* s);
buffer (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);
fill (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);
range (6)	template <class InputIterator> string& replace (iterator i1, iterator i2, InputIterator first, InputIterator last);