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

basic_string& assign (InputIterator first, InputIterator last);

ps:charT是类模板basic_string的第1个参数，指定了字符串中字符的类型。⽤char实例化basic_string，得到string（可参考在下的“C++string到底是什么”）。所以， 在string中，charT就是char。⽰例：

#include#includeusing namespace std;

int main(){

string str1(\"123456\"); string str = \"1234567\"; char* str2 = \"abcdef\"; str.assign(str1);

cout << str << endl;//123456 可见执⾏assign()后，str将被重写 str.assign(str1, 2, 3);

cout << str << endl;//345 从位置2开始的3个字符 str.assign(str1, 1, 20);//超出范围 cout << str << endl;//23456

cout << str.length() << endl;//5 可见没有空格 str.assign(str1, 2, str1.npos);//后⾯介绍npos

cout << str << endl;//3456 从位置2到末尾的字符给str str.assign(5, 'X');

cout << str << endl;//XXXXX

str.assign(str1.begin(), str1.end() - 1);

cout << str << endl;//12345 从开头到结尾-1（即倒数第个字符）

//str.assign(str1.begin() + 4, str1.end() - 4);//不能反着来，即试图将以str1.begin() + 4（5）开头，以str1.end() - 4（2）结尾的32给str是不⾏的 //cout << str << endl; //这样会出现运⾏时错误

str.assign(str1.begin() + 2, str1.end() - 3);//前后指向同⼀字符（3），这样可以 cout << str << endl;//3

str.assign(str1.begin() + 2, str1.end() - 4);//这个却可以 cout << str << endl;//空⾏

cout << str.length() << endl;//0 str.assign(\"abcdefg\", 6);

cout << str << endl;//abcdef 将abcdefg的前6个字符给str str.assign(\"abcdefg\", 20);//超出范围 cout << str << endl;//abcdefg+乱码

cout << str.length() << endl;//10 说明将\"abcdefg+3个空格\"给了str str.assign(3, 0x41);

cout << str << endl;//AAA 可以使⽤16进制的ASCII码 0x41换成10进制是65，是A的ASCII码 str.assign(str2);

cout << str << endl;//abcdef str.assign(str2, 2, 3);

cout << str << endl;//cde 对char*型也可以 return 0;}

以上代码中有⼀句

str.assign(str1, 2, str1.npos);这⾥我们解释npos：它的定义如下：std::string::npos

static const size_t npos = -1;

它是size_t类型的最⼤值，有些编译器也将它置为string对象的最⼤容量（按字节算，包括'\\0'），⽽有些编译器不是，我们在后边将会看到。为什么是最⼤呢？

-1⽤反码存储（32位），就是32个1，⽽size_t是⽆符号整型，所以，32个1的2进制转化为10进制就是2的32次⽅-1，即4294967295。看下⾯⼀段验证代码：

#include#includeusing namespace std;

int main(){

string str1 = \"1234567\";

cout << str1.npos << endl;//4294967295 cout << (str1.npos == -1) << endl;//1

cout << str1.max_size() << endl;//4294967294 1073741820(=2^30-4) return 0;}

其中，4294967294是VS2013上的结果，可见max_size()不包括'\\0'，1073741820是CodeBlocks12.11上的结果。由此，我们可知，str.assign(str1, 2, str1.npos);等价于str.assign(str1, 2, 4294967294);另外，在C++11中，还有两个重载的assign()函数，它们的原型分别是：

//initializer list(7)

basic_string& assign (initializer_list il);//move (8)

basic_string& assign (basic_string&& str) noexcept;

其中，（7）与list容器有关，⽽（8）与右值引⽤和移动语义有关，这⾥我们暂不详述。

对于（8）中的noexcept关键字，它声明了函数不会抛出异常（当然函数不是真的就永远都不会抛出异常，⽐如该函数A（声明为

noexcept）中调⽤了另⼀个函数B，⽽函数B中有抛出异常语句，那么，当我们调⽤函数A是，就可能抛出异常），由于noexcept不是本⽂的重点，这⾥我们不详述，有兴趣的读者可以⾃⾏查阅资料了解学习相关内容。2.swap()

原型：void swap (basic_string& str);

只有这⼀个，要交换就交换整个字符串，这⾥没有针对⼦串的操作。不举例。3.erase()原型：

//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#includeusing namespace std;

int main(){

string str1(\"1234567\"); string str2(\"1234567\"); string str3(\"1234567\"); string str4(\"1234567\"); string str5(\"1234567\"); string str6(\"1234567\"); string str7(\"1234567\"); string str8(\"1234567\"); str1.erase(2, 3);

cout << str1 << endl;//1267

str2.erase(2, 10); cout << endl;//空⾏

str3.erase(7);//注意这⾥的参数值不能超过str3.length(),否则会出现运⾏时错误等于是输出空⾏，相当于删除'\\0'及其后⾯的（当然后⾯什么也没有， //因为'\\0'已经是最后⼀个）

cout << str3 << endl;//1234567 当省略第2个参数时，删除第1个参数所指位置起（即包括该位置）的所有字符

//str4.erase(10, 5);//这么做不⾏ //cout << str4 << endl; str4.erase(str4.begin());

cout << str4 << endl;//234567 str5.erase(str5.begin() + 2); cout << str5<< endl;//124567

//str6.erase(str6.begin() + 10);//这么做不⾏ //cout << str6 << endl; str6.erase(str6.end() - 2);

cout << str6 << endl;//12345679

//str7.erase(str7.end() - 10);//这么做不⾏ //cout << str7 << endl;

str7.erase(str7.begin()+2,str7.end()-2); str7.erase(str7.begin() + 2, str7.end() - 2);

cout << str7 << endl;//12 删除从str7.begin()+2（包括str7.begin()+2)到str7.end() - 2（包括str7.end() - 2）的所有字符 //str8.erase(str8.begin() + 7, str8.end() - 5);//这么做不⾏ //cout << str8 << endl; return 0;}

4.clear()原型：

void clear() noexcept;

作⽤：

删除字符串的所有内容。⽰例：

#include#includeusing namespace std;

int main(){

string str(\"1234567\"); str.clear();

cout << str << endl;//空⾏

cout << str.length() << endl;//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

iterator insert (iterator p, InputIterator first, InputIterator last);//initializer list (8)

basic_string& insert (const_iterator p, initializer_list il);

说明：

1）原型（8）与list容器有关，是C++11新标准，这⾥赞不详述。

2）以上原型中出现的返回值和参数有iterator和InputIterator与迭代器有关，这⾥也暂不详述，可以将其简单地理解为指针，begin()和end()的返回值与它们匹配。⽰例：

#include#includeusing namespace std;int main()

{ /*

*测试basic_string& insert (size_type pos, const basic_string& str); */

string st1(\"1234567\"); //string st2(\"1234567\"); string str1(\"abc\"); st1.insert(3, str1);

cout << st1 << endl;//123abc4567 注意是在pos所指位置前插⼊ //st2.insert(10, str1);//超出范围 //cout << st2 << endl;//不可以 /*

**测试basic_string& insert (size_type pos, const basic_string& str,size_type subpos, size_type sublen); */

string st2(\"1234567\"); string st3(\"1234567\"); string str2(\"abcdefg\"); st2.insert(3, str2, 2, 3);

cout << st2 << endl;//123cde4567 st3.insert(3, str2, 4, 9);//超出范围

cout << st3 << endl;//123efg4567 可见如果超出字符串的长度，则⼀直到字符串的最后，不补空格 /*

**测试basic_string& insert (size_type pos, const charT* s); */

string st4(\"1234567\"); string st5(\"1234567\"); char* str3 = \"abc\"; st4.insert(3, str3);

cout << st4 << endl;//123abc4567 st5.insert(3, \"abc\");

cout << st5 << endl;//123abc4567 /*

**测试basic_string& insert (size_type pos, const charT* s, size_type n); */

string st6(\"1234567\"); string st7(\"1234567\");

st6.insert(3, \"abcdefg\", 3);//n可以为0，为0时什么也不加 当n为负值时会出现运⾏时错误 cout << st6 << endl;//123abc4567 st7.insert(3, \"abcdefg\", 20);//超出范围

cout << st7 << endl;//123abcdefg i n v a l i 4567 调⼤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(\"1234567\"); string st9(\"1234567\"); st8.insert(3, 2, 'a');

cout << st8 << endl;//123aa4567 st9.insert(st9.begin() + 3, 2, 'a'); cout << st9 << endl;//123aa4567 /*

**测试iterator insert (const_iterator p, charT c); */

string ss1(\"1234567\");

ss1.insert(ss1.begin()+3, 'a');//由原型知，这⾥不能将ss1.begin()+3改为3 cout << ss1 << endl;//123a4567 /*

**测试template

** iterator insert (iterator p, InputIterator first, InputIterator last); */

string ss2(\"1234567\"); string str4(\"abcdefg\");

ss2.insert(ss2.begin() + 3, str4.begin(), str4.begin()+3);//超出范围会出现运⾏时错误 cout << ss2 << endl;//123abc4567 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

basic_string& append (InputIterator first, InputIterator last);//initializer list(7)

basic_string& append (initializer_list il);

(7)不详述。⽰例：

#include#includeusing namespace std;

int main(){ /*

**测试basic_string& append (const basic_string& str); */

string st1(\"1234567\"); string str1(\"abc\");

string& ss = st1.append(str1);

cout << ss << endl;//1234567abc cout << st1 << endl;//1234567abc /*

**测试basic_string& append (const basic_string& str, size_type subpos, size_type sublen); */

string st2(\"1234567\"); string st3(\"1234567\"); string str2(\"abcdefg\"); st2.append(str2, 2, 3);

cout << st2 << endl;//1234567cde st3.append(str2, 3, 20);//超出范围

cout << st3 << endl;//1234567defg 当⽤数字表⽰范围时，若超出范围，则直到字符串的结尾，不会补空格，也不会出现运⾏时错误 cout << st3.length() << endl;//13 尽管如此，在实际编程时，也必须保证不超范围 /*

**测试basic_string& append (const charT* s); */

string st4(\"1234567\"); st4.append(\"abc\");

cout << st4 << endl;//1234567abc /*

**测试basic_string& append (const charT* s, size_type n); */

string st5(\"1234567\");

st5.append(\"abc\", 5);//超出范围

cout << st5 << endl;//1234567abc+乱码 /*

**测试basic_string& append (size_type n, charT c); */

string st6(\"1234567\");

st6.append(3, 0x41);//可以⽤16进制的ASCII码 cout << st6 << endl;//1234567AAA /*

**测试template

**basic_string& append (InputIterator first, InputIterator last); */ /*

string st7(\"1234567\"); string str3(\"abcdefg\");

st6.append(str3.begin() + 2, str3.begin() + 10);//超出范围

cout << st7 << endl;//当使⽤迭代器时，若超出范围，则会出现运⾏时错误 */

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

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 il);

(7)不详述

⽰例：（这⾥仅给出部分原型的测试，其它的读者可参照前⾯⼏个函数的实例⾃⾏测试）

#include#includeusing namespace std;

int main(){ /*

**测试basic_string& replace (size_type pos, size_type len, const basic_string& str); */

string st1(\"1234567\"); string str1(\"abcde\"); string str2(\"ab\");

st1.replace(2, 3, str1);//将位置2开始的3个字符（345）换成abcde cout << st1 << endl;//12abcde67 string st2(\"1234567\"); st2.replace(1, 7, str1);

cout << st2 << endl;//1abcde9 string st3(\"1234567\");

st3.replace(6, 9, str2);//超出范围 cout << st3 << endl;//123456ab /*

**测试basic_string& replace (const_iterator i1, const_iterator i2, const basic_string& str); */

/*string st4(\"1234567\");

st4.replace(st4.begin() + 8, st4.begin() + 10, str1); //迭代器超范围，出现运⾏时错误 cout << st4 << endl;*/ /*

**测试basic_string& replace (size_type pos, size_type len, const charT* s, size_type n); */

string st5(\"1234567\");

st5.replace(2, 3, \"abcdefg\", 5);

cout << st5 << endl;//12abcde67 string st6(\"1234567\");

st6.replace(2, 3, \"abc\", 20);//超出范围

cout << st6 << endl;//12abc+乱码+67 对于char*类型，若超出范围，就会出现乱码 return 0;}

以上各函数的原型及参数的意义⼤同⼩异，读者可以触类旁通。现结合以上各⽰例，对“超出范围”这⼀特殊情况给出⼀般性的规律总结：1.对于string类型，⽤数字表⽰范围，超出时，⾃动截⽌到字符串的末尾，不会补空格，不会有乱码，也不会出现运⾏时错误。2.对于string类型，⽤迭代器表⽰范围，超出时，出现运⾏时错误。

3.对于char*类型，⽤数字表⽰范围（只能⽤数字表⽰，char*是基本类型，没有迭代器），超出时，会出现乱码。