标准库字符串函数(超详细)

C语言字符串处理的库函数

使用C语言字符串处理的库函数，务必包含头文件string.h，即#include

1、比较字符串大小函数

1）忽略大小写---strcasecmp

函数原型：int strcasecmp (const char *s1, const char *s2);

函数说明：用来比较参数s1和s2字符串，比较时会自动忽略大小写的差异

2）忽略大小写—stricmp

函数原型：int stricmp(char *str1, char *str2);

函数说明：以大小写不敏感方式比较两个串

3）不忽略大小写—strcmp

函数原型：int strcmp(char*str1,char*str2);

函数说明：通过比较字串中各个字符的ASCII码，来比较参数Str1和Str2字符串，比较时考虑字符的大小写。4）比较一部分—strncmpi

函数原型：int strncmpi(char *str1, char *str2, unsigned maxlen);

函数说明：比较字符串str1和str2的前maxlen个字符

5）内存区域比较---memcmp

函数原型：int memcmp(void*buf1,void *buf2,unsigned int count)

函数说明：比较内存区域buf1和buf2的前count个字节。Void*是指任何类型的指针。

6）内存区域部分比较-- memicmp Void*是指任何类型的指针。

函数原型：int memicmp(void*buf1,void *buf2,unsigned int count)

函数说明：比较内存区域buf1和buf2的前count个字节，但不区分大小写。

以上比较函数的返回值：若参数1中字符串和参数中2字符串相同则返回0；

若参数1中字符串长度大于参数2中字符串长度则返回大于0 的值；

若参数1中字符串长度小于参数2中字符串长度则返回小于0的值。

2、从字符串中提取子串

1）提取子串--strstr

函数原型：char* strstr(char*src,char*find)

函数说明：从字符串src中寻找find第一次出现的位置（不比较结束符NULL）

返回值：返回指向第一次出现find位置的指针，如果没有找到则返回NULL

2）提取分隔符间字串—strtok

函数原型：char *strtok(char*src，char*delim);

函数说明：分解字符串诶一组标记串，src为要分解的字符串，delim为分隔符字符串。

首次调用时，src必须指向要分解的字符串，随后调用要把s设成NULL；

strtok中src中查找包含在delim中的字符，并用NULL（’\0’）来替换直到找遍整个字符串。

返回值：从s开头开始的一个个被分割的串。当没有被分割的串时则返回NULL。

所有delim中包含的字符都会被滤掉，并将被滤掉的地方设为一处分割的节点。

举例：

#include

#include

int main(){

char *s="Golden Global View";

char *d=" ";

char *p;

p=strtok(s,d);

while(p){

printf("%s\n",p);

strtok(NULL,d);

}

return 0;

}

输出：Golden

Global

View

3、字符串复制

1) 字串复制--strcpy

函数原型：char*strcpy(char*dest,char*src)

函数说明：把src所指由NULL结束的字符串复制到dest所指的数组中。

其中，src和dest所致内存区域不可重叠且dest必须有足够的空间来容纳src的字符串。

返回值：返回指向dest的指针。

2）字串复制--strdup

函数原型：char* strdup(char*src)

函数说明：复制字符串src

返回值：返回指向被复制字符串的指针，所需空间有malloc（）分配且可以有free（）释放。

3）内存空间复制--memcpy

函数原型：void *memcpy(void *dest,void *src,unsigned int count);

函数说明：src和dest 所指内存区域不能重叠；由src所致内存区域复制count个字节到dest所指内存区域中。返回值：返回指向dest的指针。

4、字符串连接

1）接尾连接--strcat

函数原型：char* strcat(char*dest,char*src)

函数说明：把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')并添加'\0'

2)部分连接--strncat

函数原型:char* strncat(char*dest,char*src,int n);

函数说明：把src所指字符串的前n个字符添加到dest结尾处（覆盖dest结尾处的’\0’）并添加’’\0’.

返回值：返回指向dest的指针。

5、从字符串中查找字符

1）内存区域找字符--memchr

函数原型：void *memchr(void*buf,char ch,usigned count)

函数说明：从buf所指内存区域的前count个字节查找字符ch，当第一次遇到字符ch时停止查找。

返回值：如果找到了，返回指向字符ch的指针；否则返回NULL

2）字串中找字符--strchr

函数原型:char* strchr(char*src,char ch)

函数说明：查找字符串s中首次出现字符ch的位置

返回值：返回首次出现c的位置的指针，如果s中不存在c则返回NULL

3）搜所现字符--strcspn

函数原型：int strcspn（char*src,char*find）

函数说明：在字符串src中搜寻find中所出现的字符

返回值：返回第一个出现的字符在src中的下标值，即src中出现而不在find中出现的字串的长度。

举例：

#include

#include

int main(){

char *s="Golden Global View";

char *r="new";

int n;

n=strcspn(s,r);

printf("The first char both in s1 and s2 is: %c",s[n]);

return 0;

}

输出：The first char both in s1 and s2 is :e

4)匹配任一字符--strpbrk

函数原型：char*strpbrk(char*s1,char*s2)

函数说明：在字符串S1中寻找字符串S2中任何一个字符相匹配的第一个字符的位置，空字符不包括在内。返回值：返回指向S1中第一个相匹配的字符的指针，如果没有匹配字符则返回空指针。

举例：

#include

#include

int main(){

char *s1="Welcome To Beijing";

char *s2="BIT";

char *p;

p=strpbrk(s1,s2);

if(p)

printf("%s\n",p);

else printf("Not Found!\n");

return 0;

}

输出：To Beijing

6、其他函数

1）全部转成大写---strupr

函数原型：char*strupr(char*src)

函数说明：将字符串src转换成大写形式，只转换src中出现的小写字母，不改变其他字符

返回值：返回指向src的指针。

2）全部转成小写---strlwr

函数原型：char*strlwr(char*src)

函数说明：将字符串src转换成小写形式，只转换src中出现的大写字母，不改变其他字符

返回值：返回指向src的指针。

3）将字串逆向--strrev

函数原型：char*strrev（char*src）

函数说明：把字符串src的所有字符的顺序颠倒过来（不包括NULL）

返回值：返回指向颠倒顺序后的字符串指针

memset与memcpy函数使用详细说明

1. void *memset(void *s,int c,size_t n)

总的作用：将已开辟内存空间s 的首n 个字节的值设为值c。

2. 例子

＃i nclude

main(){

char *s="Golden Global View";

clrscr();

memset(s,'G',6);

printf("%s",s);

getchar();

return 0;

}

3. memset() 函数常用于内存空间初始化。如：

char str[100];

memset(str,0,100);

4. memset()的深刻内涵：用来对一段内存空间全部设置为某个字符，一般用在对定义的字符串进行初始化为‘ ’或‘\0’；例:char a[100];memset(a, '\0', sizeof(a));

memcpy用来做内存拷贝，你可以拿它拷贝任何数据类型的对象，可以指定拷贝的数据长度；例：char a[100],b[50];

memcpy(b, a, sizeof(b));注意如用sizeof(a)，会造成b的内存地址溢出。

strcpy就只能拷贝字符串了，它遇到'\0'就结束拷贝；例：char a[100],b[50];strcpy(a,b);如用strcpy(b,a)，要注意a中的字符串长度（第一个‘\0’之前）是否超过50位，如超过，则会造成b的内存地址溢出。

5.补充：某人的一点心得

memset可以方便的清空一个结构类型的变量或数组。

如：

struct sample_struct

{

char csName[16];

int iSeq;

int iType;

};

对于变量struct sample_strcut stTest;

一般情况下，清空stTest的方法：

stTest.csName[0]='\0';

stTest.iSeq=0;

stTest.iType=0;

用memset就非常方便：

memset(&stTest,0,sizeof(struct sample_struct));

如果是数组：

struct sample_struct TEST[10];

则

memset(TEST,0,sizeof(struct sample_struct)*10);

6. strcpy

原型：extern char *strcpy(char *dest,char *src);

用法：＃i nclude

功能：把src所指由NULL结束的字符串复制到dest所指的数组中。

说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。

返回指向dest的指针。

memcpy

原型：extern void *memcpy(void *dest, void *src, unsigned int count);

用法：＃i nclude

功能：由src所指内存区域复制count个字节到dest所指内存区域。

说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。

memset

原型：extern void *memset(void *buffer, int c, int count);

用法：＃i nclude

功能：把buffer所指内存区域的前count个字节设置成字符c。

说明：返回指向buffer的指针。

strcpy()、strlen()、memcpy()、memmove()、memset()的实现strcpy(), 字符串拷贝.

char *strcpy(char *strDest, const char *strSrc)

{

assert((strDest!=NULL) && (strSrc !=NULL));

char *address = strDest;

while( (*strDest++ = * strSrc++) != '\0')

NULL ;

return address ;

}

strlen,

第一种方法：

int strlen(const char *str)

{

assert(str != NULL);

int len = 0;

while((*str++) != '\0')

len++;

return len;

}

第二种方法：

int strlen(const char *str)

{

assert(str != NULL);

const char *p = str;

while((*p++) != '\0');

return p - str - 1;

}

第三种方法：

int strlen(const char* str)

{

if (str[0] == '\0')

return 0;

else

return strlen((char *)(&str[0]+1))+1;

}

memcpy, 拷贝不重叠的内存块

void *memcpy(void* pvTo, void* pvFrom, size_t count)

{

assert(pvTo != NULL && pvFrom != NULL);

byte* pbTo = (byte*)pvTo;

byte* pbFrom = (byte*)pvFrom;

/* 内存块重叠吗？如果重叠，就使用memmove */

assert(pbTo>=pbFrom+count || pbFrom>=pbTo+count);

while(count-- > 0)

*pbTo++ == *pbFrom++;

return pvTo;

}

void* memmove(void *dest, const void *src,size_t count)

{

if (count == 0) return0;

if (dest == NULL) return0;

if (src == NULL) return0;

char *psrc = (char*)src;

char *pdest = (char*)dest;

if((pdest <= psrc) || (pdest >= psrc + count)) /*检查是否有重叠问题 */ {

/*正向拷贝*/

while (count--)

*pdest++ = *psrc++;

}

else

{

/*反向拷贝*/

pdest += count - 1;

psrc += count - 1;

while (count--)

*pdest-- = *psrc--;

}

return dest;

}

memset:把buffer所指内存区域的前count个字节设置成字符c

void * memset(void* buffer, int c, int count)

{

char* pvTo=(char*)buffer;

assert(buffer != NULL);

while(count-- > 0)

*pvTo++=(char)c;

return buffer;

}

分析：

memmove、memcpy和memccpy三个函数都是内存的拷贝，从一个缓冲区拷贝到另一个缓冲区。

memmove(void *dest,void*src,int count)

memcpy(void *dest,void *src,int count)

memccpy(void*dest,void*src,int ch,int count)

表头文件: #include

定义函数: void *memcpy(void *dest, const void *src, size_t n)

函数说明: memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。与strcpy()不同的是,memcpy()会完整的复制n个字节,不会因为遇到字符串结束'\0'而结束

返回值: 返回指向dest的指针

表头文件: #include

定义函数: void *memccpy(void *dest, const void *src, int c, size_t n);

函数说明: memccpy()用来拷贝src所指的内存内容前n个字节到dest所指的地址上。与memcpy()不同的是,memccpy()如果在src中遇到某个特定值(int c)立即停止复制。

返回值: 返回指向dest中值为c的下一个字节指针。返回值为0表示在src所指内存前n个字节中没有值为c的字节。

表头文件: #include

定义函数: void *memmove(void *dest, const void *src, size_t n);

函数说明:memmove()是从一个缓冲区移动到另一个缓冲区中。

返回值: 返回指向dest指针。

当dest <= src-count 或dest >= src+count时，以上三个函数均不会产生覆盖问题，即源数据不会被更改。

若不在以上范围内，则源数据会被更改。不妨用个小程序来测一下：

# include

# include

int main()

{

int i = 0;

int a[10];

for(i; i < 10; i++)

{

a[i] = i;

}

memcpy(&a[4], a, sizeof(int)*6);

for(i = 0; i < 10; i++)

{

printf("%d ",a[i]);

}

printf("\n");

return 0;

}

将上面代码gcc之后再运行，结果为：0 1 2 3 0 1 2 3 0 1 。

再把第13行改成：memmove(&a[4], a, sizeof(int)*6)，重新gcc再运行，结果为：0 1 2 3 0 1 2 3 4 5 ！

呵呵，两者的区别出现了。不过其实这样还不够，继续修改13行：memmove(a, &a[4], sizeof(int)*6) //也就是将源、目的置换一下而已。重新gcc编译再运行，结果为：4 5 6 7 8 9 6 7 8 9 。

还不够，继续修改13行为：memcpy(a, &a[4], sizeof(int)*6); gcc并运行，结果仍为：4 5 6 7 8 9 6 7 8 9 ！

至此真相已经大白了。对比上面四个结果，不难得出以下结论：

1. 当src 和dest 所指内存区有重叠时，memmove 相对memcpy 能提供保证：保证能将src 所指内存区的前n 个字节正确的拷贝到dest 所指内存中；

2. 当src 地址比dest 地址低时，两者结果一样。换句话说，memmove 与memcpy 的区别仅仅体现在dest 的头部和src 的尾部有重叠的情况下

strcpy，memcpy，memmove，memset，strncpy

一．函数分别介绍：

1、memcpy:

原型：extern void *memcpy(void *dest, const void *src, unsigned int count);

用法：#include

功能：由src所指内存区域复制count个字节到dest所指内存区域。

说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。

注意：和strcpy相比，memcpy不是遇到’\0’就结束，而是一定会拷贝完n个字节。

2、memset:

函数原型：

extern void *memset(void *s, int c, size_t n)

功能：将已开辟内存空间s的首n个字节的值设为值c。将s中的前n个字符替换为c，并返回s。

memset常用于内存空间的初始化。

memset的深刻内涵：用来对一段内科空间全部设置为某个字符，一般用在对定义的字符串进行初始化为：memset(a, ‘\0’, sizeof(a));

3、void *memmove(void *s, const void *ct, size_t n)

与memcpy类似，所不同的是，当对象重叠时，该函数仍能正确执行

4、strncpy(s, t, n)

把t指向的字符串中前n个字符复制到s指向的位置。

二．下面重点来讲解memcpy和memmove的区别：

这两个函数的函数原型（除了名字）是一样的：

void *memcpy(void *dst, const void *src, size_t count):

void *memmove(void *dst, const void *src, size_t count);

它们都是从src所指向的内存中复制count个字节到dst所指内存中，并返回dst的值。当源内存区域和目标内存区域无交叉时，两者的结果都是一样的。但有交叉时不一样。源内存和目标内存交叉的情况有以下两种：（左边为低地址）

1、

即：dst<=src 且dst+count>src

2、

即：srcdst

下面将针对这两种情况来讨论。针对第一种交叉情况情况，dstsrc，memcpy和memmove的结果是一样的。请看下面的例子讲解：

int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

memcpy(a, a+4, sizeof(int)*6);和memmove(a, a+4, sizeof(int)*6);结果是：

4567896789

针对第二种情况，srcdst，memcpy和memmove的结果是不一样的。请看下面的例子：

int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

memcpy(a+4, a, sizeof(int)*6)

memmove(a+4, a, sizeof(int)*6)

下面是这两个函数的具体实现：

void *memcpyMy(void *dst, const void *src, size_t count){

void *address = dst;

while (count)

{

*(char *)address = *(char *)src;

address = (char *)address + 1;

src = (char *)src + 1;

count --;

}

return dst;

}

void *memmoveMy(void *dst, const void *src, size_t count){

void *address = dst;

if (dst <= src || (char*)dst >= (char *)src + count)

{

while (count --)

{

*(char *)address = *(char *)src;

address = (char *)address + 1;

src = (char *)src + 1;

}

}else{

address = (char *)address + count - 1;

src = (char *)src + count - 1;

while (count --)

{

*(char *)address = *(char *)src;

address = (char *)address - 1;

src = (char *)src - 1;

}

}

return dst;

}

以上两段代码是在vc6.0下通过测试的。

三个火枪手（memset ，memcpy，strcpy）

常常用到的函数strcpy来帮助我们进行字符串的复制。

例如：

char a[100], b[50];

strcpy(a,b);

在这个例子中，复制b到a，这里要注意的一个问题是确保目的容器（突然想起来这么一个词）有足够的空间去容纳新进数据。

strcpy 只能够拷贝字符窜，它遇到'\0'就结束拷贝。

曾经一个高手，告诉我，一个C程序员水平的高低，一方面是看他对C函数的理解和应用上。

memcpy就是一个更高层次的函数，它用来内存拷贝，任何数据类型的对象，可以指定拷贝数据的长度。

例如：

char a[100], b[50];

memcpy(b, a, sizeof(b)); //注意如果使用sizeof(a) 会造成b的内存泄漏，计算机系统最严重的一个问题了。

memset用来对一段内存空间全部设置为某个字符，一般用在对定义的字符串进行初始化' ' 或'\0'，你知道定义一个变量而没有初始化是多么危险的行为，潘多拉的盒子。

例如：

char a[100], b[50];

memset(a, '\0', sizeof(a));

除此之外memset可以方面的清空一个结构性的变量和数组。

例如：

struct sample_struct

{

char csName[16];

int iSeq;

int iType;

};

struct sample_struct stTest;

一般情况下，我们清空stTest的方法：

stTest.csName[0]='\0';

stTest.iSeq = stTest.iType = 0;

如果用memset就非常方便了

memset(stTest, 0, sizeof(struct sample_struct));

总结：

memset主要用于初始化某个内存空间，设置某个内存空间。

memcpy用于copy源空间的数据到目的空间中。

strcpy用于字符串的复制，遇到空字符’\0'就结束。

memcpy，memmove，strcpy，strncpy

memcpy与strcpy

memcpy（拷贝内存内容）

相关函数bcopy，memcpy，memcpy，memmove，strcpy，strncpy

表头文件#include

定义函数void * memcpy (void * dest ,const void *src, size_t n);

函数说明memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。与strcpy()不同的是，memcpy()会完整的复制n个字节，不会因为遇到字符串结束'\0'而结束。

返回值返回指向dest的指针。

附加说明指针src和dest所指的内存区域不可重叠。

strcpy（拷贝字符串）

相关函数bcopy，memcpy，memccpy，memmove

表头文件#include

定义函数char *strcpy(char *dest,const char *src);

函数说明strcpy()会将参数src字符串拷贝至参数dest所指的地址。

返回值返回参数dest的字符串起始地址。

附加说明如果参数dest所指的内存空间不够大，可能会造成缓冲溢出(buffer Overflow)的错误情况，在编写程序时请特别留意，或者用strncpy()来取代。

char * strncpy(char *s1,char *s2,size_t n);

将字符串s2中最多n个字符复制到字符数组s1中，返回指向s1的指针。注意：如果源串长度大于n，则strncpy 不复制最后的'\0'结束符，所以是不安全的，复制完后需要手动添加字符串的结束符才行。

Strcpy和Strncpy的区别- -

第一种情况：

char* p="how are you ?";

char name[20]="ABCDEFGHIJKLMNOPQRS";

strcpy(name,p); //name改变为"how are you ? "====>正确！

strncpy(name,p,sizeof(name)); //name改变为"how are you ? " ====>正确！

第二种情况：

char* p="how are you ?";

char name[10];

strcpy(name,p); //目标串长度小于源串,错误！

name[sizeof(name)-1]='\0'; //和上一步组合，弥补结果，但是这种做法并不可取，因为上一步出错处理方式并不确定

strncpy(name,p,sizeof(name)); //源串长度大于指定拷贝的长度sizeof(name)，注意在这种情况下不会自动在目标串后面加'\0'

name[sizeof(name)-1]='\0'; //和上一步组合，弥补结果

总结：strcpy

源字串全部拷贝到目标字串中,包括'\0'，但是程序员必须保证目标串长度足够，且不与源串重叠。

strncpy

如果目标长>=指定长>源长，则将源串全部拷贝到目标串，连同'\0'

如果指定长<源长，则将截取源串中按指定长度拷贝到目标字符串，不包括'\0'

如果指定长>目标长，错误!

拷贝时，strcpy 和strncpy 遇到‘0\’结束！！！

memcpy与memmove

memcpy是把source 指向的对象中的n个字符拷贝到destin所指向的对象中，返回指向结果对象的指针。

memmove也是把source 指向的对象中的n个字符拷贝到destin所指向的对象中，但过程就好象是先把source 所指向的对象拷贝到临时数组中，然后在从临时数组拷贝到destin所指的对象中，返回指向结果对象的指针。

如果这两个数组重叠，memmove可以正确地拷贝到dest中去，而memcpy则执行非法。可memcpy用汇编写的，快啊！

但要注意，除memmove之外的字符串操作函数在拷贝同一个字符串中的字符时，其结果是不确定的。也就是说，memmove可以把自己的一部分拷贝给自己的另一部分。其他函数不行，比如memcpy.

C语言字符串函数用法汇总

函数名: stpcpy

功能: 拷贝一个字符串到另一个

用法: char *stpcpy(char *destin, char *source);

程序例:

#include

#include

int main(void)

{

char string[10];

char *str1 = "abcdefghi";

stpcpy(string, str1);

printf("%s\n", string);

return 0;

}

函数名: strcat

功能: 字符串拼接函数

用法: char *strcat(char *destin, char *source);

程序例:

#include

#include

int main(void)

{

char destination[25];

char *blank = " ", *c = "C++", *Borland = "Borland";

strcpy(destination, Borland);

strcat(destination, blank);

strcat(destination, c);

printf("%s\n", destination);

return 0;

}

函数名: strchr

功能: 在一个串中查找给定字符的第一个匹配之处\

用法: char *strchr(char *str, char c);

程序例:

#include

#include

int main(void)

{

char string[15];

char *ptr, c = 'r';

strcpy(string, "This is a string");

ptr = strchr(string, c);

if (ptr)

printf("The character %c is at position: %d\n", c, ptr-string);

else

printf("The character was not found\n");

return 0;

}

函数名: strcmp

功能: 串比较

用法: int strcmp(char *str1, char *str2);

看Asic码，str1>str2，返回值> 0；两串相等，返回0

程序例:

#include

#include

int main(void)

{

char *buf1 = "aaa", *buf2 = "bbb", *buf3 = "ccc";

int ptr;

ptr = strcmp(buf2, buf1);

if (ptr > 0)

printf("buffer 2 is greater than buffer 1\n");

else

printf("buffer 2 is less than buffer 1\n");

ptr = strcmp(buf2, buf3);

if (ptr > 0)

printf("buffer 2 is greater than buffer 3\n");

else

printf("buffer 2 is less than buffer 3\n");

}

函数名: strncmpi

功能: 将一个串中的一部分与另一个串比较, 不管大小写用法: int strncmpi(char *str1, char *str2, unsigned maxlen); 程序例:

#include

#include

int main(void)

{

char *buf1 = "BBB", *buf2 = "bbb";

int ptr;

ptr = strcmpi(buf2, buf1);

if (ptr > 0)

printf("buffer 2 is greater than buffer 1\n");

if (ptr < 0)

printf("buffer 2 is less than buffer 1\n");

if (ptr == 0)

printf("buffer 2 equals buffer 1\n");

return 0;

}

函数名: strcpy

功能: 串拷贝

用法: char *strcpy(char *str1, char *str2);

程序例:

#include

#include

int main(void)

{

char string[10];

char *str1 = "abcdefghi";

strcpy(string, str1);

printf("%s\n", string);

return 0;

}

功能: 在串中查找第一个给定字符集内容的段

用法: int strcspn(char *str1, char *str2);

程序例:

#include

#include

#include

int main(void)

{

char *string1 = "1234567890";

char *string2 = "747DC8";

int length;

length = strcspn(string1, string2);

printf("Character where strings intersect is at position %d\n", length);

return 0;

}

函数名: strdup

功能: 将串拷贝到新建的位置处

用法: char *strdup(char *str);

程序例:

#include

#include

#include

int main(void)

{

char *dup_str, *string = "abcde";

dup_str = strdup(string);

printf("%s\n", dup_str);

free(dup_str);

return 0;

}

函数名: stricmp

功能: 以大小写不敏感方式比较两个串

用法: int stricmp(char *str1, char *str2);

程序例:

#include

#include

int main(void)

{

char *buf1 = "BBB", *buf2 = "bbb";

int ptr;

ptr = stricmp(buf2, buf1);

if (ptr > 0)

printf("buffer 2 is greater than buffer 1\n");

if (ptr < 0)

printf("buffer 2 is less than buffer 1\n");

if (ptr == 0)

printf("buffer 2 equals buffer 1\n");

return 0;

}

函数名: strerror

功能: 返回指向错误信息字符串的指针

用法: char *strerror(int errnum);

程序例:

#include

#include

int main(void)

{

char *buffer;

buffer = strerror(errno);

printf("Error: %s\n", buffer);

return 0;

}

函数名: strcmpi

功能: 将一个串与另一个比较, 不管大小写用法: int strcmpi(char *str1, char *str2);

程序例:

#include

#include

int main(void)

{

char *buf1 = "BBB", *buf2 = "bbb";

int ptr;

ptr = strcmpi(buf2, buf1);

if (ptr > 0)

printf("buffer 2 is greater than buffer 1\n");

if (ptr < 0)

printf("buffer 2 is less than buffer 1\n");

if (ptr == 0)

printf("buffer 2 equals buffer 1\n");

return 0;

}

函数名: strncmp

功能: 串比较

用法: int strncmp(char *str1, char *str2, int maxlen);

程序例:

#include

#include

int main(void)

{

char *buf1 = "aaabbb", *buf2 = "bbbccc", *buf3 = "ccc";

int ptr;

ptr = strncmp(buf2,buf1,3);

if (ptr > 0)

printf("buffer 2 is greater than buffer 1\n");

else

printf("buffer 2 is less than buffer 1\n");

ptr = strncmp(buf2,buf3,3);

if (ptr > 0)

printf("buffer 2 is greater than buffer 3\n");

else

printf("buffer 2 is less than buffer 3\n");

return(0);

}

函数名: strncmpi

功能: 把串中的一部分与另一串中的一部分比较, 不管大小写用法: int strncmpi(char *str1, char *str2);

程序例:

#include

#include