C++ string类

C++之string类
C++中的string是标准库中的一种容器,用来存储字符串。string类提供了非常丰富的函数，这些函数不仅可以完成对字符串的复杂操作,而且可以实现string类与C字符语言类字符串之间的转换。

一、C语言的字符串

在C语言里，对字符串的处理一项都是一件比较痛苦的事情，因为通常在实现字符串的操作的时候都会用到最不容易驾驭的类型——指针。

比如下面这个例子：

//example 1:
char str[12] = "Hello";
char *p = str;
*p = 'h';  //改变第一个字母

//example 2:
char *ptr = "Hello";
*ptr = 'h';  //错误

第一个字符串是用数组开辟的，它是可以改变的变量。而第二个字符串则是一个常量，也就是字面值。ptr只是指向它的指针而已，而不能改变指向的内容。

看两者的汇编即可明了：

char p[] = "Hello";

004114B8 mov eax,dword ptr [string "Hello" (4166FCh)]

004114BD mov dword ptr [ebp-10h],eax

004114C0 mov cx,word ptr ds:[416700h]

004114C7 mov word ptr [ebp-0Ch],cx

char *ptr = "Hello";

004114CB mov dword ptr [ebp-1Ch],offset string "Hello" (4166FCh)

可见用数组和用指针是完全不相同的。

要想通过指针来改变常量是错误，正确的写法应该是用const指针。

const char *ptr = "Hello";

二、初识string类

正是因为C语言的字符串(以空字符结尾的字符数组)太过复杂难于操作，所以C++标准库定义了一种string类，定义在头文件include<string>中。注意不是include<string.h>也不是include<cstring>，两者是等价的，include<string.h>是C的头文件格式，而include<cstring>是C++的头文件格式。

看下面例子:

//example 3:
string str("world");   //可以用C风格字符串初始化
string words = "Hello";
string greet = words;
string  join = greet + words;  //可以像基本类型一样操作

但是如果试图把string类型的对象直接赋给C语言的字符串的话，编译器会报错的。

string var = "Olympic";
char *ptr = var;  //error！

但是实际应用中这个问题也难以避免，很多时候我们还是需要将string类型的转化为char*来实现自定义的操作，C++标准库也为了和之前用C写的程序兼容，于是可以用string的c_str()函数。

string var = "Olympic";
char *ptr = var.c_str(); //还不能被编译

但是c_str()为了防止意外地修改string对象，返回的是const指针，所以上面这段代码是不能被编译的。正确的应该是用const指针。

string var = "Olympic";
const char *p = var.c_str(); //Correct!

这个c_str()方法在C++IO流操作上也被广泛应用。

在打开文件时，如果要指定文件名，可以用C风格的字符串。如果用到string类型的字符串作为文件名时，就必须调用c_str()方法将其转换为一个C风格字符串。

//example 4:
string   filename;  //定义文件名称
cin >> filename;
ifstream.open(filename.c_str());  //要使用C风格字符串

三、 深入了解string类

标准库为string定义了很多方法，包括构造、插入(insert)、替换(assign和replace)、比较(compare)、查找(find)、删除(erase)、连接(append)以及对子串的操作(substr)。而每一种操作都有很多种重载。

比如插入，除了包括标准容器的插入方式以外，string类本身还有一些特有的插入方法。

//example 5:
//与标准容器相同的插入操作：
str.insert(iter, value) //在迭代器iter之前插入value, 返回新元素的迭代器
str.insert(iter, n, value); //在迭代器iter之前插入n个value，返回void
str.insert(iter, begin, end); //在迭代器iter之前插入迭代器begin和end标记范围内的元素，返回void
//string类特有的插入方法:
str.insert(pos, n, ch); //在下标为pos的字符之前插入n个字符ch
str.insert(pos, str2); //在下标为pos的字符之前插入string类型的对象str2的副本
str.insert(pos1, str2, pos2, len); //在下标为pos1的z字符之前插入string类型str2中从下表为pos2开始的len个字符
str.insert(pos, cp); //在下标为pos的字符前插入字符指针cp指向的C风格字符串的副本

string是一种非常灵活的字符串类型，标准库让我们可以忽略内存管理和具体实现方式，我们只需要关注其接口就好。并且初学者在使用字符串的时候也应尽量使用这种类型，而不是C风格的字符串。

之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据类型。

好了，进入正题………

首先，为了在我们的程序中使用string类型，我们必须包含头文件 。如下：

#include //注意这里不是string.h string.h是C字符串头文件

1．声明一个C++字符串

声明一个字符串变量很简单：

string Str;

这样我们就声明了一个字符串变量，但既然是一个类，就有构造函数和析构函数。上面的声明没有传入参数，所以就直接使用了string的默认的构造函数，这个函数所作的就是把Str初始化为一个空字符串。String类的构造函数和析构函数如下：

string s;  ///生成一个空字符串s
string s(str); ///拷贝构造函数 生成str的复制品，只有定义时可以使用
string s(str,stridx); ///将字符串str内“下标始于位置stridx（stridx是数）”的部分当作字符串的初值
string s(str,stridx,strlen); ///将字符串str内“始于stridx（stridx是数）且长度顶多strlen”的部分作为字符串的初值
string s(cstr); ///将C语言的数组字符串cstr[]作为s的初值
string s(chars,chars_len); ///将C语言的数组字符串chars[]的前chars_len个字符作为字符串s的初值。
string s(num,c); ///生成一个字符串，包含num（数值）个c（一个字符量）字符
string s(beg,end); ///以区间[beg,end)（不包含end）内的字符作为字符串s的初值
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) << //将谋值写入stream

r) copy() //将某值赋值为一个C_string

s) 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异常。

有一个例外不得不说，const string a;的操作符[]对索引值是a.length()仍然有效，其返回值是’\0’。其他的各种情况，a.length()索引都是无效的。

举例如下：

const string Cstr(“const string”);
string Str(“string”);

Str[3];    //ok
Str.at(3);  //ok

Str[100]; //未定义的行为
Str.at(100);  //throw out_of_range

Str[Str.length()]  //未定义行为
Cstr[Cstr.length()] //返回 ‘\0’
Str.at(Str.length());//throw out_of_range
Cstr.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”) 另一个功能强大的比较函数是成员函数compare()。他支持多参数处理，支持用索引值和长度定位子串来进行比较。他返回一个整数来表示比较结果，返回值意义如下：0-相等
〉0-大于 <0-小于。

举例如下：

string s(“abcd”);
s.compare(“abcd”); //返回0
s.compare(“dcba”); //返回一个小于0的值
s.compare(“ab”); //返回大于0的值
s.compare(s); //相等
s.compare(0,2,s,2,2); //用”ab”和”cd”进行比较 小于零
s.compare(1,2,”bcx”,2); //用”bc”和”bc”比较。

2.5 更改内容

关于赋值，第一个赋值方法当然是使用操作符=，新值可以是string(如：s=ns) 、c_string(如：s=”gaint”)甚至单一字符（如：s=’j’）。还可以使用成员函数assign()，这个成员函数可以使你更灵活的对字符串赋值。

举例说明：

<span style="font-size:14px;">s.assign(str); //
s.assign(str,1,3);//如果str是”iamangel” 就是把”ama”赋给字符串
s.assign(str,2,string::npos);//把字符串str从索引值2开始到结尾赋给s
s.assign(“gaint”); //
s.assign(“nico”,5);//把’n’ ‘I’ ‘c’ ‘o’ ‘\0’赋给字符串
s.assign(5,’x’);//把五个x赋给字符串</span>

把字符串清空的方法有三个：s=””；s.clear()；s.erase()。

string提供了很多函数用于插入（insert）、删除（erase）、替换（replace）、增加字符。

先说增加字符（这里说的增加是在尾巴上），函数有 +=、append()、push_back()。

举例如下：

s+=str;//加个字符串
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’);

字符串操作是一个不小的主题,在标准C++中,string字符串类成为一个标准,之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下的需要.

下面我们首先从一些示例开始学习下string类的使用.

1)

#include <string>
#include <iostream>
using namespace std;

void main()
{
string s("hehe");
cout<<s<<endl;
cin.get();
}

2)

#include <string>
#include <iostream>
using namespace std;

void main()
{
char chs[] = "hehe";
string s(chs);
cout<<s<<endl;
cin.get();
}

3)

#include <string>
#include <iostream>
using namespace std;

void main()
{
char chs[] = "hehe";
string s(chs,1,3);    //指定从chs的索引1开始,最后复制3个字节
cout<<s<<endl;
cin.get();
}

4)

#include <string>
#include <iostream>
using namespace std;

void main()
{
string s1("hehe");
string s2(s1);
cout<<s2<<endl;
cin.get();
}

5)

#include <string>
#include <iostream>
using namespace std;

void main()
{
string s1("hehe",2,3);
string s2(s1);
cout<<s2<<endl;
cin.get();
}

6)

#include <string>
#include <iostream>
using namespace std;

void main()
{
char chs[] = "hehe";
string s(chs,3);    //将chs前3个字符作为初值构造
cout<<s<<endl;
cin.get();
}

7)

#include <string>
#include <iostream>
using namespace std;

void main()
{
string s(10,'k');    //分配10个字符,初值都是'k'
cout<<s<<endl;
cin.get();
}

9)

//赋新值
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s(10,'k');    //分配10个字符,初值都是'k'
cout<<s<<endl;
s = "hehehehe";
cout<<s<<endl;
s.assign("kdje");
cout<<s<<endl;
s.assign("fkdhfkdfd",5);    //重新分配指定字符串的前5的元素内容
cout<<s<<endl;
cin.get();
}

10)

//swap方法交换
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s1 = "hehe";
string s2 = "gagaga";
cout<<"s1 : "<<s1<<endl;
cout<<"s2 : "<<s2<<endl;
s1.swap(s2);
cout<<"s1 : "<<s1<<endl;
cout<<"s2 : "<<s2<<endl;
cin.get();
}

11)

//+=,append(),push_back()在尾部添加字符
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s = "hehe";
s += "gaga";
cout<<s<<endl;
s.append("嘿嘿");    //append()方法可以添加字符串
cout<<s<<endl;
s.push_back('k');    //push_back()方法只能添加一个字符...
cout<<s<<endl;
cin.get();
}

12)

//insert() 插入字符.其实,insert运用好,与其他的插入操作是一样的.
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s = "hehe";
s.insert(0,"头部");            //在头部插入
s.insert(s.size(),"尾部");    //在尾部插入
s.insert(s.size()/2,"中间");//在中间插入
cout<<s<<endl;
cin.get();
}

13)

#include <string>
#include <iostream>
using namespace std;

void main()
{
string s = "abcdefg";
s.erase(0,1);    //从索引0到索引1,即删除掉了'a'
cout<<s<<endl;
//其实,还可以使用replace方法来执行删除操作
s.replace(2,3,"");//即将指定范围内的字符替换成"",即变相删除了
cout<<s<<endl;
cin.get();
}

14)

//clear() 删除全部字符
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s = "abcdefg";
cout<<s.length()<<endl;
s.clear();
cout<<s.length()<<endl;
//使用earse方法变相全删除
s = "dkjfd";
cout<<s.length()<<endl;
s.erase(0,s.length());
cout<<s.length()<<endl;

cin.get();
}

15)

//replace() 替换字符
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s = "abcdefg";
s.replace(2,3,"!!!!!");//从索引2开始3个字节的字符全替换成"!!!!!"
cout<<s<<endl;
cin.get();
}

16)

//==,!=,<,<=,>,>=,compare()  比较字符串
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s1 = "abcdefg";
string s2 = "abcdefg";
if (s1==s2)cout<<"s1 == s2"<<endl;
else cout<<"s1 != s2"<<endl;

if (s1!=s2)cout<<"s1 != s2"<<endl;
else cout<<"s1 == s2"<<endl;

if (s1>s2)cout<<"s1 > s2"<<endl;
else cout<<"s1 <= s2"<<endl;

if (s1<=s2)cout<<"s1 <= s2"<<endl;
else cout<<"s1 > s2"<<endl;

cin.get();
}

17)

//size(),length()  返回字符数量
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s = "abcdefg";
cout<<s.size()<<endl;
cout<<s.length()<<endl;

cin.get();
}

18)

//max_size() 返回字符的可能最大个数
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s = "abcdefg";
cout<<s.max_size()<<endl;

cin.get();
}

19)

//empty()  判断字符串是否为空
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s ;
if (s.empty())
cout<<"s 为空."<<endl;
else
cout<<"s 不为空."<<endl;

s = s + "abcdefg";
if (s.empty())
cout<<"s 为空."<<endl;
else
cout<<"s 不为空."<<endl;

cin.get();
}

20)

// [ ], at() 存取单一字符
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s = "abcdefg1111";

cout<<"use []:"<<endl;
for(int i=0; i<s.length(); i++)
{
cout<<s[i]<<endl;
}
cout<<endl;

cout<<"use at():"<<endl;
for(int i=0; i<s.length(); i++)
{
cout<<s.at(i)<<endl;
}
cout<<endl;

cin.get();
}

21)

#include <string>
#include <iostream>
using namespace std;

void main()
{
string s = "abcdefg1111";

const char * chs1 = s.c_str();
const char * chs2 = s.data();

cout<<"use at():"<<endl;
int i;
for(i=0; i<s.length(); i++)
{
cout<<"c_str() : "<<chs1[i]<<endl;
cout<<"data() : "<<chs2[i]<<endl;
}
cout<<"c_str() : "<<chs1<<endl;
cout<<"data() : "<<chs2<<endl;
cout<<endl;

cin.get();
}

22)

// substr() 返回某个子字符串
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s = "abcdefg1111";

string str = s.substr(5,3);//从索引5开始3个字节
cout<<str<<endl;

cin.get();
}

23)

// find 查找函数
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s = "abcdefg1111";
string pattern = "fg";
string::size_type pos;
pos = s.find(pattern,0);        //从索引0开始,查找符合字符串"f"的头索引
cout<<pos<<endl;
string str = s.substr(pos,pattern.size());
cout<<str<<endl;
cin.get();
}

24)

// begin() end() 提供类似STL的迭代器支持
#include <string>
#include <iostream>
using namespace std;

void main()
{
string s = "abcdefg1111";
for(string::iterator iter = s.begin(); iter!=s.end(); iter++)
{
cout<<*iter<<endl;
}
cout<<endl;

cin.get();
}

一个C++字符串存在三种大小：a)现有的字符数，函数是size()和length()，他们等效。 Empty()用来检查字符串是否为空。b)max_size() 这个大小是指当前C++字符串最多能包含的字符数，很可能和机器本身的限制或者字符串所在位置连续内存的大小有关系。我们一般情况下不用关心他，应该大小足够我们用的。但是不够用的话，会抛出length_error异常c)capacity()重新分配内存之前 string所能包含的最大字符数。这里另一个需要指出的是reserve()函数，这个函数为string重新分配内存。重新分配的大小由其参数决定，默认参数为0，这时候会对string进行非强制性缩减

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;

const char &at(int n)const;

char &operator[](int n);

char &at(int n);

operator[]和at()均返回当前字符串中第n个字符的位置，但at函数提供范围检查，当越界时会抛出out_of_range异常，下标运算符[]不提供检查访问。

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为起始位置的字符数组中，返回实际拷贝的数目

string的特性描述:

int capacity()const; //返回当前容量（即string中不必增加内存即可存放的元素个数）

int max_size()const; //返回string对象中可存放的最大字符串的长度

int size()const; //返回当前字符串的大小

int length()const; //返回当前字符串的长度

bool empty()const; //当前字符串是否为空

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个字符c

string &append(const_iterator first,const_iterator last);//把迭代器first和last之间的部分连接到当前字符串的结尾

string的比较：

bool perator==(const string &s1,const string &s2)const;//比较两个字符串是否相等

运算符">","<",">=","<=","!="均被重载用于字符串的比较；

int compare(const string &s) const;//比较当前字符串和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)const;//比较当前字符串从pos开始的n个字符组成的字符串与s中pos2开始的n2个字符组成的字符串的大小

int compare(const char *s) const;

int compare(int pos, int n,const char *s) const;

int compare(int pos, int n,const char *s, int pos2) const;

compare函数在>时返回1，<时返回-1，==时返回0

string的子串：

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

void swap(string &s2); //交换当前字符串与s2的值

string类的查找函数：

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;

int rfind(const char *s, int pos, int n = npos) const;

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

int find_first_not_of(const char *s, int pos,int n) const;

int find_first_not_of(const string &s,int pos = 0) const;

//从当前串中查找第一个不在串s中的字符出现的位置，失败返回string::npos

int find_last_of(char c, int pos = npos) const;

int find_last_of(const char *s, int pos = npos) const;

int find_last_of(const char *s, int pos, int n = npos) const;

int find_last_of(const string &s,int pos = npos) const;

int find_last_not_of(char c, int pos = npos) const;

int find_last_not_of(const char *s, int pos = npos) const;

int find_last_not_of(const char *s, int pos, int n) const;

int find_last_not_of(const string &s,int pos = npos) const;

//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处插入串s

string &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处插入串s

string &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个字符c

string &replace(iterator first0, iterator last0,const char *s);//把[first0，last0）之间的部分替换为字符串s

string &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）之间的部分替换为串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_iteratorlast);//把[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个字符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

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()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第一个字符位置的前面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"

ostringstream os;

os<<s1<<s2<<s3<<s4;

cout<<os.str();