子字符串的获取与常见字符操作函数总结

字符串的获取与常见字符操作函数总结"/>

子字符串的获取与常见字符操作函数总结

 先展示一段子字符串获取函数主要使用到下面介绍的strstr。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>using namespace std;int getSubstrFromString(const char *buff, const char *starts, const char *ends, char *result, unsigned int retBufLen)
{unsigned int i = 0;  int ret = 0;char *start = NULL;char *end = NULL;if(NULL == (start = strstr((char *)buff, starts))){cout<< "find start err. buf = " << buff << ", starts = " << starts << endl;ret = -1;goto EXIT;}if(NULL == (end = strstr((char *)buff, ends))){cout<< "find end err. buf = " << buff << ", ends = " << ends << endl;ret = -1;goto EXIT;}if(end <= (start + strlen(starts))){printf(" [%s] ######### Line : %d, find err. start = %p end = %p\n",__FUNCTION__,__LINE__, start, end);cout<< "find end err. buf = " << buff << ", starts = " << starts << ", ends = " << ends << endl;ret = -1;goto EXIT;}/*** 找到的字符串必须小于出参内存长度, 需要保留1个字节设置'\0'*/if((end - start - strlen(starts)) >= retBufLen){printf(" [%s] ######### Line : %d, find err. start = %p end = %p\n",__FUNCTION__,__LINE__, start, end);cout<< "find end err. buf = " << buff << ", starts = " << starts << ", ends = " << ends;ret = -1;goto EXIT;}for(i=0; i<(end - start - strlen(starts)); i++){result[i] = buff[start - buff + strlen(starts) + i];}result[i] = '\0';EXIT:return ret;
}int main()
{char buf[] = "";char stbuf[] = "//";char endbuf[] = "blog";unsigned int len = strlen(buf);char result[64]={0};int ret = getSubstrFromString(buf,stbuf,endbuf,result,len);cout<<"main ret:"<<ret<<"result:"<<result<<endl;return 0;
}

运行结果：

huqin@ubuntu:/mnt/hgfs/share/code/2021/mon9/week3$ g++ getSubch.cpp -o getSubch huqin@ubuntu:/mnt/hgfs/share/code/2021/mon9/week3$ ls getSubch getSubch.cpp huqin@ubuntu:/mnt/hgfs/share/code/2021/mon9/week3$ ./getSubch main ret:0result:ubuntu/ 

1.strlen()函数

1. 函数声明原型：
2. 函数功能：

计算指定的字符串string的长度。

strlen函数实现：

#include
#include
#includesize_t strlen(const char *string);
size_t my_strlen1(const char* string)
{assert(string);size_t count = 0;while (*string++){count++;}return count;
}
size_t my_strlen2(const char* string)
{assert(string);if (*string == '\0')return 0;return 1 + my_strlen2(string + 1);
}
int main()
{char s[] = "abcdefg";printf("%d\n", my_strlen2(s));system("pause");return 0;
}

2.strcpy函数

原型：strcpy(str1,str2);

功能：将字符串str2复制到字符串str1中，并覆盖str1原始字符串，可以用来为字符串变量赋值

返回：str1

注意：1）字符串str2会覆盖str1中的全部字符，2）字符串str2的长度不能超过str1

#include
#include
#includechar* my_strcpy(char* dest, const char* src)
{assert(dest);assert(src);char* ptr = dest;while (*src){*dest++ = *src++;}*dest = *src;return ptr;
}
int main()
{char s1[] = "abefg";char s2[] = "cdefg";printf("%s\n", my_strcpy(s1, s2));system("pause");return 0;
}

3.strncpy函数

原型：strncpy(str1,str2,n);

功能：将字符串str2中的前n个字符复制到字符串str1的前n个字符中

返回：str1

注意：1）不会清除str1中全部字符串，只会改变前n个字符串，2）n不能大于字符串str1、str2的长度

char str1[] = "We are csdn!";

char str2[] = "Hello!";

strncpy(str1, str2, 3);

printf("str1 = %s\n", str1); //str1 = Helare csdn!

4.strcat函数

原型：strcat(str1,str2);

功能：将字符串str2添加到字符串str1的尾部，也就是拼接两个字符串

原型2：strncat(str1,str2,n);

功能2：将字符串str2的前n个字符添加到字符串str1的尾部

返回：str1

注意：拼接之后的长度不能超过字符串数组str1的长度

#include<stdio.h>#include<string.h>int main(){char str1[20] = "We are friend";char str2[] = "sure!";printf("%d\n",strlen(str1)); printf("%d\n",sizeof(str1)); strcat(str1, str2);printf("str1 = %s\n", str1); printf("%d\n",strlen(str1)); printf("%d\n",sizeof(str1)); }

5.strcmp函数

原型：strcmp(str1,str2);

功能：比较两个字符串，如果两个字符串相等，则返回0；

若str1大于str2（对于大于的理解，是指从两个字符串的第一个字符开始比较，若两个字符相同，则继续比较，若发现两个字符不相等，且str1中该字符的ASCII码大于str2中的，则表示str1大于str2），返回一个正数（这个正数不一定是1）；

若str1小于str2，返回一个负数（不一定是-1）；

若字符串str1的长度大于str2，且str2的字符与str1前面的字符相同，则也相当于 str1大于str2处理

原型2：strncmp(str1,str2,n);

功能2：比较两个字符串的前n个字符

原型3：stricmp(str1,str2); （在Windows中使用stricmp，在Linux中使用strcasecmp）

功能3：忽略两个字符串中的大小写比较字符串，也就是对大小写不敏感

#include<stdio.h>#include<string.h>int main(){char str1[] = "Wearecsdn!";char str2[] = "Wearecsdn!";char str3[] = "Wearea!";char str4[] = "Wearef!";char str5[] = "Weare";char str6[] = "weAreCsdn!";int cmp1 = strcmp(str1, str2); //cmp1=0int cmp2 = strcmp(str1, str3); //cmp2=1int cmp3 = strcmp(str1, str4); //cmp3=-1int cmp4 = strcmp(str1, str5); //cmp4=1printf("%d\n",cmp1); //cmp1=0printf("%d\n",cmp2); //cmp2=1printf("%d\n",cmp3); //cmp3=-1printf("%d\n",cmp4); //cmp4=1printf("------------------------\n");int cmp5 = strncmp(str1, str2, 5); //cmp5=0int cmp6 = strncmp(str1, str3, 5); //cmp6=0int cmp7 = strncmp(str1, str4, 5); //cmp7=0int cmp8 = strncmp(str1, str5, 5); //cmp8=0int cmp9 = strncmp(str1, str5, 6); //cmp9=1printf("%d\n",cmp5);printf("%d\n",cmp6);printf("%d\n",cmp7);printf("%d\n",cmp8);printf("%d\n",cmp9);printf("------------------------\n");int cmp10 = strcmp(str1, str6); //cmp10=0int cmp11 = strcasecmp(str1, str6); //cmp11=0printf("%d\n",cmp10);printf("%d\n",cmp11);}

6.strchr函数

原型：strchr(str,c)；

功能：在str字符串中查找首次出现字符c的位置（从字符串的首地址开始查找）

原型2：strrchr(str,c);

功能2：在字符串str中从后向前开始查找字符c首次出现的位置

原型3：strstr(str1,str2);

功能3：在字符串str1中查找字符串str2的位置，若找到，则返回str2第一个字符在str1中的位置的指针，若没找到，返回NULL

其原型为：char * strchr (const char *str, int c);

【参数】str 为要查找的字符串，c 为要查找的字符。

strchr() 将会找出 str 字符串中第一次出现的字符 c 的地址，然后将该地址返回。

注意：字符串 str 的结束标志 NUL 也会被纳入检索范围，所以 str 的组后一个字符也可以被定位。

【返回值】如果找到指定的字符则返回该字符所在地址，否则返回 NULL。

返回的地址是字符串在内存中随机分配的地址再加上你所搜索的字符在字符串位置。设字符在字符串中首次出现的位置为 i，那么返回的地址可以理解为 str + i。

提示：如果希望查找某字符在字符串中最后一次出现的位置，可以使用 strrchr() 函数。

【实例1】查找字符5首次出现的位置。

#include <stdio.h>#include <stdlib.h>#include <string.h>int main(){char *s = "0123456789012345678901234567890";char *p;p = strchr(s, '5');printf("%ld\n", s);printf("%ld\n", p);system("pause");return 0;}

输出结果：

12016464

12016469

【实例2】

#include<stdio.h>#include<string.h>int main(){char str1[] = "Wearecsdn!";char ch = 'e';char str2[] = "are";char* ret1;char* ret2;char* ret3;ret1 = strchr(str1, ch); //ret1 = earecsdn!ret2 = strrchr(str1, ch); //ret2 = ecsdn!ret3 = strstr(str1, str2); //ret3 = arecsdn!int r1 = ret1 - str1; //r1 = 1int r2 = ret2 - str1; //r2 = 4int r3 = ret3 - str1; //r3 = 2printf("%s\n%s\n%s\n", ret1, ret2, ret3);printf("%d\n%d\n%d\n", r1, r2, r3);}

7.strpbrk函数

原型：strpbrk(str1,str2);

功能：依次检验字符串 str1 中的字符，当被检验字符在字符串 str2 中也包含时，则停止检验，并返回该字符位置

返回：第一个两个字符串中都包含的字符在str1中的位置的指针

char str1[] = "We12are34csdn!";char str2[] = "32";char* ret1;ret1 = strpbrk(str1, str2); //*ret1 = 2int r1 = ret1 - str1; //r1 = 3printf("%c\n", *ret1);printf("%d\n", r1);

示例二：

#include < string .h >#include < stdio.h >int main(){char *str1="please try again,sky2098!";char *str2="Hello,I am sky2098,I like writing!";char *strtemp;strtemp=strpbrk(str1,str2); //搜索进行匹配printf("Result is: %s ",strtemp);return 0;}

8.strspn函数

原型：strspn(str1,str2);

功能：检索字符串str1中第一个不在字符串str2中出现的字符下标

返回：返回 str1 中第一个不在字符串 str2 中出现的字符下标，一个int整数值

char str1[] = "We12are34csdn!";char str2[] = "We32are1";int len;len = strspn(str1, str2); //len = 8printf("%d\n", len);

9.strcspn函数

原型：strcspn(str1,str2);

功能：检索字符串str1开头连续有几个字符都不含字符串str2中的字符

返回：返回 str1 开头连续都不含字符串 str2 中字符的字符数，一个int整数值

char str1[] = "We12are34csdn!";char str2[] = "32";int len;len = strcspn(str1, str2); //len = 3printf("%d\n", len);

***************************************************************************************************

strpbrk、strcspn、strspn三个函数的区别：strpbrk是在字符串str1中查找第一个在字符串str2中也包含的字符的位置，返回该字符在str1中的位置指针，而strcspn返回的是该字符在str1中的偏移位置，strspn是在str1中查找第一个在str2不包含的字符的位置，返回该字符在str1中的偏移位置

***************************************************************************************************

10.strtod函数

原型：double strtod ( const char *nptr, char **endptr);

功能：strtod()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，到出现非数字或字符串结束时('\0')才结束转换，并将结果返回。

若endptr不为NULL，则会将遇到不合条件而终止的nptr中的字符指针由endptr传回。参数nptr字符串可包含正负号、小数点或E(e)来表示指数部分。如123.456或123e-2。

#include <stdio.h>#include <stdlib.h>int main(){int index=0;char *endpt=NULL;char a[]="1234+9";printf("a=%1f\n",strtod(a,&endpt));index=endpt-a;printf("index=%d",index);return 0;}

执行结果如下：

a=1234.000000,index=4

11.atoi、atof、atol函数

atoi(str); //字符串转换到int整型

atof(str); //字符串转换到double浮点数

atol(str); //字符串转换到long整形

#include<stdio.h>//#include<string.h>#include<stdlib.h>int main(){char str[] = "123.34";int chint = atoi(str); //chint = 123double chdouble = atof(str); //chdouble = 123.340000long int chlong = atol(str); //chlong = 123printf("%d\n%f\n%ld\n", chint, chdouble, chlong);}

string.h中还提供以下几种常用字符串操作函数：

1）void *memchr(const void *str, int c, size_t n) 在参数 str 所指向的字符串的前 n 个字节中搜索第一次出现字符 c（一个无符号字符）的位置，相似于strchr函数

2）int memcmp(const void *str1, const void *str2, size_t n)) 把存储区 str1 和存储区 str2 的前 n 个字节进行比较，相似于strncmp函数

3）void *memcpy(void *str1, const void *str2, size_t n) 从存储区 str2 复制 n 个字符到存储区 str1，相似于strncpy函数

4）void *memmove(void *str1, const void *str2, size_t n) 从 str2 复制 n 个字符到 str1，但是在重叠内存块这方面，memmove() 是比 memcpy() 更安全的方法。如果目标区域和源区域有重叠的话，memmove() 能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中，复制后源区域的内容会被更改。如果目标区域与源区域没有重叠，则和 memcpy() 函数功能相同

5）void *memset(void *str, int c, size_t n) 复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符

#include<stdio.h>#include<string.h>int main(){char str1[] = "We are csdn!";char* str2="ddd";char* res=(char*) memcpy(str1,str2,2);printf("%s\n",res); //dd are csdn!memset(str1,'t',3);printf("%s\n",str1); //tttare csdn!}

6）字符串切割函数

函数原型：char *strtok(char *s, char *delim);

函数功能：把字符串s按照字符串delim进行分割，然后返回分割的结果。

函数使用说：

1.strtok函数的实质上的处理是，strtok在s中查找包含在delim中的字符并用NULL(’/0′)来替换,直到找遍整个字符串。这句话有两层含义：（1）每次调用strtok函数只能获得一个分割单位。（2）要获得所有的分割单元必须反复调用strtok函数。

2.strtok函数以后的调用时的需用NULL来替换s.

3.形参s(要分割的字符串)对应的变量应用char s[]=”….”形式，而不能用char *s=”….”形式。

例子如下：

#include <stdio.h>#include <string.h>int main(void){char buf[]=”Golden Global View”;char* token = strtok( buf, " ");while( token != NULL ){printf( ”%s “, token );token = strtok( NULL, ” “);}return 0;}

其结果为：

Golden

Global

View

但是如果我们把char buf[]=”Golden Global View”;换成char *buf=”Golden Global View”; 则会出错，原因是如果分配的大小一样的前提下char *p和char b[]也是有区别的，

char *p=”abc”;

char b[]=”abc”;

当这两个语句编译后，编译器会将“abc”放在常量区中，而strtok(char *s, char *delim)函数是在s中查找包含在delim中的字符并用NULL(’/0′)来替换,直到找遍整个字符串。这句话就能体现指针和数组的区别：既然查找就要p++/b++。 要替换成（‘/0’）,那么就要对*p/*b赋值

*p=’/0’;

*b=’/0’;

p指针是指向常量字符串的，对*p操作就是对字符串操作，这显然会编译不通过的。

b是字符数组的首地址，这个数组里面的元素是‘a’、’b’、’c’、’/0’,和字符串“abc”看上去是一样，不过并不是同一个。相当于，b数组里可以存放其他东西’1’、’2’、’3’、’/0’,只不过在编译到char b[]=”abc”;后给这个b数组里的元素值改变了，所以对*b的操作并不影响字符串。

如果我们把token = strtok( NULL, ” “);换成token = strtok( buf, ” “);则while循环会成为一个无限循环，而输出的结果就只为：Golden。我的解释原因如下： 在strtok函数体中有一个char 类型的指针（假设为 char *p）,它的作用就是令p=s,用于保存s的起始地址。由于在随后的处理中指针p的值会一直保存（C语言中指针的特点），因此在以后的strtok调用中用NULL来代替s的原因就是防止p被重新赋值而指向s的起始地址，从而可以保证p可以指向s的其他位置，直到最后分割完整个字符串。 但是如果用s来代替NULL，那么每次调用strtok时，p就会指向s的初始地址，从而只能获得第一个分割出来的字串，如上面的例子中while会是一个无限循环，而输出的结果只能是“Golden”。

函数strtok_r是函数strtok的可重入版本，也即线程安全版本。

//函数原型
char *strtok_r(char *str, const char *delim, char **saveptr);

 其中：
       char *str是被分割字符串，如上面例子中的"hello, jason, please come here"，第一次调用函数strtok_r时此指针一定不能为空，连续分割同一个字符串时，第一调用之后的调用需将str设置为NULL。
       const char *delim是分隔符，也是个字符串指针，例如上面例子中的","或者" "。
       char **saveptr是一个供内部使用的指针，用于保存上次分割剩下的字串。
       返回值是个指针，用于返回从被分割字符串中得到的第一个目标子串。
注意：虽然函数strtok_r可以将一个字符串进行分割，但是每次分割只能得到第一个被分割的字串

举例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>int main()
{char pSrc[] = "we/are/family;/i/am/from/china";char* pToken = NULL;char* pSave = NULL;char* pDelimiter = "/";pToken = strtok_r(pSrc, pDelimiter, &pSave);printf("Begin:\n");while(pToken){printf("   pToken[%s]; pSave[%s]\n",pToken,pSave);pToken = strtok_r(NULL, pDelimiter, &pSave);}printf("End!\n");return 0;
}

运行结果：

huqin@ubuntu:/mnt/hgfs/share/code/2021/mon11/week5$ ./strtok-r
Begin:pToken[we]; pSave[are/family;/i/am/from/china]pToken[are]; pSave[family;/i/am/from/china]pToken[family;]; pSave[i/am/from/china]pToken[i]; pSave[am/from/china]pToken[am]; pSave[from/china]pToken[from]; pSave[china]pToken[china]; pSave[]
End!

 

7）.字符串中查找字串

strstr()函数用来检索子串在字符串中首次出现的位置，其原型为：

char *strstr( char *str, char * substr );

【参数说明】str为要检索的字符串，substr为要检索的子串。

【返回值】返回字符串str中第一次出现子串substr的地址；如果没有检索到子串，则返回NULL。

【函数示例】strstr()函数的使用。

#include<stdio.h>#include<string.h>int main(){// 也可以改成 char str[] = "/";char *str = "/";char *substr = "see";char *s = strstr(str, substr);printf("%s\n", s);return 0;}

运行结果：

see.xidian.edu/cpp/u/xitong/

8）.获取字符串指定位置间的字符串

str.substr(startpos, length);

其中 startpos 是起始字符的序号，length 是[从 startpos 开始]取的字符串长度（包括

startpos ）。

如果要取得 str 中序号 m 到 n 之间（不包括n）的子字符串需要用

//str.substr(m, n-m);#include<string>#include<iostream>using namespace std;main(){string s("12345asdf");string a=s.substr(0,4); //获得字符串s中 从第0位开始的长度为4的字符串cout<<a<<endl;}

输出结果为:

1234

9).c++中string提供的字符查找函数：

string中 find()的应用 （ rfind() 类似，只是从反向查找）

原型如下：

（1）size_t find (const string& str, size_t pos = 0) const; //查找对象-- string类对象

（2）size_t find (const char* s, size_t pos = 0) const; //查找对象-- 字符串

（3）size_t find (const char* s, size_t pos, size_t n) const; //查找对象-- 字符串的前n个字符

（4）size_t find (char c, size_t pos = 0) const; //查找对象-- 字符

结果：找到 -- 返回 第一个字符的索引

没找到--返回 string::npos

string key = it->first; int mark = key.find("_"); //找到字符所在位置(正向查找) string endtime = key.substr(0, mark);//拿到完成时间 guint32 finishtime = stoi(endtime);//转为数字 string infoflag= key.substr(mark+1,key.size());//拿到信息标志（什么信息）

本文借鉴了很多资料和自己使用总结留下作为记录。