说明:文章很长,不必一次读完,可以先大体看看文章的结构内容,当作参考字典来使用,如果有用到的再来查阅。
C++中字符串表示形式
C++中提供了两种类型的字符串表示形式:
- C风格字符串
- C++引入的string类类型
C风格字符串
C风格的字符串是使用null字符或\0终止的一维字符数组。
声明和初始化一个字符串
//由于数组末尾存储了空字符,故字符数组的大小比字符数多一个
char c[7] = {'a','b','c','d','e','f','\0'};
//也可以写成
char c1[] = "abcdef";
//输出
printf("%s\n",c);
printf("%d\n",sizeof(c)); //输出为7
printf("%s\n",c1);
printf("%d\n",sizeof(c1)); //输出也为7
执行结果:
注意:一般不需要把’\0’字符放在字符串常量末尾,C编译器会在初始化数组时,自动把’\0’放在字符串的末尾。
C语言中操作字符串的常用函数
C语言中提供了string库,需要引入头文件 #include<string.h>
字符串复制strcpy()、strncpy()
char *strcpy(char *dest, const char *src)
把 src 所指向的字符串复制到 dest
参数:
dest指向用于存储复制内容的目标数组。
src指向要复制的字符串。
返回值:
返回一个指向最终目标字符串dest的指针。
char src[20];
char dest[20];
memset(dest,'\0',sizeof(dest));
strcpy(src,"hello world");
strcpy(dest,src);
printf("%s\n",dest); //hello world
char *strncpy(char *dest, const char *src, size_t n)
把 src 所指向的字符串复制到 dest,最多复制 n 个字符。当 src 的长度小于 n 时,dest 的剩余部分将用空字节填充
参数:
dest指向用于存储复制内容的目标数组。
src指向要复制的字符串。
n是要从源中复制的字符数。
返回值:
返回一个指向最终目标字符串dest的指针。
char src[20];
char dest[20];
memset(dest,'\0',sizeof(dest));
strcpy(src,"hello world");
strncpy(dest,src,8);
printf("%s\n",dest); //hello wo
复制memcpy()、memmove()
void *memcpy(void *str1, const void *str2, size_t n)
从存储区 str2 复制 n 个字节到存储区 str1
参数:
str1指向用于存储复制内容的目标数组,类型强制转换为void指针
str2指向要复制的数据源,类型强制转换为void指针
n是要被复制的字节数
返回值:
返回一个指向目标存储区str1的指针
char src[20] = "hello world";
char dest[20];
memcpy(dest, src, strlen(src)+1);
printf("%s\n",dest); //hello world
strcpy()和memcpy()的区别:
1.复制的内容不同。strcpy只能复制字符串,memcpy可以复制任意内容,例如字符数组、整型、结构体等。
2.复制的方法不同。strcpy不需要指定长度,它遇到被复制字符串结束符’\0’才结束,所以容易溢出。memcpy则是根据第三个参数决定复制的长度。
3.用途不同。通常复制字符串时用strcpy,而需要复制其他类型数据时一般用memcpy。
void *memmove(void *str1, const void *str2, size_t n)
从 str2 复制 n 个字符到 str1
参数:
str1指向用于存储复制内容的目标数组,类型强制转换为void指针
str2指向要复制的数据源,类型强制转换为void指针
n是要被复制的字节数
返回值:
返回一个指向目标存储区str1的指针
const char src[20] = "newstring";
const char dest[20] = "oldstring";
printf("%s %s\n",dest,src); //oldstring newstring
memmove(dest, src, 9);
printf("%s %s\n",dest,src); //newstring newstring
memcpy()和memmove()的区别:
在重叠内存方面,memmove()是比memcpy()更安全的方法。
如果目标区域和原区域有重叠的话,mommove()能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中,复制后源区域的内容会被更改。
如果目标区域与源区域没有重叠,则和memcpy()函数功能相同。
字符串比较strcmp()、strncmp()
int strcmp(const char *str1, const char *str2)
把 str1 所指向的字符串和 str2 所指向的字符串进行比较(两个字符串自左向右逐个字符相比(按 ASCII 值大小相比较),直到出现不同的字符或遇 \0 为止)
参数:
str1是要进行比较的第一个字符串
str2是要进行比较的第二个字符串
返回值:
如果返回值<0,则表示str1<str2
如果返回值>0,则表示str1>str2
如果返回值=0,则表示str1=str2
char str1[] = "abcdefg";
char str2[] = "ABCDEFG";
int ret = strcmp(str1, str2);
printf("%d\n",ret); //1,即str1>str2
int strncmp(const char *str1, const char *str2, size_t n)
把 str1 所指向的字符串和 str2 所指向的字符串进行比较,最多比较前 n 个字节
参数:
str1是要进行比较的第一个字符串
str2是要进行比较的第二个字符串
n是要比较的最大字符数
返回值:
如果返回值<0,则表示str1<str2
如果返回值>0,则表示str1>str2
如果返回值=0,则表示str1=str2
char str1[] = "abcdefg";
char str2[] = "abcdEFG";
int ret = strncmp(str1, str2, 4);
printf("%d\n",ret); //0,即str1和str2的前4个字符相等
比较memcmp()
int memcmp(const void *str1, const void *str2, size_t n)
把存储区 str1 和存储区 str2 的前 n 个字节进行比较
参数:
str1是指向内存块1的指针
str2是指向内存块2的指针
n是要被比较的字节数
返回值:
如果返回值<0,则表示str1<str2
如果返回值>0,则表示str1>str2
如果返回值=0,则表示str1=str2
char str1[] = "abcdefg";
char str2[] = "abcdEFG";
int ret = memcmp(str1, str2, 5);
printf("%d\n",ret);//1,即str2 小于 str1
计算字符串长度strlen()
size_t strlen(const char *str)
计算字符串 str 的长度,直到空结束字符,但不包括空结束字符
参数:
str是要计算长度的字符串
返回值:
返回字符串的长度
char str1[] = "abcdefg";
printf("%d\n",strlen(str1)); //7
查找字符位置strchr()、strrchr()
char *strchr(const char *str, int c)
在参数 str 所指向的字符串中搜索第一次出现字符 c(一个无符号字符)的位置
参数:
str是要被检索的 C 字符串
c是在 str 中要搜索的字符。以 int 形式传递,但是最终会转换回 char 形式。
返回值:
返回在字符串 str 中第一次出现字符 c 的位置,如果未找到该字符则返回 NULL
char str1[] = "abcdefg";
char *ret;
ret = strchr(str1,'d');
printf("%s\n", ret); //defg
char *strrchr(const char *str, int c)
在参数 str 所指向的字符串中搜索最后一次出现字符 c(一个无符号字符)的位置
参数:
str是要被检索的 C 字符串
c是在 str 中要搜索的字符。以 int 形式传递,但是最终会转换回 char 形式。
返回值:
返回 str 中最后一次出现字符 c 的位置。如果未找到该值,则函数返回NULL
char str1[] = "abcdefdgh";
char *ret;
ret = strrchr(str1,'d');
printf("%s\n", ret);//dgh
查找字符串位置strstr()
char *strstr(const char *str1, const char *str2)
在字符串 str1中查找第一次出现字符串 str2的位置,不包含终止符 ‘\0’
参数:
str1是要被检索的 C 字符串
str2是要搜索的字符串
返回值:
返回 str1 中第一次出现字符串str2 的位置。如果未找到则函数返回NULL
char str1[] = "abcdefg";
char str2[] = "cde";
char *ret;
ret = strstr(str1,str2);
printf("%s\n", ret); //cdefg
追加字符串strcat()、strncat()
char *strcat(char *dest, const char *src)
把 src 所指向的字符串追加到 dest 所指向的字符串的结尾
参数:
dest指向目标数组,该数组包含了一个 C 字符串,且足够容纳追加后的字符串
src指向要追加的字符串,该字符串不会覆盖目标字符串
返回值:
返回一个指向最终的目标字符串 dest 的指针
char dest[] = "abcdefg";
char src[] = "hijk";
strcat(dest, src);
printf("%s\n", dest);//abcdefghijk
char *strncat(char *dest, const char *src, size_t n)
把 src 所指向的字符串追加到 dest 所指向的字符串的结尾,直到 n 字符长度为止
参数:
dest指向目标数组,该数组包含了一个 C 字符串,且足够容纳追加后的字符串
src指向要追加的字符串
n是要追加的最大字符数
返回值:
返回一个指向最终的目标字符串 dest 的指针
char dest[20] = "abcdefg";
char src[] = "hijk";
strncat(dest, src, 2);
printf("%s\n", dest);//abcdefghi
分解字符串strtok()
char *strtok(char *str, const char *delim)
分解字符串 str 为一组字符串,delim 为分隔符
参数:
str指向要被分解成一组小字符串的字符串
delim是包含分隔符的 C 字符串
返回值:
该函数返回被分解的第一个子字符串,如果没有可检索的字符串,则返回一个空指针
char str[20] = "hello world !";
char delim[] = " ";
char *ret = strtok(str,delim);
while(ret != NULL){
printf("%s\n ", ret);
ret = strtok(NULL, delim);
}
//hello
//world
//!
C++提供的string类
C++中提供了专门的头文件string来支持string类型。string类型可以让我们像普通变量那样处理字符串。string对象和字符数组之间主要的区别是:可以将string对象声明变为简单变量,而不是数组。
C++中常用函数及操作
首先,要使用string类型需要在头文件中声明:#include<string>
string类的构造函数(6个)
<1>默认构造函数
string(); 创建一个长度为0的string对象
string s;
cout<<s.size()<<endl; //0
<2>将string对象初始化为s
string(const char *s);
char *c = "abc";
string s(c); //或者string s("abc"); 注意这里"abc"是字符数组而不是string对象
cout<<s<<endl; //abc
<3>拷贝构造函数
string(const string &str, sizt_t pos=0, size_t len=npos);
索引值从0开始,这里的npos为构造函数参数,表示直到string对象的结尾。
如果给定参数表示从pos开始子串的长度。即如果指定索引位置:第二个参数为从哪个位置开始,第三个参数为拷贝的长度。
string c = "abcdefgh";
string s1(c); //注意与<2>的参数区别
cout<<s1<<endl; //abcdefgh
string s2(c,2);
cout<<s2<<endl; //cdefgh
string s3(c,2,5);
cout<<s3<<endl; //cdefg
<4>字符填充
string(size_t n, char c); 创建一个包含n个元素的string对象,其中每个元素都被初始化为字符c
string s(5,'a');
cout<<s<<endl; //aaaaa
<5>构造子串
string(const char *c, size_t n); 拷贝字符数组的前n个字符
char c1[] = "abcdefgh";
string s1(c1,5);
cout<<s1<<endl; //abcde
string(const string &str, size_t n);
拷贝字符串str的从第n个字符开始到结束的所有字符,其实就是上面<3>的变体形式,这里是为了说明字符数组和字符串之间用法的区别。
string c = "abcdefgh";
string s(c,5);
cout<<s1<endl; //fgh
需要注意的是,如果按照下面这个方式的话,"abcdefgh"应当看作字符数组,而不是字符串对象
string c = string("abcdefgh", 5);
cout<<c<<endl; //c = "abcde"而不是"fgh"
<6>template< class Iter >
string (Iter begin,Iter end); 范围是[begin,end),开区间不包括end
string s("abcdefgh");
string s1(s.begin()+3, s.end());
cout<<s1<<endl; //defgh
初始化
用上面的构造函数,C++中初始化一个字符串可以使用下面这些方式。
string str1 = "abcdefg"; //str1 = "abcdefg"
string str2("abcdefg"); //str2 = "abcdefg",这里参数的类型是char *c
string str3 = str1; //str3 = "abcdefg"
string str4(str2); //str4 = "abcdefg",这里参数的类型是string &str
//字符填充
string str5(5,'a'); //str5 = "aaaaa"
string str6 = string(5,'a'); //str6 = "aaaaa"
//构造子串
string str7(str1,4); //str7 = "efg",从字符串str1的第5个字符开始到结束
string str8(str1,0,4); //str8 = "abcd",从字符串str1的第0个字符开始,拷贝4个字符
//字符数组
char c1[] = "abcdefgh";
string str9(c1,5); //str9 = "abcde"
string str10("abcdefgh",5); //str10 = "abcde" 注意这里参数"abcdefgh"为字符数组,而不是string对象
特征函数
int length(); int size(); 等效,均可获取字符串的长度。
string str = "abcdefgh";
cout<<str.length()<<endl; //8
cout<<str.size()<<endl; //8
bool empty();——用来检查当前字符串是否为空。
string s;
cout<<s.empty()<<endl; //1
int max_size();
返回的大小是string对象中可存放的最大字符串的长度,很可能和机器本身的限制或者字符串所在位置连续内存的大小有关系。
int capacity();
返回当前容量,即在不分配新的内存空间的前提下它最多可以保存多少元素。
void resize(int len, char c);
把字符串当前大小设置为len,并用字符c填充不足的部分。
赋值assign
string &operator=(const string &s);——把字符串s赋给当前字符串
string str = "abcdefg";
string str1 = str; //str1 = "abcdefg"
string &assign(const char *s);——用c类型字符串s赋值
char c[] = "abcdefg";
string str;
str.assign(c); //str = "abcdefg"
string &assign(const char *s,int n);——用c字符串s开始的n个字符赋值
char c[] = "abcdefg";
string str;
str.assign(c,5); //str = "abcde"
string &assign(const string &s);——把字符串s赋给当前字符串
string str = "abcdefg";
string str1;
str1.assign(str); //str1 = "abcdefg"
string &assign(int n,char c);——用n个字符c赋值给当前字符串
string str;
str.assign(5,'a'); //str = "aaaaa"
string &assign(const string &s,int start,int n);——把字符串s中从start开始的n个字符赋给当前字符串
string str = "abcdefg";
string str1;
str1.assign(str,2,4); //str1 = "cdef"
string &assign(const_iterator first,const_itertor last);//把first和last迭代器之间的部分赋给字符串
string str = "abcdefg";
string str1;
str1.assign(str.begin(),str.end()-2); //str1 = "abcde"
连接append
string &operator+=(const string &s);——把字符串s连接到当前字符串的结尾
string str = "abcdefg";
string str1 = "hijk";
str += str1; //str = "abcdefghijk"
string &append(const char *s);——把c类型字符串s连接到当前字符串结尾
string str = "abcdefg";
char s[] = "hijk";
str.append(s); //str = "abcdefghijk"
string &append(const char *s,int n);——把c类型字符串s的前n个字符连接到当前字符串结尾
string str = "abcdefg";
char s[] = "hijk";
str.append(s,2); //str = "abcdefghi"
string &append(const string &s);——把字符串s连接到当前字符串的结尾,同operator+=()
string str = "abcdefg";
string str1 = "hijk";
str.append(str1); //str = "abcdefghijk"
string &append(const string &s,int pos,int n);——把字符串s中从pos开始的n个字符连接到当前字符串的结尾
string str = "abcdefg";
string str1 = "hijk";
str.append(str1,2,2); //str = "abcdefghijk"
string &append(int n,char c);——在当前字符串结尾添加n个字符c
string str = "abcdefg";
str.append(5,'h'); //str = "abcdefghhhhh"
string &append(const_iterator first,const_iterator last);——把迭代器first和last之间的部分连接到当前字符串的结尾
string str = "abcdefg";
string str1 = "hijk";
str.append(str1.begin()+1,str1.end()); //str = "abcdefgijk"
插入insert
string &insert(int p0, const char *s); ——在p0位置插入字符串s
char c[] = "hhhh";
string str = "abcde";
str.insert(2,c); //str = "abhhhhcde"
string &insert(int p0, const char *s, int n);——在p0位置插入字符串s的前n个字符
char c[] = "hhhh";
string str = "abcde";
str.insert(2,c,3); //str = "abhhhcde"
string &insert(int p0,const string &s);——在p0位置插入字符串s
string str = "abcde";
string str1 = "hhh";
str.insert(3,str1); //str = "abchhhde"
string &insert(int p0,const string &s, int pos, int n);——在p0位置插入字符串s从pos开始的连续n个字符
string str = "abcde";
string str1 = "fgh";
str.insert(3,str1,1,2); //str = "abcghde"
string &insert(int p0, int n, char c);——在p0处插入n个字符c
string str = "abcde";
string str1 = "fgh";
str.insert(3,5,'h'); //str = "abchhhhhde"
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
删除erase
iterator erase(iterator first, iterator last);——删除[first,last)之间的所有字符,返回删除后迭代器的位置
iterator erase(iterator it);——删除it指向的字符,返回删除后迭代器的位置
string &erase(int pos = 0, int n = npos);——删除pos开始的n个字符,返回修改后的字符串
string str = "abcde";
str.erase(1,3); //str = "ae"
查找find
find()函数:查找第一次出现的位置
int find(char c, int pos = 0) const;——从pos开始查找字符c在当前字符串第一次出现的位置
string str = "abchhhhdef";
cout<<str.find('h',0); //3,其中0也可以不写(默认为0)或给出别的数值,下面同理
int find(const char *s, int pos = 0) const;——从pos开始查找字符串s在当前串中第一次出现的位置
string str = "abchhhhdefhhhh";
char c[] = "hhhh";
cout<<str.find(c,0); //3
int find(const char *s, int pos, int n) const;——从pos开始查找字符串s中前n个字符在当前串中第一次出现的位置
string str = "abchhhhdef";
char c[] = "hhde";
cout<<str.find(c,0,2); //3
int find(const string &s, int pos = 0) const;——从pos开始查找字符串s在当前串中第一次出现的位置
string str = "abchhhhdefhhhh";
string str1 = "hhhh";
cout<<str.find(str1,0); //3
rfind()函数:查找最后一次出现的位置,也就是从后向前查找第一次出现的位置
int rfind(char c, int pos = npos) const;——从pos开始从后向前查找字符c在当前串中的第一次出现位置
string str = "abchhhhdef";
cout<<str.rfind('h')<<endl; //6,不给出pos默认从最后一个开始
cout<<str.rfind('h',9)<<endl; //6,也可以给出pos,不过返回的位置是从前向后计算的,以下同理
int rfind(const char *s, int pos = npos) const;——从pos开始从后向前查找字符数组s在当前串中第一次出现的位置
string str = "abchhhhdef";
char c[] = "hhhh";
cout<<str.rfind(c); //3
int rfind(const char *s, int pos, int n = npos) const;——从pos开始从后向前查找字符数组s中前n个字符组成的字符串在当前串中第一次出现的位置
string str = "abchhhhdefhhhh";
char c[] = "hhhh";
cout<<str.rfind(c,9)<<endl; //3
cout<<str.rfind(c,9,2)<<endl; //5
cout<<str.rfind(c,13)<<endl; //10
int rfind(const string &s, int pos = npos) const;——从pos开始从后向前查找字符串s在当前串中第一次出现的位置
string str = "abchhhhdefhhhh";
string str1= "hhhh";
cout<<str.rfind(str1)<<endl; //10
cout<<str.rfind(str1,9)<<endl; //3
find_first_of()函数:在当前字符串中查找第一个与要查找的字符串中任意一个字符匹配的字符,并返回其位置。
注意与find()函数的区别:如果在一个字符串str1中查找另一个字符串str2,如果str1中含有str2中的任何字符,就会查找成功
int find_first_of(char c, int pos = 0) const;——从pos开始查找字符c在当前字符串中第一次出现的位置
string str = "abchhhhdefhhhh";
cout<<str.find_first_of('h')<<endl; //3,默认从0开始
cout<<str.find_first_of('h',4)<<endl; //4,也可指定开始位置,以下同理
int find_first_of(const char *s, int pos = 0) const;——从pos开始查找字符数组s在当前字符串中第一次出现的位置
string str = "abchhhhdefhhhh";
char c[]= "hhd";
cout<<str.find_first_of(c)<<endl; //3
cout<<str.find_first_of(c,5)<<endl; //5,c中任意一个字符在str中出现的第一个位置
int find_first_of(const char *s, int pos, int n) const;——从pos开始查找当前串中第一个在s的前n个字符组成的字符数组中的字符的位置
string str = "abchhhhdefhhhh";
char c[]= "hhbdf";
cout<<str.find_first_of(c,0,3); //1
int find_first_of(const string &s, int pos = 0) const;——从pos开始查找当前字符串中第一个在字符串s中任意一个字符出现的位置
string str = "abchhhhdefhhhh";
string str1= "hhbdf";
cout<<str.find_first_of(str1,0); //1
int find_first_not_of()函数:在字符串中查找第一个与要查找的字符串中的字符都不匹配的字符,返回它的位置
int find_first_not_of(char c, int pos = 0) const;——从pos开始在当前字符串中查找第一个与c字符不匹配的字符的位置
string str = "abchhhhdefhhhh";
cout<<str.find_first_not_of('h')<<endl; //0,默认开始位置0
cout<<str.find_first_not_of('h',5)<<endl; //7,指定开始位置5
int find_first_not_of(const char *s, int pos = 0) const;——从pos开始在当前字符串中查找第一个与字符数组s中的字符都不匹配的字符的位置
string str = "abchhhhdefhhhh";
char c[] = "ahdf";
cout<<str.find_first_not_of(c); //1
int find_first_not_of(const char *s, int pos, int n) const;——从pos开始在字符串中查找第一个与字符数组s中的前n个字符都不匹配的字符的位置
string str = "abchhhhdefhhhh";
char c[] = "hdaf";
cout<<str.find_first_not_of(c,0,2)<<endl; //0
cout<<str.find_first_not_of(c,0,3)<<endl; //1
int find_first_not_of(const string &s,int pos = 0) const;——从pos开始在当前字符串中查找第一个与字符串s中的字符都不匹配的字符的位置
string str = "abchhhhdefhhhh";
string str1 = "hdaf";
cout<<str.find_first_not_of(str1,0); //1
int find_last_of()函数:在当前字符串中查找最后一个(即从后向前查找第一个)与要查找的字符串中任意一个字符匹配的字符,并返回其位置
int find_last_of(char c, int pos = npos) const;——从pos开始在当前字符串中从后向前查找第一个与c相同的字符,并返回其位置
string str = "abchhhhdefhhhh";
cout<<str.find_last_of('h'); //13
int find_last_of(const char *s, int pos = npos) const;——从pos开始在当前字符串中从后向前查找第一个与字符数组s中任意一个字符匹配的字符,并返回其位置
string str = "abchhhhdefhhhh";
char c[] = "daf";
cout<<str.find_last_of(c); //9
int find_last_of(const char *s, int pos, int n = npos) const;——从pos开始在当前字符串中从后向前查找第一个与s的前n个字符组成的字符数组中任意一个字符相匹配的字符的位置
string str = "abchhhhdefhhhh";
char c[] = "daf";
cout<<str.find_last_of(c,13,1); //7
int find_last_of(const string &s,int pos = npos) const;——从pos开始在当前字符串中从后向前查找第一个与字符串s中任意一个字符匹配的字符,并返回其位置
string str = "abchhhhdefhhhh";
string str1 = "daf";
cout<<str.find_last_of(str1); //9
find_last_not_of()函数:在字符串中查找最后一个(即从后向前查找第一个)与要查找的字符串中的字符都不匹配的字符,返回它的位置
int find_last_not_of(char c, int pos = npos) const;——从pos开始在当前字符串中从后向前查找第一个与c不匹配的字符,并返回其位置
string str = "abchhhhdefhhhh";
cout<<str.find_last_not_of('h'); //9
int find_last_not_of(const char *s, int pos = npos) const;——从pos开始在当前字符串中从后向前查找第一个与字符数组s中任意一个字符都不匹配的字符,并返回其位置
string str = "abchhhhdefhhhh";
char c[] = "daf";
cout<<str.find_last_not_of(c)<<endl; //13
cout<<str.find_last_not_of(c,9)<<endl; //8
int find_last_not_of(const char *s, int pos, int n) const;——从pos开始在当前字符串中从后向前查找第一个与s的前n个字符组成的字符数组中任意一个字符都不匹配的字符的位置
string str = "abchhhhdefhhhh";
char c[] = "dafh";
cout<<str.find_last_not_of(c,9,1); //9
int find_last_not_of(const string &s,int pos = npos) const;——从pos开始在当前字符串中从后向前查找第一个与字符串s中任意一个字符都不匹配的字符,并返回其位置
string str = "abchhhhdefhhhh";
string str1 = "dafh";
cout<<str.find_last_not_of(str1); //8
find_last_of和find_last_not_of与find_first_of和find_first_not_of相似,只不过是从后向前查找。
另外以上所有函数查找成功时返回所在位置,失败返回string::npos的值
替换replace
string &replace(int p0, int n0,const char *s);——删除从p0开始的n0个字符,然后在p0处插入串s
string str = "abcdefgh";
char c[] = "hh";
str.replace(1,3,c); //str = "ahhefgh"
string &replace(int p0, int n0, const char *s, int n);——删除p0开始的n0个字符,然后在p0处插入字符串s的前n个字符
string str = "abcdefgh";
char c[] = "hhjk";
str.replace(1,3,c,3); //str = "ahhjefgh"
string &replace(int p0, int n0, const string &s);——删除从p0开始的n0个字符,然后在p0处插入串s
string str = "abcdefgh";
string str1 = "hh";
str.replace(1,3,str1); //str = "ahhefgh"
string &replace(int p0, int n0, const string &s, int pos, int n);——删除p0开始的n0个字符,然后在p0处插入串s中从pos开始的n个字符
string str = "abcdefgh";
string str1 = "hhjk";
str.replace(1,3,str1,1,2); //str = "ahjefgh"
string &replace(int p0, int n0, int n, char c);——删除p0开始的n0个字符,然后在p0处插入n个字符c
string str = "abcdefgh";
str.replace(1,3,4,'h'); //str = "ahhhhefgh"
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)之间的字符串
交换swap
void swap(string &s2); ——交换当前字符串与s2的值
string str = "abcdefgh";
string str1 = "hhjk";
str.swap(str1); //str = "hhjk",str1 = "abcdefgh"
swap(str, str1); //str1 = "hhjk",str = "abcdefgh" 两种写法都可
比较compare
两个字符串自左向右逐个字符相比(按ASCII值大小相比较),直到出现不同的字符或遇’\0’为止。运算符">","<",">=","<=","!="均被重载用于字符串的比较。
bool operator==(const string &s1,const string &s2) const;——比较两个字符串是否相等
string str = "abcdefgh";
string str1 = "abcdefg";
cout<<(str == str1 ? 1 : 0); //0
int compare(const string &s) const;——比较当前字符串和s的大小
string str = "abcdefg";
string str1 = "abcdefghi";
string str2 = "abcdef";
cout<<str.compare(str1)<<endl; //-2
cout<<str.compare(str2)<<endl; //1
int compare(int pos, int n, const string &s) const;——比较当前字符串从pos开始的n个字符组成的字符串与s的大小
string str = "abcdefg";
string str1 = "abcdefghi";
string str2 = "abcdef";
cout<<str.compare(0,6,str1)<<endl; //-3
cout<<str.compare(0,6,str2)<<endl; //0
int compare(int pos, int n, const string &s, int pos2, int n2) const;——比较当前字符串从pos开始的n个字符组成的字符串与s中pos2开始的n2个字符组成的字符串的大小
string str = "abcdefg";
string str1 = "abcdefghi";
string str2 = "abcdef";
cout<<str.compare(0,6,str1,0,7)<<endl; //-1
cout<<str.compare(0,6,str2,0,5)<<endl; //1
int compare(const char *s) const;——比较当前字符串和字符数组s的大小
string str = "abcdefg";
char c1[] = "abcdefghi";
char c2[] = "abcdef";
cout<<str.compare(c1)<<endl; //-2
cout<<str.compare(c2)<<endl; //1
int compare(int pos, int n, const char *s) const;——比较当前字符串从pos开始的n个字符组成的字符串与字符数组s的大小
string str = "abcdefg";
char c1[] = "abcdefghi";
char c2[] = "abcdef";
cout<<str.compare(0,6,c1)<<endl; //-3
cout<<str.compare(0,6,c2)<<endl; //0
int compare(int pos, int n, const char *s, int n1) const;——比较当前字符串从pos开始的n个字符组成的字符串与s中
string str = "abcdefg";
char c1[] = "abccdefgh";
char c2[] = "abcdef";
cout<<str.compare(0,2,c1,2)<<endl; //0
cout<<str.compare(1,3,c2,3)<<endl; //1
说明
本文中所有代码均为自己理解所写,若有错误,欢迎讨论。