之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必担心内存是否足够、字符串长度等等,而且作为一个泛型类出现,他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作,== 进行比较,+ 做串联(是不是很简单?)。我们尽可以把它看成是C++的基本数据类型。
C++中对于strinig的定义为:typedef basic_string string; 也就是说C++中的string类是一个泛型类,由模板而实例化的一个标准类,本质上不是一个标准数据类型。
好了,进入正题………
首先,为了在我们的程序中使用string类型,我们必须包含头文件 。如下:
#include //注意这里不是string.h string.h是C字符串头文件
using namespace std; //此语句必不可少,否则有的编译器无法识别
1.声明一个C++字符串
声明一个字符串变量很简单:
string Str;
这样我们就声明了一个字符串变量,但既然是一个类,就有构造函数和析构函数。上面的声明没有传入参数,所以就直接使用了string的默认的构造函数,这个函数所作的就是把Str初始化为一个空字符串。String类的构造函数和析构函数如下:
a) string s; //生成一个空字符串s
b) 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) //以区间beg;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) << //将谋值写入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”比较。
怎么样?功能够全的吧!什么?还不能满足你的胃口?好吧,那等着,后面有更个性化的比较算法。先给个提示,使用的是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’ ‘\0’赋给字符串
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’);
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_string
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搜索与查找
查找函数很多,功能也很强大,包括了:
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))。
C++ 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 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
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_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个字符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();
c++ String 类函数详解(代码版)
#include < iostream >
#include < string >
using namespace std;
void main()
{
string s = "asdssfghjkl";
char a1;
string::iterator it;
string::const_iterator cit;
string::size_type n;
s.append("zxcv"); //s="asdssfghjklzxcv",参数必须为string类型 不可为char。
s.assign("qwert"); //s="qwert",相当于赋值操作,赋以新值 ,参数不可为char。
a1 = s.at(0); //a1='q' 下标操作
a1 = s.back(); //a1='t' 返回最后一个字符
it = s.begin(); //返回字符串起始位置的迭代器,cit = s.begin(); 正确
a1=it[0]; //s ="qwert", a1='q',a=cit[0]; 正确
it[3] = 'f'; //s ="qweft",cit[3] = 'f'; 错误
n = s.capacity(); //s="qwert" n=15(win64 vs2013)
/*
给字符串分配内存的时候,并不是有多大长度分配多少的,考虑到append等操
作,一次分配内存是比给他的字符串长度多的。这样在append的时候,就不用
每次都分配内存了。除非append时,已分配内存不够了,会再次追加一次内存
分配。当前已经分配的内存大小,就是capacity。字符串实际大小,就是
size。这样做是为了提高字符串操作效率。capacity是容量,是可存放字符
的个数。size是大小,是当前已存放字符的个数。capacity >= size, 具
体capcacity大多少,具体的stl库实现决定。capacity是可增大的,如果当
前size加上要加入的字符个数超过capacity,capacity就要增大,一般翻倍
增长,具体取决于实现。
*/
cit=s.cbegin(); //s="qweft",返回字符串起始位置的const型迭代器
a1 = cit[1]; // a1='w'
/*
1.iterator,const_iterator作用:遍历容器内的元素,并访问这些元素的
值。iterator可以改元素值,但const_iterator不可改。跟C的指针有点像
2.const_iterator 对象可以用于const vector 或非 const vector,它
自身的值可以改(可以指向其他元素),但不能改写其指向的元素值. 如 cit[1]
= 'o' 错误
*/
cit = s.cend(); //cit = " ",返回字符串末尾的 const型迭代器
s.clear(); //删除字符串里的所有字符
s = "asdfg";
int n1=s.compare("asdfg"); //n1=0 字符串比较
int n2 = s.compare("sdfg"); //n1=-1
int n3 = s.compare("ab"); //n1=1
char* sdest;
n=s.copy(sdest,1,0); //会报unsafe的问题
/*
size_type copy( CharT* dest, size_type count, size_type
pos = 0);
参数:
dest pointer to the destination character string
pos position of the first character to include
count length of the substring
返回值:
copy的字符个数
从string类型对象中至多复制count个字符到字符指针dest指向的空间中。默
认从首字符开始,但是也可以指定,开始的位置(记住从0开始)。返回真正从对
象中复制的字符。用户要确保p指向的空间足够保存n个字符。
*/
string::const_reverse_iterator it2;
it2=s.crbegin(); /*返回const翻转迭代器,将s先翻转,再取其begin。
it2[2] = 'g';错误。it2=" ",相当于取到s的最后一个元素 ++是往s的前
面取。*/
a1 = it2[0]; //a1='g'
a1 = it2[1]; //a1='f'
it2 = s.crend(); /*返回const翻转迭代器,将s先翻转,再取其end。
it2 = "asdfg"; char a3 = it2[0]; char a4 = it2[1]; 错误溢出。
相当于取到s的第一个元素前一个。与cbegin cend 相反。*/
const char* s1;
s1=s.c_str(); /*s1="asdgf",c_str()返回的是一个临时指针,不能
对其进行操作,s中字符删除s1也就没了,s1是c字符串,末尾追加\0。*/
/*
const char* c;
string s="1234";
c = s.c_str();
cout<<c<<endl; //输出:1234
s="abcd";
cout<<c<<endl; //输出:abcd
c_str()返回一个客户程序可读不可改的指向字符数组的指针,不需要手动释放
或删除这个指针。*/
s1=s.data(); /*s1="asdfg",与c_str()类似,但是返回的数组不以空
字符终止。*/
bool flag = s.empty(); //flag=false,返回bool型,为空返回true
it=s.end(); //it=" ",返回迭代器指向s末尾。
s.erase(2,2); //s="asg",从下标2开始删除2个,s = "asdfg";
s.erase(s.begin(), s.begin() + 3); //s="fg",s = "asdfg";
s.erase(4); //s="asdf",删除下标4的值,s = "asdfg";
s.erase(s.begin() + 4); //s="asdf",删除下标4的值。
s.erase(s.begin(), s.end()); //s=" ",s.end()是末尾元素下一个
/*
(1)erase(pos,n);
删除从pos开始的n个字符,比如erase(0,1)就是删除第一个字符
(2)erase(position);
删除position处的一个字符(position是个string类型的迭代器)
(3)erase(first,last);
删除从first到last之间的字符(first和last都是迭代器)
输入下标0,1,2...和迭代器s.begin(),s.begin()+1....A对应。
*/
s = "asdfg";
n = s.find("asdfg"); //n=0 查找 全匹配
n=s.find(100); //n=2,将100转为字符查找,d的ascii码为100
n=s.find('dfg'); //n=4
n = s.find("dfg"); //n=2
n=s.find("dhh"); //n=string::npos=4294967295
n = s.find("wer"); //n=string::npos=4294967295
n=s.find('f'); //n=3
n = s.find("f"); //n=3
char as = 'dfg'; //as='g'
n = s.find_first_of("asdfg"); //n=0,查找包含子串中的任何字符, 返回第一个位置
n = s.find_first_of(3); //n=string::npos=4294967295
n = s.find_first_of('dfg'); //n=4
n = s.find_first_of("dfg"); //n=2
n = s.find_first_of("dhh"); //n=2
n = s.find_first_of("wer"); //n=string::npos=4294967295
n = s.find_first_of('f'); //n=3,从pos开始查找字符第一次出现的位置
n = s.find_first_of("f"); //n=3
n = s.find_last_of("asdfg"); //n=4,查找包含子串中的任何字符,返回最后一个位置
n = s.find_last_of(3); //n=string::npos=4294967295
n = s.find_last_of('dfg'); //n=4
n = s.find_last_of("dfg"); //n=4
n = s.find_last_of("dhh"); //n=2
n = s.find_last_of("wer"); //n=string::npos=4294967295
n = s.find_last_of('f'); //n=3
n = s.find_last_of("f"); //n=3
n = s.find_first_not_of("asdfg");//n=string::npos=4294967295,查找不包含子串中的任何字符,返回第一个位置。从当前串中查找第一个不在参数串中的字符出现的位置
n=s.find_first_not_of(3); //n=0
n=s.find_first_not_of('dfg'); //n=0
n = s.find_first_not_of("dfg");//n=0
n=s.find_first_not_of("dhh"); //n=0
n = s.find_first_not_of("wer");//n=0
n=s.find_first_not_of('f'); //n=0
n = s.find_first_not_of("f"); //n=0
n = s.find_last_not_of("asdfg");//n=string::npos=4294967295,查找不包含子串中的任何字符,返回最后一个位置
n=s.find_last_not_of(3); //n=4
n=s.find_last_not_of('dfg'); //n=3
n = s.find_last_not_of("dfg"); //n=1
n=s.find_last_not_of("dhh"); //n=4
n = s.find_last_not_of("wer"); //n=4
n=s.find_last_not_of('f'); //n=4
n = s.find_last_not_of("f"); //n=4
n = s.rfind("asdfg"); //n=0,反向查找,从pos开始从后向前查找字符c在当前串中的位置
n=s.rfind(3); //n=string::npos=4294967295
n=s.rfind('dfg'); //n=4
n = s.rfind("dfg"); //n=2
n=s.rfind("dhh"); //n=string::npos=4294967295
n = s.rfind("wer"); //n=string::npos=4294967295
n=s.rfind('f'); //n=3
n = s.rfind("f"); //n=3
/*以上查找函数都被重载了4次:
size_type find(const basic_string& s, size_type pos = 0)
//从pos开始查找字符串s在当前串中的位置
size_type find(const charT* s, size_type pos, size_type n)
//从pos开始查找字符串s中前n个字符在当前串中的位置
size_type find(const charT* s, size_type pos = 0)
//从pos开始查找字符串s在当前串中的位置
size_type find(charT c, size_type pos = 0)
//从pos开始查找字符c在当前字符串的位置
所有的查找函数都返回一个size_type类型,这个返回值一般都是所找到字符串
的位置,如果没有找到,则返回string::npos。
有一点需要特别注意,所有和string::npos的比较一定要用
string::size_type来使用,不要直接使用int 或者unsigned int等类
型。其实string::npos表示的是-1。
*/
a1=s.front();//a1='a',返回首字符,返回值为char/const char,不是string或迭代器
string::allocator_type aa=s.get_allocator(); //返回本字符串的配置器
s.insert(2,"z"); //s="aszdfg"
s.insert(2, "qwegt", 3); //s="asqwezdfg"。
/*const string a1 = "zxc"; s.insert(2,a1); //错误*/
s.insert(2, "zxcv", 2, 2); //s="ascvqwezdfg"
/*
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
*/
n = s.length(); //n=11,s="ascvqwezdfg",返回字符串长度。
n = s.max_size(); //s="ascvqwezdfg",n=4294967294,返回值是string所支持最大长度,一般也不会用到这么长的字符串。
n=s.npos; //n=4294967295
string s11 = "qwe";
string s22 = "asd";
string ss = s11 + s22; //ss=""qweasd""
ss += "dfr"; //ss=""qweasddfr""
//s11+=s22; //错误
//s11 = s22; //错误 string 不能到const char*
a1 = s[3]; //a1='v'
s.pop_back(); //s="ascvqwezdf",删除最后一位
a1 = 'm';
s.push_back(a1); //s=""ascvqwezdfm"" 参数为char型
string::reverse_iterator rit;
string::const_reverse_iterator crit;
rit=s.rbegin(); //s="ascvqwezdfm",末尾为start,开始为end,迭代器从后往前递增
a1=rit[3]; //s="ascvqwezdfm" a1='z'
rit[3] = 'n'; //rit="" s="ascvqwendfm" 从后往前下标为三的变成了n
crit = s.rbegin(); //crit="" s="ascvqwendfm"
a1 = crit[4]; //a1='e' s="ascvqwendfm"
//crit[3] = 'n'; //错误 不能改变const迭代器指向的值
rit = s.rend(); //s="ascvqwendfm" 末尾为start 开始为end rit=""
//a1 = rit[3]; //报错 溢出
// rit[3] = 'n'; //报错 溢出
crit = s.rend(); //crit="" s="ascvqwendfm"
//a1 = crit[4]; //报错 溢出
//crit[3] = 'n'; //错误 不能改变const迭代器指向的值
string s33 = "mnbvcx"; //s="ascvqwendfm"
const char * s44= "asdfg"; //s="ascvqwendfm"
s.replace(2,3,s33); //s="asmnbvcxwendfm",替换原字符串下标2开始长度3的字符
s.replace(2, 3, s44); //s="asasdfgvcxwendfm"
s.replace(s.begin()+2,s.end()-2, s33); //s="asmnbvcxfm"
s.replace(s.begin() + 2, s.end() - 2, s44);//s="asasdfgfm"
s.replace(2, 3, s33, 2, 3); //s="asbvcfgfm"
s.replace(2, 3, s44, 2, 3); // s="asdfgfgfm"
s.replace(2, 3, s44, 2); // s="asasfgfm"
s.replace(s.begin() + 2, s.end() - 2, s44,4); //s="asasdffm"
s.replace(2, 3, 4, 'c'); //s="asccccffm"
s.replace(s.begin() + 2, s.end() - 2, 4, 'f'); //s="asfffffm"
/*
用法一:
用str替换指定字符串从起始位置pos开始长度为len的字符
string& replace (size_t pos, size_t len, const string&
str);
用法二:
用str替换 迭代器起始位置 和 结束位置 的字符
string& replace (const_iterator i1, const_iterator i2,
const string& str);
用法三:
用substr的指定子串(给定起始位置和长度)替换从指定位置上的字符串
string& replace (size_t pos, size_t len, const string&
str, size_t subpos, size_t sublen);
用法四:
string转char*时编译器可能会报出警告,不建议这样做,用str替换从指定
位置0开始长度为5的字符串。
string& replace(size_t pos, size_t len, const char* s);
用法五:
string转char*时编译器可能会报出警告,不建议这样做,用str替换从指定
迭代器位置的字符串
string& replace (const_iterator i1, const_iterator i2,
const char* s);
用法六:
string转char*时编译器可能会报出警告,不建议这样做,用s的前n个字符
替换从开始位置pos长度为len的字符串
string& replace(size_t pos, size_t len, const char* s,
size_t n);
用法七:
string转char*时编译器可能会报出警告,不建议这样做,用s的前n个字符
替换指定迭代器位置(从i1到i2)的字符串
string& replace (const_iterator i1, const_iterator i2,
const char* s, size_t n);
用法八:
用重复n次的c字符替换从指定位置pos长度为len的内容
string& replace (size_t pos, size_t len, size_t n, char
c);
用法九:
用重复n次的c字符替换从指定迭代器位置(从i1开始到结束)的内容
string& replace (const_iterator i1, const_iterator i2,
size_t n, char c);
*/
n = s.size(); //n=8 s="asfffffm"
s.reserve(2); //指定 容器 能存储数据的个数
s.resize(3); //重新 指定 有效元素的个数 s="asf"
n=s.size(); //n=3
/*
size() 指目前存在的元素数。 元素个数
capacity() 指容器能存储 数据的个数 容器容量
reserve() 指定容器能存储数据的个数
resize() 重新指定有效元素的个数 ,区别于reserve()指定容量的大小
当创建空容器时,容量(capacity)为 0;当用完时,增加原容量的 1/2 (各
编译器 可能存在差异 vs2010是这样的,mingw则 增加原容量 )--适用如
vector这种 元素连续存储的容器, 如为list则不同。capacity 一般大于
size的原因是为了避免 每次增加数据时都要重新分配内存,所以一般会 生成一
个较大的空间,以便随后的数据插入。
*/
s = "asdfgh";
n=s.rfind("sdf",2); //n=1
n = s.rfind("serr"); //n=4294967295
n = s.rfind("serr",2); //n=4294967295
n = s.rfind('serr', 2); //n=4294967295
n = s.rfind('s', 2); //n=1
n = s.rfind('s'); //n=1
n = s.rfind("serr", 2,3); //n=4294967295
n = s.rfind("sdf", 2,2); //n=1
/*
rfind全名reversefind,与find相。
size_type rfind( const basic_string &str, size_type index
);
//返回最后一个与str中的某个字符匹配的字符,从index开始查找。如果没找
到就返回string::npos。
size_type rfind( const char *str, size_type index );
//返回最后一个与str中的某个字符匹配的字符,从index开始查找。如果没找
到就返回string::npos。
size_type rfind( char ch, size_type index );
//返回最后一个与ch匹配的字符,从index开始查找。如果没找到就返回
string::npos。
这里要注意与find不同的地方,rfind是从左往右数index个位置,这里作为基
准index,然后从这里开始,从右往左数到第一次出现目标的位置。
find是在基准index从左往右数。
*/
s.shrink_to_fit(); //无返回值
/*
erase 改变了size,但并没有改变capacity,并未真正释放空间
clear后 size==0,capacity不变,并未真正释放空间。
vector<int>(vec).swap(vec) 使得vec的capacity()==size(),真正
释放了空间。
C++11中已经实现了shink_to_fit函数 替代swap,调用该请求可能会引起一
次内存重分配,但不会对size产生影响,使得capacity()==size()。
*/
ss = s.substr(3); //s="asdfgh",ss="fgh",从s的下标3 的位置开始取到末尾
ss = s.substr(3,4); //ss="fgh"
ss = s.substr(1, 4); //ss="sdfg" 从下标1开始取4个
/*
basic_string substr( size_type index, size_type num = npos
);下标非迭代器
substr()返回本字符串的一个子串,从index开始,长num个字符。
如果没有指定,将是默认值 string::npos。这样,substr()函数将简单的返
回从index开始的剩余的字符串。
*/
s.swap(s); //s="asdfgh" 用来交换两个string的值 无返回值
s.swap(ss); //s="sdfg" ss="asdfgh"
system("pause");
}
转载于以下大佬的博客:
https://www.cnblogs.com/c1299401227/p/5370685.html
https://blog.csdn.net/sinat_36184075/article/details/54836053