目录
4、stricmp(strcmpi)：字符串比较函数(不区分字母大小写)
6、strnicmp(strncmpi)：字符串子串比较函数(不区分字母大小写)
1、memcmp：数据比较函数(区分字母大小写)
函数原型及源码：int memcmp(const void *buffer1,const void *buffer2,int count);
int memcmp(const void *buffer1,const void *buffer2,int count)
{
if (!count)
return(0);
while ( --count && *(char *)buffer1 == *(char *)buffer2)
{
buffer1 = (char *)buffer1 + 1;
buffer2 = (char *)buffer2 + 1;
}
return( *((unsigned char *)buffer1) - *((unsigned char *)buffer2) );
}
函数功能：把存储区 buffer1和存储区 buffer2的前count个字节的码值进行逐个比较，比较过程区分大小写，即‘a’大于‘A’。
返回值：当buffer1中字符的码值大于、等于、小于buffer2相同位置的字符码值时，分别返回大于、等于、小于0的值。
例：
char *buf1 = "123456\n";
char *buf2 = "123456\n";
char *buf3 = "123455\n";
char *buf4 = "123457\n";
int rtn;
rtn = memcmp(buf1,buf2,10);
printf("src1等于src2:%d\n", rtn);
rtn = memcmp(buf1, buf3, 10);
printf("src1大于src2:%d\n", rtn);
rtn = memcmp(buf1, buf4, 10);
printf("src1小于src2:%d\n", rtn);执行结果：
2、 memicmp：数据比较函数(不区分字母大小写)
函数原型及源码：int memicmp(const void *buffer1,const void *buffer2,int count)；
#define CHRTOLOW(p) (((p) >= 'A'&& (p) <= 'Z') ? ((p) + 0x20) : (p))
int memicmp(const void *buffer1, const void *buffer2, int count)
{
int f = 0;
int l = 0;
while (count--)
{
if ((*(unsigned char *)buffer1 == *(unsigned char *)buffer2) ||
((f = CHRTOLOW(*(unsigned char *)buffer1)) == (l = CHRTOLOW(*(unsigned char *)buffer2))))
{
buffer1 = (char *)buffer1 + 1;
buffer2 = (char *)buffer2 + 1;
}
else
break;
}
return (f - l);
}函数功能：把存储区 buffer1和存储区 buffer2的前count个字节的码值进行逐个比较，比较过程不区分字母大小写，即‘a’等于‘A’。
返回值：当s1中字符的码值大于、等于、小于s2相同位置的字符码值时，分别返回大于、等于、小于0的值。
例：
char *buf1 = "abcde\n";
char *buf2 = "ABCDE\n";
char *buf3 = "abcdG\n";
char *buf4 = "abcdA\n";
int rtn;
rtn = memicmp(buf1, buf2, 5);
printf("src1等于src2:%d\n", rtn);
rtn = memicmp(buf1, buf3, 5);
printf("src1大于src2:%d\n", rtn);
rtn = memicmp(buf1, buf4, 5);
printf("src1小于src2:%d\n", rtn);执行结果：
3、strcmp：字符串比较函数(区分字母大小写)
函数原型及源码：int strcmp (const char *str1,const char * str2)
int strcmp(const char* str1, const char* str2)
{
int ret = 0;
while(!(ret=*(unsigned char*)str1-*(unsigned char*)str2) && *str1)
{str1++;str2++}
if (ret < 0){return -1;}
else if (ret > 0)
{return 1;}
return 0;
}
函数功能：把存储区 str1和存储区 str2的字符串的码值进行逐个比较，只对字符串比较，比较过程区分大小写，即‘a’大于‘A’。
返回值：当str1中字符的码值大于、等于、小于str2相同位置的字符码值时，分别返回大于、等于、小于0的值。
例
char *buf1 = "ABCDEF\n";
char *buf2 = "ABCDEF\n";
char *buf3 = "ABCDEE\n";
char *buf4 = "abcdef\n";
int rtn;
rtn = strcmp(buf1, buf2);
printf("src1等于src2:%d\n", rtn);
rtn = strcmp(buf1, buf3);
printf("src1大于src2:%d\n", rtn);
rtn = strcmp(buf1, buf4);
printf("src1小于src2:%d\n", rtn);执行结果
4、stricmp(strcmpi)：字符串比较函数(不区分字母大小写)
函数原型及源码：int stricmp(const char *str1, const char *str2)
int stricmp(const char *str1, const char *str2)
{
int ch1, ch2;
do
{
if ( ((ch1 = (unsigned char)(*(str1++))) >= 'A') &&(ch1 <= 'Z') )
ch1 += 0x20;
if ( ((ch2 = (unsigned char)(*(str2++))) >= 'A') &&(ch2 <= 'Z') )
ch2 += 0x20;
} while (ch1&&(ch1 == ch2));
return(ch1- ch2);
}
函数功能：其功能是把存储区 str1和存储区 str2的字符串的码值进行逐个比较，与只能对字符串比较，比较过程不区分大小写，即‘a’等于‘A’。
返回值：当str1中字符的码值大于、等于、小于str2相同位置的字符码值时，分别返回大于、等于、小于0的值。
例：
char *buf1 = "abcde\n";
char *buf2 = "ABCDE\n";
char *buf3 = "abcdD\n";
char *buf4 = "abcdf\n";
int rtn;
rtn = stricmp(buf1, buf2);
printf("src1等于src2:%d\n", rtn);
rtn = stricmp(buf1, buf3);
printf("src1大于src2:%d\n", rtn);
rtn = stricmp(buf1, buf4);
printf("src1小于src2:%d\n", rtn);执行结果
5、strncmp：字符串子串比较函数(区分字母大小写)
函数原型及源码：int strncmp (char *str1,char * str2, int count)
int strncmp(const char *str1,const char *str2,int count)
{
if (!count)
return(0);
while (--count && *str1&& *str1== *str2)str1++,str2++;
return( *(unsigned char *)str1- *(unsigned char *)str2);
}函数功能：其功能是把存储区 str1和存储区 str2的字符串前count的码值进行逐个比较，与只能对字符串比较，比较过程区分大小写，即‘a’大于‘A’。
返回值：当str1中字符的码值大于、等于、小于str2相同位置的字符码值时，分别返回大于、等于、小于0的值。
例：
char *buf1 = "ABCDEFg\n";
char *buf2 = "ABCDEFh\n";
char *buf3 = "ABCDEE\n";
char *buf4 = "abcdef\n";
int rtn;
rtn = strncmp(buf1, buf2,6);
printf("前6字符src1等于src2:%d\n", rtn);
rtn = strncmp(buf1, buf3, 6);
printf("前6字符src1大于src2:%d\n", rtn);
rtn = strncmp(buf1, buf4, 6);
printf("前6字符src1小于src2:%d\n", rtn);输出结果
6、strnicmp(strncmpi)：字符串子串比较函数(不区分字母大小写)
函数原型及源码：int strnicmp(const char *str1,const char *str2,int count)
int strnicmp(const char *str1,const char *str2,int count)
{
int ch1, ch2;
do
{
if ( ((ch1 = (unsigned char)(*(str1++))) >= 'A') &&(ch1 <= 'Z') )
ch1 += 0x20;
if ( ((ch2 = (unsigned char)(*(str2++))) >= 'A') &&(ch2 <= 'Z') )
ch2 += 0x20;
} while ( --count && ch1 && (ch1 == ch2) );
return (ch1 - ch2);
}
函数功能：其功能是把存储区 str1和存储区 str2的字符串前count的码值进行逐个比较，与只能对字符串比较，比较过程不区分大小写，即‘a’等于‘A’。
返回值：当str1中字符的码值大于、等于、小于str2相同位置的字符码值时，分别返回大于、等于、小于0的值。
例：
char *buf1 = "abcdeF\n";
char *buf2 = "ABCDEF\n";
char *buf3 = "abcdGF\n";
char *buf4 = "abcdAF\n";
int rtn;
rtn = strnicmp(buf1, buf2, 5);
printf("前5字符src1等于src2:%d\n", rtn);
rtn = strnicmp(buf1, buf3, 5);
printf("前5字符src1大于src2:%d\n", rtn);
rtn = strnicmp(buf1, buf4, 5);
printf("前5字符src1小于src2:%d\n", rtn);执行结果：
7、memcpy： 数据拷贝函数(不可用于重叠存储)
函数原型及源码：void *memcpy(void *dst,const void *src,int count)
void * memcpy(void *dst,const void *src,int count)
{
void * ret = dst;
while (count--)
{
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
return(ret);
}
函数功能：从src所指的存储中复制count个字节数据到dst所指的存储中。但是，如果这种复制发生在重叠对象之间，其行为是不可预知的。
返回值：目标数据地址dst
注意事项：如果复制过程中发生在重叠对象之间，其行为是不可预知的
例：
char *buf1 = "abcdeF";
char buf2[10] = "*********";
char buf3[10] = "abcdefg";
char *rtn;
rtn = memcpy(&buf2[0], buf1,5);
printf("拷贝5个字符:%s\n", rtn);
rtn = memcpy(&buf3[2], &buf3[0], 7);
printf("字符后移2位(重叠):%s\n", rtn);输出结果
8、memccpy： 数据拷贝函数(遇指定字符编码停止)
函数原型及源码：void * memccpy(void *dest, const void *src, int c, int count)
void * memccpy(void *dest,const void *src,int c,int count)
{
while ( count && (*((char *)(dest = (char *)dest + 1) - 1) =
*((char *)(src = (char *)src + 1) - 1)) != (char)c )
count--;
return(count ? dest : NULL);
}
函数功能：由src所指内存区域复制不大于count个字节到dest所指内存区域，如果遇到字符c则停止复制。
返回值：返回指向字符ch后的第一个字符的指针(复制的数据包含c)，如果src前n个字节中不存在ch则返回NULL。
例
char *buf1 = "abcdeF";
char buf2[10] = "123456";
char *rtn;
rtn = memccpy(&buf2[0], buf1,'b',5);
printf("拷贝5个字符遇b结束:%s\n", buf2);
printf("拷贝5个字符遇b结束,返回位置:%s\n", rtn);执行结果
9、memmove： 数据拷贝函数(可用于重叠存储)
函数原型及源码：void *memmove(void *dst, const void * src, size_t count);
void *memmove(void *dst, const void * src, size_t count)
{
assert((dst != NULL) && (src != NULL));
char *tmp_dst = (char *)dst;
char *tmp_src = (char *)src;
if (tmp_dst + count < src || tmp_src + count < dst)
{
while (count--)
*tmp_dst++ = *tmp_src++;
}
else
{
tmp_dst += count - 1;
tmp_src += count - 1;
while (count--)
*tmp_dst-- = *tmp_src--;
}
return dst;
}函数功能：从src所指内存区域复制count个字节到临时缓存，再由临时缓存复制到dest所指内存区域。当对象重叠时，该函数仍能正确执行。
返回值：目标地址dst
例
char *buf1 = "abcdeF";
char buf2[10] = "*********";
char buf3[10] = "abcdefg";
char *rtn;
rtn = memmove(&buf2[0], buf1,5);
printf("拷贝5个字符:%s\n", rtn);
rtn = memmove(&buf3[2], &buf3[0], 7);
printf("字符后移2位(重叠):%s\n", rtn);
10、strcpy：字符串拷贝函数
函数原型及源码： char * strcpy(char * dst, const char * src);
char * strcpy(char * dst, const char * src)
{
char *cp = dst;
while( *cp++ = *src++ ) ;
return( dst );
}
函数功能：把字符串src中的内容拷贝到字符串dest中(包含src最后的'\0')，使两个字符串的内容相同。
返回值：指向字符串dest的地址
例：代码简单，省略例程。
11、strncpy：字符串子串拷贝函数
函数原型及源码：char *strncpy(char *dest, const char *source, int count)
char *strncpy(char *dest, const char *source, int count)
{
char *p = dest;
while (count && (*p++ = *source++)) count--;
while(count--)
*p++ = '/0';
return(dest);
}函数功能：也就是把字符串source中的前count个字符拷贝到字符串dest中。
返回值：指向字符串dest的指针
例：与memcpy功能相似，但是只对字符串进行操作，可参照memcpy的实例。
12、strdup：字符串新建拷贝函数
函数原型及源码：char *strdup(const char *str)
char *strdup(const char *str)
{
char *p;
if (!str)
return(NULL);
if (p = malloc(strlen(str) + 1))
return(strcpy(p,str));
return(NULL);
}
函数功能：将str指向的字符串拷贝到一块新分配的存储空间，其内部使用动态分配内存技术实现的，分配给字符串的空间来自于当前所用内存模式制定的堆。
返回值：返回指向含有该串拷贝的存储区。
注意事项：该函数用到了动态内存分配malloc，为了避免内存溢出，当使内存用完成后，必须调用free函数进行内存回收。
例：
char *buf1 = "abcdeF";
char *rtn;
rtn = strdup(buf1);
printf("动态内存:%s\n", rtn);
// 使用完释放
free(rtn);执行结果
13、memchr：字符搜索函数
函数原型及源码：extern void *memchr(const void * buffer,int ch,int count)
void * memchr(const void * buffer,int ch,int count)
{
while ( count && (*(unsigned char *)buffer != (unsigned char)ch) )
{
buffer = (unsigned char *)buffer + 1;
count--;
}
return(count ? (void *)buffer : NULL);
}
函数功能：在数组buffer的前count个字节中搜索字符 ch。
返回值：如果搜到字符 ch，返回ch在buf中第一次出现的地址。反之，返回NULL。
例：
char *buf = "ABCDEFGHIJK\n";
char *p;
// 搜到
p = memchr(buf, 'K', strlen(buf));
printf("OK-%s", p);
// 搜不到
p = memchr(buf, 'M', strlen(buf));
printf("NO-%d", p);运行结果：
14、memrchr：字符逆向搜索函数
函数原型及源码：void * memrchr(const void * buffer,int ch,int count)
void * memrchr(const void * buffer,int ch,int count)
{
int i=0;
while(*(unsigned char *)buffer)
{
((unsigned char *)buffer)++;
i++;
}
count=count<i?count:i;
while(count&&(*(unsigned char *)buffer!=(unsigned char)ch))
{
buffer = (unsigned char *)buffer- 1;
count--;
}
return(count ? (void *)buffer : NULL);
}函数功能：在字符串中buffer中从后向前搜索ch，搜索长度不超过count个字符。
返回值：如果搜到字符 ch，返回ch在buf中第一次出现的地址。反之，返回NULL。
例：
char buf[20] ="123456789";
char *rtn;
rtn = memrchr(buf,'7',10);
printf("返回值：%s\n", rtn);执行结果
15、strchr：字符串中字符首次匹配函数
函数原型及源码：char *strchr(const char *str, int ch)
char *strchr(const char *str, int ch)
{
while (*str && *str != (char)ch)
str++;
if (*str == (char)ch)
return((char *)str);
return(NULL);
}
函数功能：从前向后，在字符串str中查找字符ch第一次出现的位置。
返回值：如果搜到字符 ch，返回ch在buf中第一次出现的地址。反之，返回NULL。
例：
char *buf = "ABCDEFGHIJK\n";
char *p;
// 搜到
p = strchr(buf, 'K', strlen(buf));
printf("OK-%s", p);
// 搜不到
p = strchr(buf, 'M', strlen(buf));
printf("NO-%d", p);执行结果
16、strrchr：字符串中字符末次匹配函数
函数原型及源码：char *strrchr(char *str, char ch);
char * strrchr(const char * str,int ch)
{
char *p = (char *)str;
while (*str) str++;
while (str-- != p && *str != (char)ch);
if (*str == (char)ch)
return( (char *)str );
return(NULL);
}
函数功能：从后向前，在字符串str中查找字符ch第一次出现的位置。
返回值：如果搜到字符 ch，返回ch在buf中第一次出现的地址。反之，返回NULL。
例：
char *buf = "ABCABCABC\n";
char *p;
// 搜到
p = strrchr(buf, 'A', strlen(buf));
printf("OK-%s", p);
// 搜不到
p = strrchr(buf, 'M', strlen(buf));
printf("NO-%d", p);执行结果
17、strstr：字符串匹配函数
函数原型及源码：char *strstr(char *s1, char *s2);
char *strstr(const char *s1,const char *s2)
{
if (*s1 == 0)
{
if (*s2) return (char *) NULL;
return (char *) s1;
}
while (*s1)
{
size_t i;
i = 0;
while (1)
{
if (s2[i] == 0) {return (char *) s1;}
if (s2[i] != s1[i]) {break;}
i++;
}
s1++;
}
return (char *) NULL;
}
函数功能：在字符串s1中查找第一次出现字符串s2的位置。
返回值：如果找到匹配字符串，返回第一次匹配字符串的指针；否则，返回NULL
char *buf = "abcABCabc\n";
char *p;
// 搜到
p = strstr(buf, "ABC");
printf("OK-%s", p);
// 搜不到
p = Mstrstr(buf, "MLN");
printf("NO-%d", p);执行结果
18、strspn：字符集匹配函数
函数原型及源码：int strspn(char *s1, char *s2);
int strspn(const char *s1 ,const char *s2)
{
const char *s = s1;
const char *p;
while (*s1)
{
for (p = s2; *p; p++)
{
if (*s1 == *p)
break;
}
if (*p == '/0') break;
s1++;
}
return s1 - s;
}
函数功能：在字符串s1中查找第一个不属于s2字符集合的下标，顺序为从前向后。换句话说，若果返回值为7，表示字符串s1的前7个字符都在s2字符集合中。
返回值：所找到的字符在字符串s1中段的相对位置(下标)。
例：
char *buf = "0123456789";
char *buf1 = "1234567abc456";
int rtn;
// 找到字符串中第一个不是数字的位置
rtn = strspn(buf1, buf);
printf("找到字符串中第一个不是数字的位置:%d", rtn);
19、strcspn：字符集逆匹配函数
函数原型及源码：int strcspn(char *s1, char *s2);
int strcspn(const char *s1 ,const char *s2)
{
const char *s = s1;
const char *p;
while (*s1)
{
for (p = s2; *p; p++)
{
if (*s1 == *p)
break;
}
if (*p) break;
s1++;
}
return s1 - s;
}
函数功能：在字符串s1中查找第一个属于s2字符集合的下标，顺序为从前向后。换句话说，若果返回值为6，表示字符串s1的前6个字符都不在s2字符集合中。。
返回值：所找到的字符在字符串s1中段的相对位置(下标)
char *buf = "0123456789";
char *buf1 = "abcdfe123abcdfe";
int rtn;
// 找到字符串中第一个数字的位置
rtn = strcspn(buf1, buf);
printf("找到字符串中第一个数字的位置:%d", rtn);
20、strpbrk：字符集字符匹配函数
函数原型及源码：char *strpbrk(char *s1, char *s2);
char * strpbrk(const char *s1 ,const char *s2)
{
const char *c = s2;
if (!*s1)
return (char *) NULL;
while (*s1)
{
for (c = s2; *c; c++)
{
if (*s1 == *c)
break;
}
if (*c)
break;
s1++;
}
if (*c == '/0')
s1 = NULL;
return (char *) s1;
}
函数功能：在源字符串（s1）中找出最先含有搜索字符串（s2）中任一字符的位置。
返回值：返回第一个匹配字符的指针，若找不到则返回空指针
例:
char *buf = "0123456789";
char *buf1 = "abcdfe123abcdfe";
char *rtn;
// 找到字符串中第一个数字的位置
rtn = strpblk(buf1, buf);
printf("找到字符串中第一个数字的指针:%s", rtn);执行结果
21、Strcat：字符串连接函数
函数原型及源码：char *strcat (char *dest,char *src);
char * strcat(char * dest, const char * src)
{
char *tmp = dest;
while (*dest)
dest++;
while ((*dest++ = *src++) != '\0')
;
return tmp;
}
函数功能：将两个字符串连接合并成一个字符串，即把字符串src连接到字符串dest后面，连接后的结果放在字符串dest中
返回值：指向字符串dest的指针
例：
char buf[10]="abcd";
char *buf1 = "1234";
char *rtn;
// 找到字符串中第一个数字的位置
rtn = strcat(buf, buf1);
printf("字符串连接:%s", rtn);执行结果
22、strncat：字符串连接子串函数
函数原型及源码：char * strncat(char *dest,const char *source,int count)
char * strncat(char *dest,const char *source,int count)
{
char *p = dest;
while (*p) p++;
while (count-- && (*p++ = *source++));
*p = '\0';
return(dest);
}
函数功能：将一个字符串的子串连接到另一个字符串末端，也就是把字符串src的前count个字符连接到字符串dest后面，连接后的结果放在字符串dest中。
返回值：指向字符串dest的指针
例：
char buf[10] = "abcd";
const char *buf1 = "1234";
char *rtn;
// 找到字符串中第一个数字的位置
rtn = strncat(buf, buf1,2);
printf("字符串连接:%s", rtn);
23、strupr：字符串小写-大写转换函数
函数原型及源码：char *strupr(char *str);
char * strupr(char *str)
{
char *p = str;
while (*p != '\0')
{
if(*p >= 'a' && *p <= 'z') *p -= 0x20;
p++;
}
return str;
}
函数功能：将字符串str中小写字符全部转换为大写字符。
返回值：返回指向被转换字符串的指针
例：
char buf[10] ="abcDE";
char *rtn;
// 小写转大写
rtn = strupr(buf);
printf("小写转大写:%s", rtn);执行结果
24、strlwr：字符串大写-小写转换函数
函数原型及源码：strlwr(char *str)
strlwr(char *str)
{
char *p = str;
while (*p != '\0')
{
if(*p >= 'A' && *p <= 'Z') *p = (*p) + 0x20;
p++;
}
return str;
}
函数功能：将字符串str中的所有大写字符变成小写字符。
返回值：返回指向被转换字符串的指针
例：
char buf[10] ="abcDE";
char *rtn;
// 大写转小写
rtn = strlwr(buf);
printf("大写转小写:%s", rtn);执行结果
25、memset：数据设定函数
函数原型及源码：void *memset(void *dst,int val,int count)
void * memset(void *dst,int val,int count)
{
void *p = dst;
while (count--)
{
*(char *)dst = (char)val;
dst = (char *)dst + 1;
}
return p;
}
函数功能：将dst所指存储的前count自己设置为val，常用作初始化局部变量。
返回值：dst的值。
例：将局部数组int a[10]初始化为全0 ：memset(a,0,sizeof(a));
26、strset：字符串设定函数
函数原型及源码：函数原型：char *strset(char *str, char c);
char * strset(char *str,char c)
{
char *p = str;
while (*str)
*str++ = (char)c;
return(p);
}
函数功能：将字符串str中的所有字符全部用字符c进行替换.
返回值：返回指向被替换字符串的指针
例：将局部字符串char a[10]初始化为全'\0' ：strset(a,'\0',sizeof(a));，
27、strnset：字符串子串设定函数
函数原型及源码：char * strnset(char * str,char c,int count)
char * strnset(char * str,char c,int count)
{
char *p = str;
while (count-- && *p)
*p++ = (char)c;
return(p);
}函数功能：将字符串str前count个字符设定为指定字符c.
返回值：返回指向未被设定字符的指针
例：
char buf[20] ="123456789";
char *rtn;
rtn = strnset(buf,'a',5);
printf("替换后：%s\n", buf);
printf("返回值：%s\n", rtn);执行结果
28、strlen：计算字符串长度函数
函数原型及源码：int strlen(const char * str )
int strlen(const char * str )
{
const char *p = str;
while( *p++ ) ;
return( (int)(p - str - 1) );
}
函数功能：求字符串的长度，也就是求字符串str中有多少个字符，遇'\0'结束计算，计算长度不包含'\0'。
返回值：字符串str字符的个数。
例：strlen("123456789");计算结果为9
29、strrev：字符串倒转函数
函数原型及源码：函数原型：char *strrev(char *str);
char * strrev(char *str)
{
char *right = str;
char *left = str;
char ch;
while (*right) right++;
right--;
while (left < right)
{
ch = *left;
*left++ = *right;
*right-- = ch;
}
return(str);
}
函数功能：将字符串进行倒转，也就是将字符串str中的第一个字符与最后一个字符交换，第二个字符与倒数第二个字符交换，以此类推。
返回值：返回倒转后字符串的指针
例
char buf[20] ="123456789";
char *rtn;
rtn = strrev(buf);
printf("%s\n", rtn);执行结果
30、strtok：字符串分隔函数
函数原型及源码：char *strtok (char *s,const char *delim)
char *strtok (char *s,const char *delim)
{
static char *olds;
char *token;
if (s == NULL) s = olds;
//将指针移到第一个非delim中的字符的位置
s+=strspn (s,delim);
if (*s == '\0')
{
olds = s;
return NULL;
}
token = s;
//将指针移到第一个delim中的字符的位置
s = strpbrk(token, delim);
if (s == NULL)
{
olds = strchr(token, '\0');
}
else
{
// 将分割符替换为空字符
*s = '\0';
olds = s + 1;
}
return token;
}函数功能：在字符串str1中查找由字符串str2定义的分隔符，以分隔符为界，分隔出分隔符前面的字符组成一个单词，分离出第一个单词后将第一个参数置为空，可以继续分隔第二个单词。
返回值：返回分隔出的单词的指针
例：分割IP地址192.168.1.2
char buf[20] ="192.168.1.2";
char *rtn;
rtn = buf;
rtn = strtok(buf,".");
printf("%s\n", rtn);
rtn = strtok(NULL, ".");
printf("%s\n", rtn);
rtn = strtok(NULL, ".");
printf("%s\n", rtn);
rtn = strtok(NULL, ".");
printf("%s\n", rtn);
执行结果
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
