string(const char *s);//用c字符串s初始化
string(int n,char c);//用n个字符c初始化
string s1;//空串
string s2 = "hello"

const char &operator[](int n)const;//s[1]
const char &at(int n)const;//s.at[1]
char &operator[](int n);
char &at(int n);//at会提供越界检查
const char *data()const;//返回一个非null终止的c字符数组
const char *c_str()const; //返回一个以null终止的c字符串
int copy(char *s,int n,int pos = 0)const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中,返回实际拷贝的数目.

int capacity()const;//返回当前容量,即最大可存放的元素数量 15 当capacity满,string会自己扩展空间,除非非常在意内存,无需在意.
int max_size()const;//返回string对象中可存放的最大字符串的长度 2147483647
int size()const; //返回当前字符串的大小
int length()const; //返回当前字符串的长度 两者等价 为了可读性存在
bool empt()const; //返回字符串是否为空
void resize(int len,char c = '\0');//把字符串大小置为len,并用字符c填充不足的部分 如果len小于size,会做截取

getline(istream &in,string &s); //用于从输入流(如文件)in中读取字符串到s中,以'\n'结尾

string &operator=(const string &s); //把字符串s赋给当前字符串
string &assign(const char *s); //把c类型字符串s赋值
string &assign(const char *s,int n); //把c字符串s开始的n字符赋值
string &assign(const string &s); //把字符串s赋给当前字符串
string &assign(int n,char c); //用n个字符c赋值给当前字符串
string &assign(const string &s,int start,int n); //把字符串中从start开始的n个字符赋给当前字符串
string &assign(const_iterator first,const_iterator last); //把first和last迭代器之间的部分赋给字符串

string &operator+=(const string &s); //把字符串s连接到放弃字符串的结尾
string &append(const char *s); //把c类型字符串s连接到当前字符串结尾
string &append(const char *s,int n); //把c类型字符串s的前n个字符连接到当前字符串结尾
string &append(const string &s); //等价于+=
string &append(const string &s,int pos,int n);//把字符串s中从pos开始的n个字符连接到当前字符串的结尾
string &append(int n,char c); //在当前字符串结尾添加n个字符c
string &append(const_iterator first,const_iterator last); //把迭代器first和last之间的部分连接到当前字符串的结尾

bool operator==(const string &s1,const string &s2)const; //比较两个字符串是否相等
//运算符 '>','<','>=','<=','!='均已被重载
int compare(const string &s) const; //比较当前字符串和s的大小 this - s
int compare(int pos,int n,const string &s)const; //比较当前字符串从pos开始的n个字符组成的字符串与s的大小
int compare(int pos,int n,const string &s,int pos2,int n2);//比较当前字符串从pos开始的n个字符组成的字符串与s从pos2开始的n2个字符组成的字符串的大小
int compare(const char *s) const;//比较c风格字符串和当前字符串大小
int compare(int pos,int n,const char *s) const;
int compare(int pos,int m,const char *s,int pos2,int n2) const;

string substr(int pos = 0,int n = npos) const;//返回pos开始的n个字符组成的字符串

int find(char c,int pos = 0) const; //从pos开始查找字符c在当前字符串的位置
int find(const char *s,int pos = 0) const; //从pos开始查找字符串s在当前串中的位置
int find(const char *s,int pos,int n) const;//从pos开始查找字符串s中前n个字符在当前串中的位置
int find(const string &s,int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
//成功时返回所在位置,失败返回string::npos的值
int rfind(char c,int pos = npos) const; //从pos开始 从后向前查找字符c在当前串中的位置
int rfind(const char *s,int pos = npos) const; //从pos开始 从后向前查找字符串s在当前串中的位置
int rfind(const char *s,int pos,int n = npos) const; //从pos开始 从后向前查找s的前n个字符在字符串中最先出现的位置.  
int rfind(const string &s,int pos = npos) const; //从pos开始 从后向前查找字符串s的前n个字符最早出现的位置 失败返回string::npos的值

int find_first_of(char c,int pos = 0) const;//从pos开始查找字符c第一次出现的位置
int find_first_of(const char *s,int pos = 0) const;
int find_first_of(const char *s,int pos,int n) const;
int find_first_of(const string &s,int pos = 0) const;//从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置.失败返回string::npos.

int find_first_not_of(char c,int pos = 0) const;
int find_first_not_of(const char *s,int pos = 0,int n = npos) const;
int find_first_not_of(const string &s,int pos = 0) const;//从当前串中查找第一个不在串s中的字符出现的位置.失败返回string::npos

string &replace(int p0,int n0,const char *s);//删除从p0开始的n0个字符,插入s,返回替换后的当前字符串
string &replace(int p0,int n0,const char *s,int n);//删除从p0开始的n0个字符,插入s的前n个字符.
string &replace(int p0,int n0,const string &s);//删除从p0开始的n0个字符,插入字符串s.
string &replace(int p0,int n0,const string &s,int pos,int n);//删除从p0开始的n0个字符,插入s从pos开始的n个字符.
string &replace(int p0,int n0,int n, char c);//删除p0开始的n0个字符,然后在p0处插入n个字符c
string &replace(iterator first0, iterator last0,const string &s);//把[first0，last0）之间的部分替换为串s
string &replace(iterator first0, iterator last0,int n, char c);//把[first0，last0）之间的部分替换为n个字符c
string &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0，last0）之间的部分替换成[first，last）之间的字符串

string &insert(int p0,const char *s);
string &insert(int p0,const char *s,int n);
string &insert(int p0,const string &s);
string &insert(int p0,const string &s,int pos,int n);//在当前字符串的p0位置插入s从pos开始的n字符.
string &insert(int p0,int n,char c);//在p0处插入n个字符c
iterator insert(iterator it, char c);//在it处插入字符c，返回插入后迭代器的位置
void insert(iterator it, const_iterator first, const_iterator last);//在it处插入[first，last）之间的字符
void insert(iterator it, int n, char c);//在it处插入n个字符c

iterator erase(iterator first,iterator last); //删除[first,last)之间的所有字符,返回删除后迭代器的位置
iterator erase(iterator it); //删除it指向的字符,返回删除后迭代器的位置
string &erase(int pos = 0,int n = npos); //删除pos开始的n个字符,返回修改后的字符串

const_iterator begin()const;
iterator begin();                //返回string的起始位置
const_iterator end()const;
iterator end();                    //返回string的最后一个字符后面的位置
const_iterator rbegin()const;
iterator rbegin();                //返回string的最后一个字符的位置
const_iterator rend()const;
iterator rend();                    //返回string第一个字符位置的前面

string input("hello cat 1 2");
string s1,s2,s3,s4;
istringstream is(input);
is >> s1 >> s2 >> s3 >> s4;//s1 = "hello" s2 = "cat" s3 = "1" s4 = "2"
ostringstream os;
os << s1 << s2 << s3 << s4;
cout << os.str();