string常用操作

#include <string>

//The string class is an instantiation of the basic_string class template, defined in <string> as:
typedef basic_string<char> string;
string实际上是basic_string<char>的一个typedef，同时省略了与内存管理相关的参数。

string s1;	        默认构造函数 s1 为空串
string s2(s1);	    将 s2初始化为 s1 的一个副本
string s3(“value”);	将 s3 初始化为一个字符串字面值副本
string s4(n, ‘c’);	将 s4 初始化为字符 ‘c’ 的 n 个副本

void swap(string &x)　重载1：x.swap(y)
void swap (string& x, string& y)  重载2: swap(x, y)
q.swap(p) //交换两个string
所有迭代器和引用都可能无效

cin >> s;

string word;
程序将从标准输入读取一组 string 对象，然后在标准输出上逐行输出：
while (cin >> word)
	cout << word << endl;

string line; // read line at time until end-of-file
while (getline(cin, line))  //循环读取输入流
	cout << line << endl;

// st1 is an empty string, st2 is a copy of the literal
string st1, st2 = "The expense of spirit";
st1 = st2; // replace st1 by a copy of st2
它必须先把 st1 占用的相关内存释放掉，然后再分配给 st2 足够存放 st2 副本的内存空间，最后把 st2 中的所有字符复制到新分配的内存空间。

string s1 = "hello"; // no punctuation
string s2 = "world";
string s3 = s1 + ", "; // ok: adding a string and a literal
string s4 = "hello" + ", "; // error: no string operand s4 的初始化试图将两个字符串字面值相加，因此是非法的
string s5 = s1 + ", " + "world"; // ok: each + has string operand
string s6 = "hello" + ", " + s2; // error: can't add string literals
 s6 的初始化是非法的。依次来看每个子表达式，则第一个子表达式试图把两个字符串字面值连接起来。这是不允许的，因此这个语句是错误的。

s.empty();	    true如果字符串为空, 否则返回false
s.size();       字符串中CharT元素的数量
s.length();	    字符串中CharT元素的数量
s.capacity();	返回字符串当前为其分配空间的字符数
s.max_size();   返回string对象能够容纳的字符的最大数目
s.resize(size_t n, char c);  用来改变string的大小，如果size小于原来string的size大小，则截取前面的size个字符，如果大于，则用空格填充。
s.resize(size_t n); 
s.reserve(size_t res_arg=0);为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserve不会改变容量大小。 
s.shrink_to_fit()	请求删除未使用的容量

s.append(args);	将args追加到s.返回一个指向s的引用.
s.assign(args);	将s中的字符替换为args指定的字符.返回一个指向s的引用.
s.push_back(char c); 在末尾添加一个元素，返回值为空
string& insert ( size_t pos1, size_t n, char c ); 在字符串pos1位置，插入n次c字符。 
size_t copy ( char* s, size_t n, size_t pos = 0) const; 从pos位置开始，复制n个字符到s指针指向的内存；

  string str="to be question";
  string str2="the ";
  string str3="or not to be";
  string::iterator it;
  // used in the same order as described above:
  str.insert(6,str2);                 // to be (the )question
  str.insert(6,str3,3,4);             // to be (not )the question
  str.insert(10,"that is cool",8);    // to be not (that is )the question
  str.insert(10,"to be ");            // to be not (to be )that is the question
  str.insert(15,1,':');               // to be not to be(:) that is the question
  it = str.insert(str.begin()+5,','); // to be(,) not to be: that is the question
  str.insert (str.end(),3,'.');       // to be, not to be: that is the question(...)
  str.insert (it+2,str3.begin(),str3.begin()+3); // (or )
Output:to be, or not to be: that is the question...

  string str;
  string str2="Writing ";
  string str3="print 10 and then 5 more";

  str.append(str2);                       // "Writing "
  str.append(str3,6,3);                   // "10 "
  str.append("dots are cool",5);          // "dots "
  str.append("here: ");                   // "here: "
  str.append(10,'.');                     // ".........."
  str.append(str3.begin()+8,str3.end());  // " and then 5 more"
  str.append<int>(5,0x2E);                // "....."
Output:  Writing 10 dots here: .......... and then 5 more.....

s[index]; 
s.at(index); index是下标 
size_t find (char c, size_t pos =0) const;	 从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
size_t rfind(char c, size_t pos = npos);	 反向查找，从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
string substr(size_t pos = 0, size_t n= npos)const;	在str中从pos位置开始，截取n个字符，然后将其返回

s.clear()	从字符串中删除所有字符, clear()只是将string中有效字符清空，不改变底层空间大小。
s.erase(pos,len); 删除从位置pos开始的len个字符,如果len被省略,则删除从pos开始直至s末尾的所有字符.返回一个指向s的引用.
iterator erase (const_iterator p); 删除源字符串中迭代器p指向的字符，返回删除后迭代器的位置。
iterator erase (const_iterator first, const_iterator last); 删除源字符串迭代器范围为[first，last）内的所有字符，返回删除后迭代器的位置。
s.pop_back(); 删除源字符串的最后一个字符，有效的减少它的长度。

s=std::to_string(int/double/...);

string to_string (int val);
string to_string (long val);
string to_string (long long val);
string to_string (unsigned val);
string to_string (unsigned long val);
string to_string (unsigned long long val);
string to_string (float val);
string to_string (double val);
string to_string (long double val);

s.data();	返回指向字符串第一个字符的指针
s.begin();  返回字符串第一个字符的迭代器,const
s.cbegin(); 返回字符串第一个字符的迭代器
s.end();    返回字符串最后一个字符的后面一个位置的迭代器
s.cend();   返回字符串最后一个字符的后面一个位置的迭代器,const
s.rbegin(); 反向迭代器
s.rend();   反向迭代器
string::npos     相当于s.end()