c++中的string常用函数用法总结
字体：[ ] 类型：转载 时间：
以下是对c++中的string常用函数的用法进行了详细的分析介绍，需要的朋友可以过来参考下
标准c++中string类函数介绍注意不是CString之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必 担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据类型。
好了，进入正题………首先，为了在我们的程序中使用string类型，我们必须包含头文件 &string&。
如下：#include &string& //注意这里不是string.h string.h是C字符串头文件#include &string&
1．声明一个C++字符串声明一个字符串变量很简单：string S这样我们就声明了一个字符串变量，但既然是一个类，就有构造函数和析构函数。上面的声明没有传入参数，所以就直接使用了string的默认的构造函数，这个函数所作的就是把Str初始化为一个空字符串。String类的构造函数和析构函数如下：a)&&&&&&&& //生成一个空字符串sb)&&&&& string s(str) //拷贝构造函数 生成str的复制品c)&&&&& string s(str,stridx) //将字符串str内“始于位置stridx”的部分当作字符串的初值d)&&&&& string s(str,stridx,strlen) //将字符串str内“始于stridx且长度顶多strlen”的部分作为字符串的初值e)&&&&& string s(cstr) //将C字符串作为s的初值f)&&&&& string s(chars,chars_len) //将C字符串前chars_len个字符作为字符串s的初值。g)&&&&& string s(num,c) //生成一个字符串，包含num个c字符h)&&&&& string s(beg,end) //以区间end(不包含end)内的字符作为字符串s的初值i)&&&&& s.~string() //销毁所有字符，释放内存都很简单，我就不解释了。
2．字符串操作函数这里是C++字符串的重点，我先把各种操作函数罗列出来，不喜欢把所有函数都看完的人可以在这里找自己喜欢的函数，再到后面看他的详细解释。a) =,assign()&&&& //赋以新值b) swap()&&&& //交换两个字符串的内容c) +=,append(),push_back() //在尾部添加字符d) insert() //插入字符e) erase() //删除字符f) clear() //删除全部字符g) replace() //替换字符h) + //串联字符串i) ==,!=,&,&=,&,&=,compare()&&& //比较字符串j) size(),length()&&& //返回字符数量k) max_size() //返回字符的可能最大个数l) empty()&&& //判断字符串是否为空m) capacity() //返回重新分配之前的字符容量n) reserve() //保留一定量内存以容纳一定数量的字符o) [ ], at() //存取单一字符p) &&,getline() //从stream读取某值q) &&&&& //将谋值写入streamr) copy() //将某值赋值为一个C_strings) c_str() //将内容以C_string返回t) data() //将内容以字符数组形式返回u) substr() //返回某个子字符串v)查找函数w)begin() end() //提供类似STL的迭代器支持x) rbegin() rend() //逆向迭代器y) get_allocator() //返回配置器
下面详细介绍：
2．1 C++字符串和C字符串的转换C ++提供的由C++字符串得到对应的C_string的方法是使用data()、c_str()和copy()，其中，data()以字符数组的形式返回字符串内容，但并不添加'/0'。c_str()返回一个以‘/0'结尾的字符数组，而copy()则把字符串的内容复制或写入既有的c_string或 字符数组内。C++字符串并不以'/0'结尾。我的建议是在程序中能使用C++字符串就使用，除非万不得已不选用c_string。由于只是简单介绍，详细介绍掠过，谁想进一步了解使用中的注意事项可以给我留言(到我的收件箱)。我详细解释。
2．2 大小和容量函数一个C++字符串存在三种大小：a)现有的字符数，函数是size()和length()，他们等效。Empty()用来检查字符串是否为空。b)max_size() 这个大小是指当前C++字符串最多能包含的字符数，很可能和机器本身的限制或者字符串所在位置连续内存的大小有关系。我们一般情况下不用关心他，应该大小足够我们用的。但是不够用的话，会抛出length_error异常c)capacity()重新分配内存之前 string所能包含的最大字符数。这里另一个需要指出的是reserve()函数，这个函数为string重新分配内存。重新分配的大小由其参数决定， 默认参数为0，这时候会对string进行非强制性缩减。还有必要再重复一下C++字符串和C字符串转换的问 题，许多人会遇到这样的问题，自己做的程序要调用别人的函数、类什么的（比如数据库连接函数Connect(char*,char*)），但别人的函数参 数用的是char*形式的，而我们知道，c_str()、data()返回的字符数组由该字符串拥有，所以是一种const char*,要想作为上面提及的函数的参数，还必须拷贝到一个char*,而我们的原则是能不使用C字符串就不使用。那么，这时候我们的处理方式是：如果 此函数对参数(也就是char*)的内容不修改的话，我们可以这样Connect((char*)UserID.c_str(), (char*)PassWD.c_str()),但是这时候是存在危险的，因为这样转换后的字符串其实是可以修改的（有兴趣地可以自己试一试），所以我强调除非函数调用的时候不对参数进行修改，否则必须拷贝到一个char*上去。当然，更稳妥的办法是无论什么情况都拷贝到一个char*上去。同时我们也祈祷现在仍然使用C字符串进行编程的高手们（说他们是高手一点儿也不为过，也许在我们还穿开裆裤的时候他们就开始编程了，哈哈…）写的函数都比较规范，那样我们就不必进行强制转换了。
2．3元素存取我们可以使用下标操作符[]和函数at()对元素包含的字符进行访问。但是应该注意的是操作符[]并不检查索引是否有效（有效索引0~str.length()），如果索引失效，会引起未定义的行为。而at()会检查，如果使用 at()的时候索引无效，会抛出out_of_range异常。
有一个例外不得不说，的操作符[]对索引值是a.length()仍然有效，其返回值是'/0'。其他的各种情况，a.length()索引都是无效的。举例如下：const string Cstr(“const string”);string Str(“string”);Str[3];&&&&& //okStr.at(3);&&& //okStr[100]; //未定义的行为Str.at(100);&&& //throw out_of_rangeStr[Str.length()]&&& //未定义行为Cstr[Cstr.length()] //返回 ‘/0'Str.at(Str.length());//throw out_of_rangeCstr.at(Cstr.length()) ////throw out_of_range我不赞成类似于下面的引用或指针赋值：char& r=s[2];char* p= &s[3];因为一旦发生重新分配，r,p立即失效。避免的方法就是不使用。
2．4比较函数C ++字符串支持常见的比较操作符（&,&=,&,&=,==,!=），甚至支持string与C-string的比较(如 str&”hello”)。在使用&,&=,&,&=这些操作符的时候是根据“当前字符特性”将字符按字典顺序进行逐一得 比较。字典排序靠前的字符小，比较的顺序是从前向后比较，遇到不相等的字符就按这个位置上的两个字符的比较结果确定两个字符串的大小。同时，string (“aaaa”) &string(aaaaa)。
另一个功能强大的比较函数是成员函数compare()。他支持多参数处理，支持用索引值和长度定位子串来进行比较。他返回一个整数来表示比较结果，返回值意义如下：0-相等 〉0-大于 &0-小于。举例如下：string s(“abcd”);<pare(“abcd”); //返回0<pare(“dcba”); //返回一个小于0的值<pare(“ab”); //返回大于0的值<pare(s); //相等<pare(0,2,s,2,2); //用”ab”和”cd”进行比较 小于零<pare(1,2,”bcx”,2); //用”bc”和”bc”比较。怎么样？功能够全的吧！什么？还不能满足你的胃口？好吧，那等着，后面有更个性化的比较算法。先给个提示，使用的是STL的比较算法。什么？对STL一窍不通？靠，你重修吧！
2．5 更改内容这在字符串的操作中占了很大一部分。首先讲赋值，第一个赋值方法当然是使用操作符=，新值可以是string(如：s=ns) 、c_string(如：s=”gaint”)甚至单一字符（如：s='j'）。还可以使用成员函数assign()，这个成员函数可以使你更灵活的对字符串赋值。还是举例说明吧：s.assign(str); //不说s.assign(str,1,3);//如果str是”iamangel” 就是把”ama”赋给字符串s.assign(str,2,string::npos);//把字符串str从索引值2开始到结尾赋给ss.assign(“gaint”); //不说s.assign(“nico”,5);//把'n' ‘I' ‘c' ‘o' ‘/0'赋给字符串s.assign(5,'x');//把五个x赋给字符串把字符串清空的方法有三个：s=””;s.clear();s.erase();(我越来越觉得举例比说话让别人容易懂！)。string提供了很多函数用于插入（insert）、删除（erase）、替换（replace）、增加字符。先说增加字符（这里说的增加是在尾巴上），函数有 +=、append()、push_back()。
举例如下：s+=//加个字符串s+=”my name is jiayp”;//加个C字符串s+='a';//加个字符s.append(str);s.append(str,1,3);//不解释了 同前面的函数参数assign的解释s.append(str,2,string::npos)//不解释了s.append(“my name is jiayp”);s.append(“nico”,5);s.append(5,'x');s.push_back(‘a');//这个函数只能增加单个字符对STL熟悉的理解起来很简单
也许你需要在string中间的某个位置插入字符串，这时候你可以用insert()函数，这个函数需要你指定一个安插位置的索引，被插入的字符串将放在这个索引的后面。&&&&& s.insert(0,”my name”);&&&&& s.insert(1,str);这种形式的insert()函数不支持传入单个字符，这时的单个字符必须写成字符串形式(让人恶心)。既然你觉得恶心，那就不得不继续读下面一段话：为了插 入单个字符，insert()函数提供了两个对插入单个字符操作的重载函数：insert(size_type index,size_type num,chart c)和insert(iterator pos,size_type num,chart c)。其中size_type是无符号整数，iterator是char*,所以，你这么调用insert函数是不行的：insert(0,1, 'j');这时候第一个参数将转换成哪一个呢？所以你必须这么写：insert((string::size_type)0,1,'j')！第二种形式指 出了使用迭代器安插字符的形式，在后面会提及。顺便提一下，string有很多操作是使用STL的迭代器的，他也尽量做得和STL靠近。
删除函数erase()的形式也有好几种（真烦！），替换函数replace()也有好几个。
举例吧：string s=”il8n”;s.replace(1,2,”nternationalizatio”);//从索引1开始的2个替换成后面的C_strings.erase(13);//从索引13开始往后全删除s.erase(7,5);//从索引7开始往后删5个
2．6提取子串和字符串连接题取子串的函数是：substr(),形式如下：s.substr();//返回s的全部内容s.substr(11);//从索引11往后的子串s.substr(5,6);//从索引5开始6个字符把两个字符串结合起来的函数是+。（谁不明白请致电120）
2．7输入输出操作1．&& 从输入流读取一个string。2．&& 把一个string写入输出流。另一个函数就是getline(),他从输入流读取一行内容，直到遇到分行符或到了文件尾。
2．8搜索与查找查找函数很多，功能也很强大，包括了：find()rfind()find_first_of()find_last_of()find_first_not_of()find_last_not_of()
这些函数返回符合搜索条件的字符区间内的第一个字符的索引，没找到目标就返回npos。所有的函数的参数说明如下：第一个参数是被搜寻的对象。第二个参数（可有可无）指出string内的搜寻起点索引，第三个参数（可有可无）指出搜寻的字符个数。比较简单，不多说不理解的可以向我提出，我再仔细的解答。当然，更加强大的STL搜寻在后面会有提及。最后再说说npos的含义，string::npos的类型是string::size_type,所以，一旦需要把一个索引与npos相比，这个索引值必须是string::size)type类型的，更多的情况下，我们可以直接把函数和npos进行比较（如：if(s.find(“jia”)== string::npos)）。
string类的构造函数：string(const char *s);&&& //用c字符串s初始化string(int n,char c);&&&& //用n个字符c初始化此外，string类还支持默认构造函数和复制构造函数，如string s1；string s2="hello"；都是正确的写法。当构造的string太长而无法表达时会抛出length_error异常
string类的字符操作：const char &operator[](int n)const char &at(int n)char &operator[](int n);char &at(int n);operator[]和at()均返回当前字符串中第n个字符的位置，但at函数提供范围检查，当越界时会抛出out_of_range异常，下标运算符[]不提供检查访问。const char *data()//返回一个非null终止的c字符数组const char *c_str()//返回一个以null终止的c字符串int copy(char *s, int n, int pos = 0)//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目
string的特性描述:int capacity()&&& //返回当前容量（即string中不必增加内存即可存放的元素个数）int max_size()&&& //返回string对象中可存放的最大字符串的长度int size()&&&&&&& //返回当前字符串的大小int length()&&&&&& //返回当前字符串的长度bool empty()&&&&&&& //当前字符串是否为空void resize(int len,char c);//把字符串当前大小置为len，并用字符c填充不足的部分
string类的输入输出操作:string类重载运算符operator&&用于输入，同样重载运算符operator&&用于输出操作。函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中，以换行符'\n'分开。
string的赋值：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);//把字符串s中从start开始的n个字符赋给当前字符串string &assign(const_iterator first,const_itertor last);//把first和last迭代器之间的部分赋给字符串
string的连接：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);&&& //同operator+=()string &append(const string &s,int pos,int n);//把字符串s中从pos开始的n个字符连接到当前字符串的结尾string &append(int n,char c);&&&&&&& //在当前字符串结尾添加n个字符cstring &append(const_iterator first,const_iterator last);//把迭代器first和last之间的部分连接到当前字符串的结尾
string的比较：bool operator==(const string &s1,const string &s2)//比较两个字符串是否相等运算符"&","&","&=","&=","!="均被重载用于字符串的比较；int compare(const string &s)//比较当前字符串和s的大小int compare(int pos, int n,const string &s)//比较当前字符串从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)int compare(int pos, int n,const char *s)int compare(int pos, int n,const char *s, int pos2)compare函数在&时返回1，&时返回-1，==时返回0&& string的子串：string substr(int pos = 0,int n = npos)//返回pos开始的n个字符组成的字符串
string的交换：void swap(string &s2);&&& //交换当前字符串与s2的值
string类的查找函数： int find(char c, int pos = 0)//从pos开始查找字符c在当前字符串的位置int find(const char *s, int pos = 0)//从pos开始查找字符串s在当前串中的位置int find(const char *s, int pos, int n)//从pos开始查找字符串s中前n个字符在当前串中的位置int find(const string &s, int pos = 0)//从pos开始查找字符串s在当前串中的位置//查找成功时返回所在位置，失败返回string::npos的值 int rfind(char c, int pos = npos)//从pos开始从后向前查找字符c在当前串中的位置int rfind(const char *s, int pos = npos)int rfind(const char *s, int pos, int n = npos)int rfind(const string &s,int pos = npos)//从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置，成功返回所在位置，失败时返回string::npos的值 int find_first_of(char c, int pos = 0)//从pos开始查找字符c第一次出现的位置int find_first_of(const char *s, int pos = 0)int find_first_of(const char *s, int pos, int n)int find_first_of(const string &s,int pos = 0)//从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。查找失败返回string::npos int find_first_not_of(char c, int pos = 0)int find_first_not_of(const char *s, int pos = 0)int find_first_not_of(const char *s, int pos,int n)int find_first_not_of(const string &s,int pos = 0)//从当前串中查找第一个不在串s中的字符出现的位置，失败返回string::npos int find_last_of(char c, int pos = npos)int find_last_of(const char *s, int pos = npos)int find_last_of(const char *s, int pos, int n = npos)int find_last_of(const string &s,int pos = npos) int find_last_not_of(char c, int pos = npos)int find_last_not_of(const char *s, int pos = npos)int find_last_not_of(const char *s, int pos, int n)int find_last_not_of(const string &s,int pos = npos)//find_last_of和find_last_not_of与find_first_of和find_first_not_of相似，只不过是从后向前查找
string类的替换函数： string &replace(int p0, int n0,const char *s);//删除从p0开始的n0个字符，然后在p0处插入串sstring &replace(int p0, int n0,const char *s, int n);//删除p0开始的n0个字符，然后在p0处插入字符串s的前n个字符string &replace(int p0, int n0,const string &s);//删除从p0开始的n0个字符，然后在p0处插入串sstring &replace(int p0, int n0,const string &s, int pos, int n);//删除p0开始的n0个字符，然后在p0处插入串s中从pos开始的n个字符string &replace(int p0, int n0,int n, char c);//删除p0开始的n0个字符，然后在p0处插入n个字符cstring &replace(iterator first0, iterator last0,const char *s);//把[first0，last0）之间的部分替换为字符串sstring &replace(iterator first0, iterator last0,const char *s, int n);//把[first0，last0）之间的部分替换为s的前n个字符string &replace(iterator first0, iterator last0,const string &s);//把[first0，last0）之间的部分替换为串sstring &replace(iterator first0, iterator last0,int n, char c);//把[first0，last0）之间的部分替换为n个字符cstring &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0，last0）之间的部分替换成[first，last）之间的字符串
string类的插入函数： 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);//前4个函数在p0位置插入字符串s中pos开始的前n个字符string &insert(int p0, int n, char c);//此函数在p0处插入n个字符citerator 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
string类的删除函数 iterator erase(iterator first, iterator last);//删除[first，last）之间的所有字符，返回删除后迭代器的位置iterator erase(iterator it);//删除it指向的字符，返回删除后迭代器的位置string &erase(int pos = 0, int n = npos);//删除pos开始的n个字符，返回修改后的字符串
string类的迭代器处理： string类提供了向前和向后遍历的迭代器iterator，迭代器提供了访问各个字符的语法，类似于指针操作，迭代器不检查范围。
用string::iterator或string::const_iterator声明迭代器变量，const_iterator不允许改变迭代的内容。常用迭代器函数有：const_iterator begin()iterator begin();&&&&&&&&&&&&&&& //返回string的起始位置const_iterator end()iterator end();&&&&&&&&&&&&&&&&&&& //返回string的最后一个字符后面的位置const_iterator rbegin()iterator rbegin();&&&&&&&&&&&&&&& //返回string的最后一个字符的位置const_iterator rend()iterator rend();&&&&&&&&&&&&&&&&&&& //返回string第一个字符位置的前面rbegin和rend用于从后向前的迭代访问，通过设置迭代器string::reverse_iterator,string::const_reverse_iterator实现
字符串流处理： 通过定义ostringstream和istringstream变量实现，&sstream&头文件中例如：string input("hello,this is a test");istringstream is(input);string s1,s2,s3,s4;is&&s1&&s2&&s3&&s4;//s1="hello,this",s2="is",s3="a",s4="test"os&&s1&&s2&&s3&&s4;cout&&os.str();
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具C++string中有关字符串内容修改和替换的函数浅析_Linux编程_Linux公社-Linux系统门户网站
你好，游客
C++string中有关字符串内容修改和替换的函数浅析
来源：Linux社区&
作者：zpcdbky
C++string中有关字符串内容修改和替换的函数浅析
1.assign()
//string (1)basic_string& assign (const basic_string& str);//substring (2)basic_string& assign (const basic_string& str, size_type subpos, size_type sublen);//c-string (3)basic_string& assign (const charT* s);//buffer (4)basic_string& assign (const charT* s, size_type n);//ill (5)basic_string& assign (size_type n, charT c);//range (6)template &class InputIterator&&
basic_string& assign (InputIterator first, InputIterator last);
ps:charT是类模板basic_string的第1个参数，指定了字符串中字符的类型。用char实例化basic_string，得到string（可参考在下的&C++ string到底是什么&）。所以， 在string中，charT就是char。
#include&iostream&#include&string&
int main(){& & string str1("123456");& & string str = "";& & char* str2 = "abcdef";& & str.assign(str1);& & cout && str &&//123456&
可见执行assign()后，str将被重写& & str.assign(str1, 2, 3);& & cout && str &&//345&
从位置2开始的3个字符& & str.assign(str1, 1, 20);//超出范围& & cout && str &&//23456& & cout && str.length() &&//5 可见没有空格& & str.assign(str1, 2, str1.npos);//后面介绍npos& & cout && str &&//3456&
从位置2到末尾的字符给str& & str.assign(5, 'X');& & cout && str &&//XXXXX& & str.assign(str1.begin(), str1.end() - 1);& & cout && str &&//12345 从开头到结尾-1（即倒数第个字符）& & //str.assign(str1.begin() + 4, str1.end() - 4);//不能反着来，即试图将以str1.begin() + 4（5）开头，以str1.end() - 4（2）结尾的5432给str是不行的& & //cout && str &&& & & & & & & & & & & &
//这样会出现运行时错误& & str.assign(str1.begin() + 2, str1.end() - 3);//前后指向同一字符（3），这样可以& & cout && str &&//3& & str.assign(str1.begin() + 2, str1.end() - 4);//这个却可以& & cout && str &&//空行& & cout && str.length() &&//0& & str.assign("abcdefg", 6);& & cout && str &&//abcdef 将abcdefg的前6个字符给str& & str.assign("abcdefg", 20);//超出范围& & cout && str &&//abcdefg+乱码& & cout && str.length() &&//10&
说明将"abcdefg+3个空格"给了str& & str.assign(3, 0x41);& & cout && str &&//AAA&
可以使用16进制的ASCII码 0x41换成10进制是65，是A的ASCII码& & str.assign(str2);& & cout && str &&//abcdef & & str.assign(str2, 2, 3);& & cout && str &&//cde&
对char*型也可以& & return 0;}
以上代码中有一句str.assign(str1, 2, str1.npos);这里我们解释npos：它的定义如下：std::string::nposstatic const size_t npos = -1;它是size_t类型的最大值，有些编译器也将它置为string对象的最大容量（按字节算，包括'\0'），而有些编译器不是，我们在后边将会看到。为什么是最大呢？-1用反码存储（32位），就是32个1，而size_t是无符号整型，所以，32个1的2进制转化为10进制就是2的32次方-1，即。看下面一段验证代码：
#include&iostream&#include&string&
int main(){& & string str1 = "";& & cout && str1.npos &&//& & cout && (str1.npos == -1) &&//1& & cout && str1.max_size() &&//&
(=2^30-4)& & return 0;}
其中，是VS2013上的结果，可见max_size()不包括'\0'，是CodeBlocks12.11上的结果。由此，我们可知，str.assign(str1, 2, str1.npos);等价于str.assign(str1, 2, );
另外，在C++11中，还有两个重载的assign()函数，它们的原型分别是：
//initializer list(7)basic_string& assign (initializer_list&charT& il);//move (8)basic_string& assign (basic_string&& str)
其中，（7）与list容器有关，而（8）与右值引用和移动语义有关，这里我们暂不详述。对于（8）中的noexcept关键字，它声明了函数不会抛出异常（当然函数不是真的就永远都不会抛出异常，比如该函数A（声明为noexcept）中调用了另一个函数B，而函数B中有抛出异常语句，那么，当我们调用函数A是，就可能抛出异常），由于noexcept不是本文的重点，这里我们不详述，有兴趣的读者可以自行查阅资料了解学习相关内容。
原型：void swap (basic_string& str);只有这一个，要交换就交换整个字符串，这里没有针对子串的操作。不举例。
//sequence (1)basic_string& erase (size_type pos = 0, size_type len = npos);//character (2)& &
iterator erase (iterator p);//range (3)& &
iterator erase (iterator first, iterator last);
说明：注意到basic_string& erase (size_type pos = 0, size_type len = npos);给出了默认参数，这样，我们在使用该函数时，就可以省略第2个参数，效果是删除从第1个参数所指位置（包括该位置）起的所有字符（正如下边示例中有关str3的操作和输出）。原因是len=npos，而npos一定大于string对象的最大长度。
#include&iostream&#include&string&
int main(){& & string str1("");& & string str2("");& & string str3("");& & string str4("");& & string str5("");& & string str6("");& & string str7("");& & string str8("");& & str1.erase(2, 3);& & cout && str1 &&//126789& & str2.erase(2, 10); cout &&//空行& & str3.erase(7);//注意这里的参数值不能超过str3.length(),否则会出现运行时错误等于是输出空行，相当于删除'\0'及其后面的（当然后面什么也没有，& & & & & & & & & //因为'\0'已经是最后一个）& & cout && str3 &&//1234567&
当省略第2个参数时，删除第1个参数所指位置起（即包括该位置）的所有字符& & //str4.erase(10, 5);//这么做不行& & //cout && str4 &&& & str4.erase(str4.begin());& & cout && str4 &&//& & str5.erase(str5.begin() + 2);& & cout && str5&&//& & //str6.erase(str6.begin() + 10);//这么做不行& & //cout && str6 &&& & str6.erase(str6.end() - 2);& & cout && str6 &&//& & //str7.erase(str7.end() - 10);//这么做不行& & //cout && str7 &&& & str7.erase(str7.begin()+2,str7.end()-2);& & str7.erase(str7.begin() + 2, str7.end() - 2);& & cout && str7 &&//1289&
删除从str7.begin()+2（包括str7.begin()+2)到str7.end() - 2（包括str7.end() - 2）的所有字符& & //str8.erase(str8.begin() + 7, str8.end() - 5);//这么做不行& & //cout && str8 &&& & return 0;}
&4.clear()
void clear()
作用：删除字符串的所有内容。
#include&iostream&#include&string&
int main(){& & string str("");& & str.clear();& & cout && str &&//空行& & cout && str.length() &&//0& & return 0;}
&5.insert()
//string (1)basic_string& insert (size_type pos, const basic_string& str);//substring (2)basic_string& insert (size_type pos, const basic_string& str,& & & & & & & & & & & size_type subpos, size_type sublen);//c-string (3)basic_string& insert (size_type pos, const charT* s);//buffer (4)basic_string& insert (size_type pos, const charT* s, size_type n);//fill (5)basic_string& insert (size_type pos,&
size_type n, charT c);& &
iterator insert (const_iterator p, size_type n, charT c);//single character (6)& &
iterator insert (const_iterator p, charT c);//range (7)template &class InputIterator&& &
iterator insert (iterator p, InputIterator first, InputIterator last);//initializer list (8)basic_string& insert (const_iterator p, initializer_list&charT& il);
说明：1）原型（8）与list容器有关，是C++11新标准，这里赞不详述。2）以上原型中出现的返回值和参数有iterator和InputIterator与迭代器有关，这里也暂不详述，可以将其简单地理解为指针，begin()和end()的返回值与它们匹配。
#include&iostream&#include&string&
int main(){&
/*& & *测试basic_string& insert (size_type pos, const basic_string& str);&
*/& & string st1("");& & //string st2("");& & string str1("abc");& & st1.insert(3, str1);& & cout && st1 &&//123abc456789&
注意是在pos所指位置前插入& & //st2.insert(10, str1);//超出范围& & //cout && st2 &&//不可以& & /*& & **测试basic_string& insert (size_type pos, const basic_string& str,size_type subpos, size_type sublen);& & */& & string st2("");& & string st3("");& & string str2("abcdefg");& & st2.insert(3, str2, 2, 3);& & cout && st2 &&//123cde456789& & st3.insert(3, str2, 4, 9);//超出范围& & cout && st3 &&//123efg456789&
可见如果超出字符串的长度，则一直到字符串的最后，不补空格& & /*& & **测试basic_string& insert (size_type pos, const charT* s);& & */& & string st4("");& & string st5("");& & char* str3 = "abc";& & st4.insert(3, str3);& & cout && st4 &&//123abc456789& & st5.insert(3, "abc");& & cout && st5 &&//123abc456789& & /*& & **测试basic_string& insert (size_type pos, const charT* s, size_type n);& & */& & string st6("");& & string st7("");& & st6.insert(3, "abcdefg", 3);//n可以为0，为0时什么也不加 当n为负值时会出现运行时错误& & cout && st6 &&//123abc456789& & st7.insert(3, "abcdefg", 20);//超出范围& & cout && st7 &&//123abcdefg i n v a l i 456789& 调大n值（如500）进行测试，发现中间多出来的是报错的语句和乱码，且每次运行的输出可能不一样& & & & & & & & & & & & //CodeBlocks12.11上中间直接就是乱码& & /*& & **测试basic_string& insert (size_type pos,&
size_type n, charT c);& 和& iterator insert (const_iterator p, size_type n, charT c);& & */& & string st8("");& & string st9("");& & st8.insert(3, 2, 'a');& & cout && st8 &&//123aa456789& & st9.insert(st9.begin() + 3, 2, 'a');& & cout && st9 &&//123aa456789& & /*& & **测试iterator insert (const_iterator p, charT c);& & */& & string ss1("");& & ss1.insert(ss1.begin()+3, 'a');//由原型知，这里不能将ss1.begin()+3改为3& & cout && ss1 &&//123a456789& & /*& & **测试template &class InputIterator&& & **& & iterator insert (iterator p, InputIterator first, InputIterator last);& & */& & string ss2("");& & string str4("abcdefg");& & ss2.insert(ss2.begin() + 3, str4.begin(), str4.begin()+3);//超出范围会出现运行时错误& & cout && ss2 &&//123abc456789& & return 0;}
&6.append()
//string (1)basic_string& append (const basic_string& str);//substring (2)basic_string& append (const basic_string& str, size_type subpos, size_type sublen);//c-string (3)basic_string& append (const charT* s);//buffer (4)basic_string& append (const charT* s, size_type n);//fill (5)basic_string& append (size_type n, charT c);//range (6)template &class InputIterator&basic_string& append (InputIterator first, InputIterator last);//initializer list(7)basic_string& append (initializer_list&charT& il);
(7)不详述。示例：
#include&iostream&#include&string&
int main(){& & /*& & **测试basic_string& append (const basic_string& str);& & & & */& & string st1("");& & string str1("abc");& & string& ss = st1.append(str1);& & cout && ss &&//abc& & cout && st1 &&//abc& & /*& & **测试basic_string& append (const basic_string& str, size_type subpos, size_type sublen);& & & & */& & string st2("");& & string st3("");& & string str2("abcdefg");& & st2.append(str2, 2, 3);& & cout && st2 &&//cde& & st3.append(str2, 3, 20);//超出范围& & cout && st3 &&//defg& & 当用数字表示范围时，若超出范围，则直到字符串的结尾，不会补空格，也不会出现运行时错误& & cout && st3.length() &&//13& & & 尽管如此，在实际编程时，也必须保证不超范围& & /*& & **测试basic_string& append (const charT* s);& & & & */& & string st4("");& & st4.append("abc");& & cout && st4 &&//abc& & /*& & **测试basic_string& append (const charT* s, size_type n);& & */& & string st5("");& & st5.append("abc", 5);//超出范围& & cout && st5 &&//abc+乱码& & /*& & **测试basic_string& append (size_type n, charT c);& & */& & string st6("");& & st6.append(3, 0x41);//可以用16进制的ASCII码& & cout && st6 &&//AAA& & /*& & **测试template &class InputIterator&& & **basic_string& append (InputIterator first, InputIterator last);& & */& & /*& & string st7("");& & string str3("abcdefg");& & st6.append(str3.begin() + 2, str3.begin() + 10);//超出范围& & cout && st7 &&//当使用迭代器时，若超出范围，则会出现运行时错误& & */& & & return 0;}
&7.replace()
//string (1)basic_string& replace (size_type pos,& &
size_type len,& &
const basic_string& str);basic_string& replace (const_iterator i1, const_iterator i2, const basic_string& str);//substring (2)basic_string& replace (size_type pos, size_type len, const basic_string& str,& & & & & & & & & & &
size_type subpos, size_type sublen);//c-string (3)basic_string& replace (size_type pos,& &
size_type len,& &
const charT* s);basic_string& replace (const_iterator i1, const_iterator i2, const charT* s);//buffer (4)basic_string& replace (size_type pos,& &
size_type len,& &
const charT* s, size_type n);basic_string& replace (const_iterator i1, const_iterator i2, const charT* s, size_type n);//fill (5)basic_string& replace (size_type pos,& &
size_type len,& &
size_type n, charT c);basic_string& replace (const_iterator i1, const_iterator i2, size_type n, charT c);//range (6)template &class InputIterator&& basic_string& replace (const_iterator i1, const_iterator i2,& & & & & & & & & & &
InputIterator first, InputIterator last);//initializer list (7)basic_string& replace (const_iterator i1, const_iterator i2, initializer_list&charT& il);
(7)不详述示例：（这里仅给出部分原型的测试，其它的读者可参照前面几个函数的实例自行测试）
#include&iostream&#include&string&
int main(){& & /*& & **测试basic_string& replace (size_type pos,& &
size_type len,& &
const basic_string& str);& & */& & string st1("");& & string str1("abcde");& & string str2("ab");& & st1.replace(2, 3, str1);//将位置2开始的3个字符（345）换成abcde& & cout && st1 &&//12abcde6789& & string st2("");& & st2.replace(1, 7, str1);& & cout && st2 &&//1abcde9& & string st3("");& & st3.replace(6, 9, str2);//超出范围& & cout && st3 &&//123456ab& & /*& & **测试basic_string& replace (const_iterator i1, const_iterator i2, const basic_string& str);& & */& & /*string st4("");& & st4.replace(st4.begin() + 8, st4.begin() + 10, str1);&
//迭代器超范围，出现运行时错误& & cout && st4 &&*/& & /*& & **测试basic_string& replace (size_type pos,& &
size_type len,& &
const charT* s, size_type n);& & */& & string st5("");& & st5.replace(2, 3, "abcdefg", 5);& & cout && st5 &&//12abcde6789& & string st6("");& & st6.replace(2, 3, "abc", 20);//超出范围& & cout && st6 &&//12abc+乱码+6789&
对于char*类型，若超出范围，就会出现乱码& & return 0;}
以上各函数的原型及参数的意义大同小异，读者可以触类旁通。现结合以上各示例，对&超出范围&这一特殊情况给出一般性的规律总结：1.对于string类型，用数字表示范围，超出时，自动截止到字符串的末尾，不会补空格，不会有乱码，也不会出现运行时错误。2.对于string类型，用迭代器表示范围，超出时，出现运行时错误。3.对于char*类型，用数字表示范围（只能用数字表示，char*是基本类型，没有迭代器），超出时，会出现乱码。
------------------------------分割线------------------------------
C++ Primer Plus 第6版 中文版 清晰有书签PDF+源代码
读C++ Primer 之构造函数陷阱
读C++ Primer 之智能指针
读C++ Primer 之句柄类
将C语言梳理一下，分布在以下10个章节中：
Linux-C成长之路（一）：Linux下C编程概要
Linux-C成长之路（二）：基本数据类型
Linux-C成长之路（三）：基本IO函数操作
Linux-C成长之路（四）：运算符
Linux-C成长之路（五）：控制流
Linux-C成长之路（六）：函数要义
Linux-C成长之路（七）：数组与指针
Linux-C成长之路（八）：存储类，动态内存
Linux-C成长之路（九）：复合数据类型
Linux-C成长之路（十）：其他高级议题
本文永久更新链接地址：
相关资讯 & & &
& (05/02/:44)
& (05/01/:10)
　　　同意评论声明
　　　发表
尊重网上道德，遵守中华人民共和国的各项有关法律法规
承担一切因您的行为而直接或间接导致的民事或刑事法律责任
本站管理人员有权保留或删除其管辖留言中的任意内容
本站有权在网站内转载或引用您的评论
参与本评论即表明您已经阅读并接受上述条款