std::string

 

标准模板库（STL）提供了一个std::string类，其是std::basic_string的一个特化，它是一个容器类，可把字符串当作普通类型来使用，并支持比较、连接、遍历、STL算法、复制、赋值等等操作，这个类定义在<string>头文件中。

#include <string> //注意这里不是string.h string.h是C字符串头文件
1．声明一个C++字符串
std::string类的构造函数

声明一个字符串变量很简单：
string Str;
这样我们就声明了一个字符串变量，但既然是一个类，就有构造函数和析构函数。上面的声明没有传入参数，所以就直接使用了string的默认的构造函数，这个函数所作的就是把Str初始化为一个空字符串。String类的构造函数和析构函数如下：
a) string s(); //生成一个空字符串s
b) string s(str) //拷贝构造函数 生成str的复制品string(const string& str)
c) string s(str,stridx) //将字符串str内"始于位置stridx"的部分当作字符串的初值
d) string s(const string& str, size_type pos,strlen) //将字符串str内"始于pos且长度顶多strlen"的部分作为字符串的初值
e) string s(const char *s) //将C字符串作为s的初值
f) string s(const char* cstr, size_type n) //使用字符串str的前n个字符初始化作为字符串s的初值。
g) string s(int num,char c) //生成一个字符串，包含num个c字符
h) string s(beg,end) //以区间beg;end(不包含end)内的字符作为字符串s的初值
i) s.~string() //销毁所有字符，释放内存

2．字符串操作函数
这里是C++字符串的重点，我先把各种操作函数罗列出来，不喜欢把所有函数都看完的人可以在这里找自己喜欢的函数，再到后面看他的详细解释。
a) =,assign() //赋以新值
b) swap() //交换两个字符串的内容
c) +=,append(),push_back() //在尾部添加字符
d) insert() //插入字符
e) erase(int nStart,int nEnd) //删除nStart—nEnd位置字符
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() //返回配置器

在平常工作中经常用到了string类，本人记忆了不好用到了的时候经常要去查询。在网上摘抄一下总结一下，为以后的查询方便：

string类的构造函数：
string(const char*s);    //用c字符串s初始化string(intn,char c);     //用n个字符c初始化

string类的字符操作：
const char&operator[](int n)const;
const char &at(intn)const;
char &operator[](intn);
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中对象字符的处理，有很多已有的函数在CCtype头文件中，可以很方便的应用

string的特性描述:
intcapacity()const;    //返回当前容量（即string中不必增加内存即可存放的元素个数）
intmax_size()const;    //返回string对象中可存放的最大字符串的长度
intsize()const;        //返回当前字符串的大小
intlength()const;       //返回当前字符串的长度
boolempty()const;        //当前字符串是否为空
void resize(int len,charc);//把字符串当前大小置为len，并用字符c填充不足的部分

string类的输入输出操作:string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。
函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中，以换行符'\n'分开。

string的赋值：
string &operator=(conststring &s);//把字符串s赋给当前字符串
string &assign(constchar *s);//用c类型字符串s赋值
string &assign(constchar *s,int n);//用c字符串s开始的n个字符赋值
string &assign(conststring &s);//把字符串s赋给当前字符串
string &assign(intn,char c);//用n个字符c赋值给当前字符串
string &assign(conststring &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(constchar *s);            //把c类型字符串s连接到当前字符串结尾
string &append(constchar *s,int n);//把c类型字符串s的前n个字符连接到当前字符串结尾
string &append(conststring &s);    //同operator+=()
string &append(conststring &s,int pos,int n);//把字符串s中从pos开始的n个字符连接到当前字符串的结尾
string &append(intn,char c);        //在当前字符串结尾添加n个字符c
string&append(const_iterator first,const_iterator last);//把迭代器first和last之间的部分连接到当前字符串的结尾

string的比较：
bool operator==(conststring &s1,const string &s2)const;//比较两个字符串是否相等
运算符">","<",">=","<=","!="均被重载用于字符串的比较；
int compare(const string&s) const;//比较当前字符串和s的大小
int compare(int pos, intn,const string &s)const;//比较当前字符串从pos开始的n个字符组成的字符串与s的大小
int compare(int pos, intn,const string &s,int pos2,int n2)const;//比较当前字符串从pos开始的n个字符组成的字符串与s中pos2开始的n2个字符组成的字符串的大小
int compare(const char *s)const;
int compare(int pos, intn,const char *s) const;
int compare(int pos, intn,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, intpos = 0) const;//从pos开始查找字符串s在当前串中的位置
int find(const char *s, intpos, 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(constchar *s, int pos = 0) const;
int find_first_of(constchar *s, int pos, int n) const;
int find_first_of(conststring &s,int pos = 0) const;
//从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。查找失败返回string::npos 
int find_first_not_of(charc, int pos = 0) const;
int find_first_not_of(constchar *s, int pos = 0) const;
int find_first_not_of(constchar *s, int pos,int n) const;
int find_first_not_of(conststring &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(conststring &s,int pos = npos) const; 
int find_last_not_of(charc, int pos = npos) const;
int find_last_not_of(constchar *s, int pos = npos) const;
int find_last_not_of(constchar *s, int pos, int n) const;
int find_last_not_of(conststring &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_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(intp0,const string &s);
string &insert(intp0,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(iteratorit, 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(iteratorit);//删除it指向的字符，返回删除后迭代器的位置
string &erase(int pos =0, int n = npos);//删除pos开始的n个字符，返回修改后的字符串

string类的迭代器处理：
string类提供了向前和向后遍历的迭代器iterator，迭代器提供了访问各个字符的语法，类似于指针操作，迭代器不检查范围。
用string::iterator或string::const_iterator声明迭代器变量，const_iterator不允许改变迭代的内容。常用迭代器函数有：
const_iteratorbegin()const;
iteratorbegin();               //返回string的起始位置
const_iterator end()const;
iteratorend();                   //返回string的最后一个字符后面的位置
const_iteratorrbegin()const;
iteratorrbegin();               //返回string的最后一个字符的位置
const_iterator rend()const;
iteratorrend();                   //返回string第一个字符位置的前面
rbegin和rend用于从后向前的迭代访问，通过设置迭代器string::reverse_iterator,string::const_reverse_iterator实现

字符串流处理：
通过定义ostringstream和istringstream变量实现，<sstream>头文件中
例如：
    stringinput("hello,this is a test");
   istringstream is(input);
    strings1,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();

标准C++库字符串类std::string的用法

#include<string>

std::string s1;

std::string s3(s2);

std::string s2("this is a string");

begin       得到指向字符串开头的Iterator

end       得到指向字符串结尾的Iterator

rbegin       得到指向反向字符串开头的Iterator

rend       得到指向反向字符串结尾的Iterator

size       得到字符串的大小

length()       和size函数功能相同

max_size       字符串可能的最大大小

capacity       在不重新分配内存的情况下，字符串可能的大小

empty       判断是否为空

operator[]       取第几个元素，相当于数组

c_str       取得C风格的constchar*字符串

data       取得字符串内容地址

operator=       赋值操作符

reserve       预留空间

swap       交换函数

insert       插入字符

append       追加字符

push_back       追加字符

erase       删除字符串

clear       清空字符容器中所有内容

resize       重新分配空间

assign       和赋值操作符一样

replace       替代

copy       字符串到空间

find       查找,返回基于0的索引号

rfind       反向查找

find_first_of       查找包含子串中的任何字符，返回第一个位置

find_first_not_of       查找不包含子串中的任何字符，返回第一个位置

find_last_of       查找包含子串中的任何字符，返回最后一个位置

find_last_not_of       查找不包含子串中的任何字符，返回最后一个位置

substr(n1,len)       得到字符串从n1开始的长度为len的子串

比较字符串(支持所有的关系运算符)

compare       比较字符串

operator+       字符串链接

operator+=       += 操作符

operator==       判断是否相等

operator!=       判断是否不等于

operator<       判断是否小于

operator>>       从输入流中读入字符串

operator<<       字符串写入输出流

getline       从输入流中读入一行

2．3元素存取

我们可以使用下标操作符[]和函数at()对元素包含的字符进行访问。但是应该注意的是操作符[]并不检查索引是否有效（有效索引0~str.length()），如果索引失效，会引起未定义的行为。而at()会检查，如果使用 at()的时候索引无效，会抛出out_of_range异常。
有一个例外不得不说，const string a;的操作符[]对索引值是a.length()仍然有效，其返回值是’’。其他的各种情况，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()] //返回 ‘’
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立即失效。避免的方法就是不使用。

遍历所有字符，这可由C风格的索引或STL迭代子来完成（如果无需修改，应使用const_iterator）。

std::string name = "marius";

for(size_t i = 0; i < name.length(); ++i)

std::cout << name[i];

 

for(std::string::const_iterator cit = name.begin(); cit != name.end(); ++cit)

std::cout << *cit;

 

for(std::string::iterator it = name.begin();it != name.end(); ++it)

*it = toupper(*it);
2．4比较函数
C ++字符串支持常见的比较操作符（>,>=,<,<=,==,!=），甚至支持string与C-string的比较(如 str<"hello")。在使用>,>=,<,<=这些操作符的时候是根据"当前字符特性"将字符按字典顺序进行逐一得 比较。字典排序靠前的字符小，比较的顺序是从前向后比较，遇到不相等的字符就按这个位置上的两个字符的比较结果确定两个字符串的大小。同时，string ("aaaa") <string(aaaaa)。
另一个功能强大的比较函数是成员函数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"比较。
怎么样？功能够全的吧！什么？还不能满足你的胃口？好吧，那等着，后面有更个性化的比较算法。先给个提示，使用的是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开始到结尾赋给s
s.assign("gaint"); //不说
s.assign("nico",5);//把’n’ ‘I’ ‘c’ ‘o’ ‘’赋给字符串
s.assign(5,’x’);//把五个x赋给字符串
把字符串清空的方法有三个：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’);
2.5.1、在字符串结尾插入其他元素。
s.push_back(‘a’);//这个函数只能增加单个字符 对STL熟悉的理解起来很简单
2.5.2、 在指定位置插入字符串或字符。

也许你需要在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_string

2.5.3、 删除字符串的某一部分。
s.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搜索与查找

std::string类的查找函数
查找函数很多，功能也很强大，包括了：
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)）。

3.1、使用STL算法

 

std::string name = "marius";

// 使字符串全为大写

std::transform(name.begin(), name.end(), name.begin(),toupper);

std::string name = "marius";

// 升序排列字符串

std::sort(name.begin(), name.end());

std::string name = "marius";

// 反转字符串

std::reverse(name.begin(), name.end());

bool iswhitespace(char ch)

{

return  ch == ' ' || ch == 't' || ch == 'v' ||

ch == 'r' || ch == 'n';

}

 

std::string name = " marius  ";

// 删除空白字符

std::string::iterator newend = std::remove_if(name.begin(), name.end(), iswhitespace);

name.erase(newend);

 

 

std::string类的替换函数

 

函数1：
std::string & replace(size_type pos1, size_type n1, const std::string & str, size_type pos2 = 0, size_type n2 = npos);

该函数的作用：使用str字符串从位置pos2开始的n2个字符，替换当前字符串从pos1位置开始处的n1个字符。
可以这样理解：该函数将当前字符串从pos1开始的n1个字符全部删除，然后再用str整个字符串或者str从pos2开始的n2个字符，从pos1位置开始填入到当前字符串中。

提醒：如果n1或者n2的数值超出了对应字符串的长度，以实际长度为准，不会出现访问越界的情况。

注意：
a、如果pos1指定的位置超出当前字符串的范围，抛出std::out_of_range异常，不捕捉将导致coredump。
b、如果pos2指定的位置超出替换字符串str的范围，抛出std::out_of_range异常，不捕捉将导致coredump。

函数2：
std::string& replace(size_type pos, size_type n1, const char * s, size_type n2);

该函数的作用：使用字符串s的前n2个字符，替换当前字符串从pos位置开始处的n1个字符。
可以这样理解：函数将当前字符串从pos开始的n1个字符全部删除，然后再用字符串s的前n2个字符填入到当前字符串中。类似于函数1的pos2等于0，必须指定n2的这种情况，但也有一点的差别，下面会注意里描述这种差别。
注意：
a、如果pos指定的位置超出当前字符串的范围，抛出std::out_of_range异常，不捕捉将导致coredump。
b、该函数不会判断字符串s和n2的大小关系，它严格地从s起始处拷贝n2个字符到指定位置。如果n2表示的长度超出了s的范围，它会读取s后面的内存空间，有可能会因为内存访问越界而coredump。但函数1的n2可以超出范围，它以实际长度为准。

函数3：
std::string& replace(size_type pos, size_type n1, const char* s);

该函数的作用：使用以''为结尾的字符串s，替换当前字符串从pos位置开始处的n1个字符。
可以这样理解：函数将当前字符串从pos开始的n1个字符全部删除，然后再用字符串s从开始到以''结束的所有字符，从pos位置开始填入到当前字符串中。

注意：如果pos指定的位置超出当前字符串的范围，抛出std::out_of_range异常，不捕捉将导致coredump。

函数4：
std::string& replace(size_type pos, size_type n1, size_type n2, char c);

该函数的作用：使用n2个c表示的字符，替换当前字符串从pos位置开始处的n1个字符。
可以这么理解：函数将当前字符串从pos开始的n1个字符全部删除，然后再用n2个c字符，从pos位置开始填入到当前字符串中。

注意：如果pos指定的位置超出当前字符串的范围，抛出std::out_of_range异常，不捕捉将导致coredump。

函数5：
std::string& replace(iterator i1, iterator i2, const std::string& str);

该函数的作用：使用字符串str，替换当前字符串[i1,i2)之间的字符。

函数6：
std::string& replace(iterator i1, iterator i2, const char* s, size_type n);

该函数的作用：使用字符串s的前n个字符，替换当前字符串[i1,i2)之间的字符。

函数7：
std::string& replace(iterator i1, iterator i2, const char* s);

该函数的作用：使用以''结尾的字符串s，替换当前字符串[i1,i2)之间的字符。

函数8：
std::string& replace(iterator i1, iterator i2, size_type n, char c);

该函数的作用：使用n个c表示的字符，替换当前字符串[i1,i2)之间的字符。

std::string类的内部类型定义

typedef traits traits_type;

typedef typename traits::char_type value_type;

typedef size_t size_type;

typedef Allocator allocator_type;

typedef ptrdiff_t difference_type;

typedef Allocator allocator_type;

typedef Allocator allocator_type;

typedef Allocator allocator_type;

typedef charT& reference; typedef const charT& const_reference; typedef charT* pointer; typedef const charT* const_pointer; typedef pointer iterator; typedef const_pointer const_iterator; typedef ::reverse_iterator reverse_iterator; typedef ::reverse_iterator const_reverse_iterator; static const size_type npos = static_cast(-1);

std::string类的赋值运算符

string& operator= (const char* s);
string& operator= (char c);
string& operator+= (const string& rhs);
string& operator+= (const char* s);
string& operator+= (char c);
string operator+ (const string & lhs, const string & rhs);
string operator+ (const char* lhs, const string & rhs);
string operator+ (char lhs, const string & rhs);
string operator+ (const string & lhs, const char* rhs);
string operator+ (const string & lhs, char rhs);

std::string类的逻辑运算符

bool operator== (const string & lhs, const string & rhs);
bool operator== (const char* lhs, const string & rhs);
bool operator== (const string & lhs, const char* rhs);
bool operator!= (const string & lhs, const string & rhs);
bool operator!= (const char* lhs, const string & rhs);
bool operator!= (const string & lhs, const char* rhs);
bool operator< (const string & lhs, const string & rhs);
bool operator< (const char* lhs, const string & rhs);
bool operator< (const string & lhs, const char* rhs);
bool operator> (const string & lhs, const string & rhs);
bool operator> (const char* lhs, const string & rhs);
bool operator> (const string & lhs, const char* rhs);
bool operator<= (const string & lhs, const string & rhs);
bool operator<= (const char * lhs, const string & rhs);
bool operator<= (const string & lhs, const char * rhs);
bool operator>= (const string & lhs, const string & rhs);
bool operator>= (const char* lhs, const string & rhs);
bool operator>= (const string & lhs, const char* rhs);

istream& operator >> (istream&, string &);
ostream& operator << (ostream&, const string &);
istream& getline (istream&, string &, char delim = 'n');

 

         在程序中常常需要处理字符串，除了以前写的一些关于char的方法的总结外，很多的时候也会用到string来进行字符串处理。下面对它的常用方法做些总结：

 

1、定义：

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迭代器之间的部分赋给字符串

 

2、append方法：

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之间的部分连接到当前字符串的结尾

 

3、比较compar方法：

bool operator==(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  

 

4、查找find方法：

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相似，只不过是从后向前查找

 

5、插入insert方法：

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

 

6、删除erase方法：

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

 

7、替换replace方法：

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_iterator last);//把[first0，last0）之间的部分替换成[first，last）之间的字符串 

8、获得字串substr方法：

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

 

9、交换swap的方法：

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