在有关内存的函数中,参数虽为void * ,但按照ANSI(American National Standards Institute)标准,不能对void指针进行算法操作,即不能对void指针进行如p++的操作,所以需要转换为具体的类型指针来操作,例如char *。
清零:内存清零memset
memset:
void memset(void *buffer , int c , int count);
内存起始地址作为其第一个参数,第二个参数是设置内存空间每个字节的值,第三个参数是设定的内存空间的长度(字节数,不是元素个数)。
memset()会将参数s所指的内存区域前n个字节以参数c填入,然后返回指向s的指针;
int c 是填入一个字节的,是针对一个字节的值,所以c 的取值只能做到一个字节的空间0~255
因为是void *buffer ,所以是对一段内存的操作,不管这个内存存储的数据类型是什么,只要指定count大小,都将会将以buffer为起始地址的count字节的存储内容值统一赋为c 。
若我们将int c = 0; 或int c = '\0' 都会将这段内存清零(事实上字符’\0‘的ASCII码的值就为0,而在内存中任何字符都是以ASCII码来进行存储的,127以下的整数可以和字符进行通用,所以int c = 0 或 ’\0‘都是等效的,只是后者更习惯用于对字符串的清0,而前者都通用)。
memset() 函数常用于内存空间初始化(初始化为0),还用于一段已用内存空间的清零,常用于以下几种情况:
用于局部动态未初始化数组清0:
main()
{
int a[10];
memset(a,0,sizeof(a));//事实上,这个清零也可以在定义时初始化int a[10] = {0};来实现
}
用于结构体对象清0:
typedef struct Stu{
char name[24];// 24是为了充分利用空间,因为字节对齐
int id;
Stu *next;
}Stu;
main()
{
Stu stu1; //这时候得到的结构体里面的成员都是局部动态变量,其初始值都为随机值,只有单stu1为全局的时候,才能为默认值,即stu1本身即为一个变量,只不过类型自定义
memset(&stu1,0,sizeof(Stu));
}
常见的memset的误用及滥用:
情况一、对整形数组进行清0 则memset(a,0,sizeof(a)) 与 int a[10] = {0};效果是相同的,但若是要给数组进行赋给一个相同的值如1,则memset(a,1,sizeof(a))是不能达到的,因为memset是对每个字节赋值,而每个整形数组的元素占4个字节,那么这样赋值完以后,对a指向的内存的20个字节进行赋值,每个都用ASCII为1的字符去填充,转为二进制后,1就是00000001,占一个字节。一个INT元素是4字节,合一起就是1000000010000000100000001,就等于16843009而不是1;
情况二、对于由malloc开辟的空间,其返回的空间的内容是随机的,是不确定的内容,所以最好要memset 一下,别忘了 !而内核空间的kmalloc也是一样!
Stu *stu2 = (Stu *)malloc(sizeof(Stu));
memset(stu2,0,sizeof(Stu)); //——良好的习惯
情况三、错误想法:对于定义后确定会马上赋值了的,则不用memset ,
良好习惯:对于定义后未初始化的,都一律最好清零--------尤其是字符数组,一定要!!!
一些可能有某种心理阴影, 他们惧怕未经初始化的内存, 所以他们会写出这样的代码:
char buffer[20];
memset(buffer, 0, sizeof((char)*20));
strcpy(buffer, "123");
这里的memset是多余的. 因为这块内存马上就被覆盖了, 清零没有意义----------错误!!!
如:
main()
{
int i;
char gs[20];
//memset(gs,0,20); //为的是将每一个字符都充满’\0‘
printf("input a string:\n");
gets(gs);
printf("gs:%s\n",gs);
for(i=0;i<20;i++)
printf("%c",gs[i]);//后面的为乱码,说明gets并不会将后面的空值也赋为0,仅是前面的覆盖,所以说数组若未初始化则要马上清零是多么重要!
strncpy(gs+3,gs,20); //若数组起始未清过零,则'\0'后的区域仍残留随机值,则输出的是错误结果
printf("gs:%s\n",gs);
printf("\n");
}输入:123456789
输出:123456789(U, � //看看,连随机值也一起拷贝了
memset主要应用是初始化某个内存空间。
memcpy是用于copy源空间的数据到目的空间中。
strcpy用于字符串copy,遇到‘/0’,将结束。
原型: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的指针。
memcpy用来做内存拷贝,你可以拿它拷贝任何数据类型的对象,可以指定拷贝的数据长度。
例:char a[100],b[50]; memcpy(b, a, sizeof(b));注意如用sizeof(a),会造成b的内存地址溢出。
Strcpy 就只能拷贝字符串了,它遇到'/0'就结束拷贝。
拷贝:覆盖: memmove、memccpy、memcpy、strncpy、strcpy、strncat、strcat、 生成:strdup -------3+2+2+1
memcpy、memmove、memccpy、strncpy、strcpy、strncat、strcat都是在已有的字符串空间进行覆盖,是两个实体间部分空间的值的拷贝;但strdup 不一样,它是利用malloc、strcpy来克隆出另一个完完全全相同的字符串实体,只是原有字符串实体空间与新生成字符串实体空间的首地址不同,其它的大小和值都一样,新生成的字符串实体的首地址作为返回值。
——strdup完全没有限制,因为它是完成的是克隆的功能,利用了malloc 和strcpy
memcpy:
void * memcpy (void * dest ,const void *src, size_t n);返回复制后的dest指针。
memcpy(拷贝内存内容) | |
相关函数
| bcopy,memccpy,memcpy,memmove,strcpy,strncpy |
表头文件
| #include<string.h> |
定义函数
| void * memcpy (void * dest ,const void *src, size_t n); |
函数说明
| memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。与strcpy()不同的是,memcpy()会完整的复制n个字节,不会因为遇到字符串结束'\0'而结束,可用于一般的内存拷贝或拷贝含'\0'的多个字符串空间。 |
返回值
| 返回指向dest的指针。 |
附加说明
| 指针src和dest所指的内存区域不可重叠。 |
范例
| #include<string.h> main() { char a[30]="string (a)"; char b[30]="string\0string"; int i; strcpy(a,b); printf("strcpy():"); for(i=0;i<30;i++) printf("%c",a[i]); memcpy(a,b,30); printf("\nmemcpy() :"); for(i=0;i<30;i++) printf("%c",a[i]); } |
执行
| strcpy() : string a ) memcpy() : string string |
memcpy实现:
void *memcpy(void *v_dst,const void *v_src, __kernel_size_t c)
{
const char *src = v_src;
char *dst = v_dst;
while (c--)
*dst++ = *src++;
return v_dst;
memmove:
memmove(拷贝内存内容) | |
相关函数
| bcopy,memccpy,memcpy,strcpy,strncpy |
表头文件
| #include<string.h> |
定义函数
| void * memmove(void *dest,const void *src,size_t n); |
函数说明
| memmove()与memcpy()一样都是用来拷贝src所指的内存内容前n个字节到dest所指的地址上。不同的是,当src和dest所指的内存区域重叠时,memmove()仍然可以正确的处理,不过执行效率上会比使用memcpy()略慢些。 |
返回值
| 返回指向dest的指针。 |
附加说明
| 其它的与memcpy一样,不同的是指针src和dest所指的内存区域可以重叠,若内存重叠,则从后往前复制。 |
范例
| 参考memcpy()。 |
{
const char *src = v_src;
char *dst = v_dst;
return v_dst;
if (v_dst <= v_src) //memmove里面则判断了内存重叠的情况,当dest在src的后面时内存重叠,则从后往前复制,否则调用memcpy来实现就可以。
return memcpy(v_dst, v_src, c);
src += c;
dst += c;
while (c--)
*--dst = *--src; //dest在src的后面时内存重叠,则从后往前复制
return v_dst;
memccpy:
memccpy(拷贝内存内容) | |
相关函数
| bcopy,memcpy,memmove,strcpy,strncpy |
表头文件
| #include<string.h> |
定义函数
| void * memccpy(void *dest, const void * src, int c,size_t n); |
函数说明
| memccpy()用来拷贝src所指的内存内容前n个字节到dest所指的地址上。与memcpy()不同的是,memccpy()会在复制时检查参数c是否出现,若是则返回dest中值为c的下一个字节地址。 |
返回值
| 返回指向dest中值为c的下一个字节指针。返回值为0表示在src所指内存前n个字节中没有值为c的字节。 |
范例
| #include<string.h> main() { char a[]="string[a]"; char b[]="string(b)"; memccpy(a,b,'B',sizeof(b)); printf("memccpy():%s\n",a); } |
执行
| memccpy():string(b),返回0 |
strncpy:
strncpy(拷贝字符串) | |
相关函数
| bcopy,memccpy,memcpy,memmove |
表头文件
| #include<string.h> |
定义函数
| char * strncpy(char *dest,const char *src,size_t n); |
函数说明
| strncpy()会用参数src字符串的前n个字符,覆盖至参数dest所指的地址为起始地址的后n个字符空间,而至于后面没覆盖的空间并不会清空,而是保留原有值。 |
返回值
| 返回参数dest的字符串起始地址。 |
范例
| #inclue <string.h> main() { char a[30]="string(1)"; char b[]="string(2)"; printf("before strncpy() : %s\n",a); printf("after strncpy() : %s\n",strncpy(a,b,6)); } |
执行
| before strncpy() : string(1) after strncpy() : string(1) |
{
int i; //strcpy 和 strncpy 都只是进行覆盖,后面没有覆盖到的值仍存在
char gs[20];
printf("input a string:\n");
gets(gs);
printf("gs:%s\n",gs);
for(i=0;i<20;i++)
printf("%c",gs[i]);//后面的为乱码,说明gets并不会将后面的空值也赋为0,仅是前面的覆盖,所以说数组若未初始化则要马上清零是多么重要!
printf("\n\n");
strncpy( gs,gs+3, strlen(gs+3)-2); //大小一定要控制好了,仅是将中间的一部分字符串覆盖到开头------若是只想达到覆盖的效果,这样就可以了
gs[strlen(gs+3)-2] = '\0'; //若是想做的不是覆盖而是复制字符串,则一定要格外添加'\0'
printf("gs:%s\n",gs);
printf("%c",gs[i]);//后面的为乱码,说明gets并不会将后面的空值也赋为0,仅是前面的覆盖,所以说数组若未初始化则要马上清零是多么重要!
printf("\n");
123456789
gs:123456789
123456789�U̶Y� //输出gs[i]
gs:4567 //输出手动补'\0'后的strncpy
45676789�U̶Y� //输出gs[i]
{
int i;
char gs[10],ks[20];
printf("input gs[10]:\n");
gets(gs); //输入gs[10]
printf("gs:%s\n",gs);
printf("input ks[20]:\n");
gets(ks); //输入ks[20]
printf("ks:%s\n",ks);
for(i=0;i<10;i++)
printf("%c",gs[i]);
printf("\n");
for(i=0;i<10;i++)
printf("%c",gs[i]);
printf("\n\n");
(gs+3)[20] = '\0'; //若是想做的不是覆盖而是复制字符串,则一定要格外添加'\0'
printf("gs+3:%s\n",gs);
for(i=3;i<20;i++)
printf("%c",gs[i]);
printf("\n");
#include<stdlib.h>
#include<string.h>
main()
{
#if 1
char gs[20];
printf("input a string:\n");
gets(gs);
printf("gs:%s\n",gs);
for(i=0;i<20;i++)
printf("%c",gs[i]);//后面的为乱码,说明gets并不会将后面的空值也赋为0,仅是前面的覆盖,所以说数组若未初始化则要马上清零是多么重要!
printf("\n");
strncpy(gs+3,gs,2);//OK ! 允许, 不算是空间重叠,因为dest的n字节尾部并没有与src的头部重合
for(i=0;i<20;i++)//strcpy 和 strncpy 都只是进行覆盖,后面没有覆盖到的值仍存在
printf("%c",gs[i]);//后面的为乱码,说明gets并不会将后面的空值也赋为0,仅是前面的覆盖,所以说数组若未初始化则要马上清零是多么重要!
printf("\n");
printf("%c",gs[i]);//后面的为乱码,说明gets并不会将后面的空值也赋为0,仅是前面的覆盖,所以说数组若未初始化则要马上清零是多么重要!
printf("\n");
strcpy:
strcpy(拷贝字符串) | |
相关函数
| bcopy,memcpy,memccpy,memmove |
表头文件
| #include<string.h> |
定义函数
| char *strcpy(char *dest,const char *src); |
函数说明
| strcpy()会将参数src字符串拷贝至参数dest所指的地址。 |
返回值
| 返回参数dest的字符串起始地址。 |
附加说明
| 如果参数dest所指的内存空间不够大,可能会造成缓冲溢出(buffer Overflow)的错误情况,在编写程序时请特别留意,或者用strncpy()来取代。 |
范例
| #include<string.h> main() { char a[30]="string(1)"; char b[]="string(2)"; printf("before strcpy() :%s\n",a); printf("after strcpy() :%s\n",strcpy(a,b)); } |
执行
| before strcpy() :string(1) after strcpy() :string(2) |
strncat:
strncat(连接两字符串) | |
相关函数
| bcopy,memccpy,memecpy,strcpy,strncpy |
表头文件
| #inclue <string.h> |
定义函数
| char * strncat(char *dest,const char *src,size_t n); |
函数说明
| strncat()会将参数src字符串拷贝n个字符到参数dest所指的字符串尾。第一个参数dest要有足够的空间来容纳要拷贝的字符串。 |
返回值
| 返回参数dest的字符串起始地址。 |
范例
| #include <string.h> main() { char a[30]="string(1)"; char b[]="string(2)"; printf("before strnact() :%s\n", a); printf("after strncat() :%s\n", strncat(a,b,6)); } |
执行
| before strnact() : string(1) after strncat() : string(1) string |
strncat 的实现:
char *strncat(char *dest, const char *src,size_t n)
{
char *dt= dest;
const char *sc = src;
if (dest == NULL || source == NULL)
{
printf("the input string is error!\n");
return NULL;
}
while (*dt++ != '\0')
;
dt--; //为了弥补等于'\0'后的还dest++
while (n--)
*dt++ = *sc++;
return dest;
}
strcat:
strcat(连接两字符串) | |
相关函数
| bcopy,memccpy,memcpy,strcpy,strncpy |
表头文件
| #include <string.h> |
定义函数
| char *strcat (char *dest,const char *src); |
函数说明
| strcat()会将参数src字符串拷贝到参数dest所指的字符串尾。第一个参数dest要有足够的空间来容纳要拷贝的字符串。 |
返回值
| 返回参数dest的字符串起始地址 |
范例
| #include <string.h.> main() { char a[30]="string(1)"; char b[]="string(2)"; printf("before strcat() : %s\n",a); printf("after strcat() : %s\n",strcat(a,b)); } |
执行
| before strcat () : string(1) after strcat () : string(1)string(2) |
strcat 的实现:
char *strcat(char *dest, const char *src)
{
char *dt= dest;
const char *sc = src;
if (dest == NULL || source == NULL)
{
printf("the input string is error!\n");
return NULL;
}
while (*dt++ != '\0')
;
dt--; //为了弥补等于'\0'后的还dest++
while (*dt++ = *sc++)
;
return dest;
}
strdup:
strdup(复制字符串) | |
相关函数
| calloc,malloc,realloc,free |
表头文件
| #include<string.h> |
定义函数
| char * strdup( const char *s); |
函数说明
| strdup()会先用malloc()配置与参数s字符串相同的空间大小,然后将参数s字符串的内容复制到该内存地址,然后把该地址返回。该地址最后可以利用free()来释放。 |
返回值
| 返回一字符串指针,该指针指向复制后的新字符串地址。若返回NULL表示内存不足。 |
范例
| #include<string.h> main() { char a[]="strdup"; char *b; b=strdup(a); printf("b[ ]=\"%s\"\n",b); } |
执行
| b[ ]="strdup" |
查找:memchr 、strchr 、index、strrchr 、rindex 、 strstr ------ 3+2+1
memchr:
memchr(在某一内存范围中查找一特定字符) | |
相关函数
| index,rindex,strchr,strpbrk,strrchr,strsep,strspn,strstr |
表头文件
| #include<string.h> |
定义函数
| void * memchr(const void *s,int c,size_t n); |
函数说明
| memchr()从头开始搜寻s所指的内存内容前n个字节,直到发现第一个值为c的字节,则返回指向该字节的指针。 |
返回值
| 如果找到指定的字节则返回该字节的指针,否则返回0。 |
范例
| #include <string.h> main() { char *s="0123456789012345678901234567890"; char *p; p=memchr(s,'5',10); printf("%p\n",p); } |
执行
| 5.68E+25 |
strchr:
strchr(查找字符串中第一个出现的指定字符) | |
相关函数 | index,memchr,rinex,strbrk,strsep,strspn,strstr,strtok |
表头文件 | #include<string.h> |
定义函数 | char * strchr (const char *s,int c); |
函数说明 | strchr()用来找出参数s字符串中第一个出现的参数c地址,然后将该字符出现的地址返回。 |
返回值 | 如果找到指定的字符则返回该字符所在地址,否则返回0。 |
范例 | #include<string.h> |
执行 | 5.68E+25 |
index:
index(查找字符串中第一个出现的指定字符) | |
相关函数
| rindex,srechr,strrchr |
表头文件
| #include<string.h> |
定义函数
| char * index( const char *s, int c); |
函数说明
| index()用来找出参数s字符串中第一个出现的参数c地址,然后将该字符出现的地址返回。字符串结束字符(NULL)也视为字符串一部分。 |
返回值
| 如果找到指定的字符则返回该字符所在地址,否则返回0。 |
范例
| #include<string.h> main() { char *s =”0123456789012345678901234567890”; char *p; p =index(s,’5’); printf(%s\n”,p); } |
执行
| 5.68E+25 |
strrchr:
strrchr(查找字符串中最后出现的指定字符)
相关函数
index,memchr,rindex,strpbrk,strsep,strspn,strstr,strtok
表头文件
#include<string.h>
定义函数
char * strrchr(const char *s, int c);
函数说明
strrchr()用来找出参数s字符串中最后一个出现的参数c地址,然后将该字符出现的地址返回。
返回值
如果找到指定的字符则返回该字符所在地址,否则返回0。
范例
#include<string.h>
main()
{
char *s="0123456789012345678901234567890";
char *p;
p=strrchr(s,'5');
printf("%p\n",p);
}
执行
567890
strrchr:
strrchr(查找字符串中最后出现的指定字符) | |
相关函数
| index,memchr,rindex,strpbrk,strsep,strspn,strstr,strtok |
表头文件
| #include<string.h> |
定义函数
| char * strrchr(const char *s, int c); |
函数说明
| strrchr()用来找出参数s字符串中最后一个出现的参数c地址,然后将该字符出现的地址返回。 |
返回值
| 如果找到指定的字符则返回该字符所在地址,否则返回0。 |
范例
| #include<string.h> main() { char *s="0123456789012345678901234567890"; char *p; p=strrchr(s,'5'); printf("%p\n",p); } |
执行
| 567890 |
rindex:
rindex(查找字符串中最后一个出现的指定字符) | |
相关函数
| index,memchr,strchr,strrchr |
表头文件
| #include<string.h> |
定义函数
| char * rindex( const char *s,int c); |
函数说明
| rindex()用来找出参数s字符串中最后一个出现的参数c地址,然后将该字符出现的地址返回。字符串结束字符(NULL)也视为字符串一部分。 |
返回值
| 如果找到指定的字符则返回该字符所在的地址,否则返回0。 |
范例
| #include <string.h> mian() { char *s ="0123456789012345678901234567890"; char *p; p=rindex(s,'5'); printf("%p\n",p); } |
执行
| 567890 |
strstr:
strstr(在一字符串中查找指定的字符串) | |
相关函数
| index,memchr,rindex,strchr,strpbrk,strsep,strspn,strtok |
表头文件
| #include<string.h> |
定义函数
| char *strstr(const char *haystack,const char *needle); |
函数说明
| strstr()会从字符串haystack 中搜寻字符串needle,并将第一次出现的地址返回。 |
返回值
| 返回指定字符串第一次出现的地址,否则返回0。 |
范例
| #include<string.h> main() { char * s="012345678901234567890123456789"; char *p; p= strstr(s,"901"); printf("%s\n",p); } |
执行
| 9.01E+21 |
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
const char *mystrstr(const char *dest, const char *search);
main()
{
char str[30] , fstr[10];
const char *finds;
printf("input a string str[20]:\n");
gets(str);
printf("input a string str[20]:\n");
gets(fstr);
printf("search %s in %s :\n",str,fstr);
finds = mystrstr(str,fstr);
if(finds)
printf("find ! in %d :%.*s\n",finds-str,strlen(fstr),finds);
else
printf("no find !\n");
}
const char *mystrstr(const char *dest, const char *search)
{
const char* dst = dest;
const char *sch = search;
int i;
if(dest == NULL ||search == NULL)
{
printf("the string be NULL\n");
return NULL;
}
while(*dst)
{
if(!strncmp(dst,sch,strlen(sch)))
return dst;
dst++;
}
return NULL;
}
输出:
input a string str[20]:
abcd 123 abcd m 12 m hj123 m
input a string str[20]:
12 m
search abcd 123 abcd m 12 m hj123 m in 12 m :
find ! in 16 :12 m
strcspn:
strcspn(返回字符串中连续不含指定字符串内容的字符数) | |
相关函数 | strspn |
表头文件 | #inclued<string.h> |
定义函数 | size_t strcspn ( const char *s,const char * reject); |
函数说明 | strcspn()从参数s字符串的开头计算连续的字符,而这些字符都完全不在参数reject 所指的字符串中。简单地说,若strcspn()返回的数值为n,则代表字符串s开头连续有n个字符都不含字符串reject内的字符。 |
返回值 | 返回字符串s开头连续不含字符串reject内的字符数目。 |
范例 | #include <string.h> |
执行 | 5 /*只计算到“ ”的出现,所以返回“Linux”的长度*/ |
strspn:
strspn(返回字符串中连续不含指定字符串内容的字符数) | |
相关函数
| strcspn,strchr,strpbrk,strsep,strstr |
表头文件
| #include<string.h> |
定义函数
| size_t strspn (const char *s,const char * accept); |
函数说明
| strspn()从参数s 字符串的开头计算连续的字符,而这些字符都完全是accept 所指字符串中的字符。简单的说,若strspn()返回的数值为n,则代表字符串s 开头连续有n 个字符都是属于字符串accept内的字符。 |
返回值
| 返回字符串s开头连续包含字符串accept内的字符数目。 |
范例
| #include<string.h> main() { char *str="Linux was first developed for 386/486-based PCs."; char *t1="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; printf("%d\n",strspn(str,t1)); } |
执行
| 5 /*计算大小写字母。不包含“ ”,所以返回Linux的长度。*/ |
比较:memcmp、strcmp、strncasecmp、strcasecmp
memcmp:
memcmp(比较内存内容) | |
相关函数
| bcmp,strcasecmp,strcmp,strcoll,strncmp,strncasecmp |
表头文件
| #include<string.h> |
定义函数
| int memcmp (const void *s1,const void *s2,size_t n); |
函数说明
| memcmp()用来比较s1和s2所指的内存区间前n个字符。字符串大小的比较是以ASCII码表上的顺序来决定,次顺序亦为字符的值。memcmp()首先将s1第一个字符值减去s2第一个字符的值,若差为0则再继续比较下个字符,若差值不为0则将差值返回。例如,字符串"Ac"和"ba"比较则会返回字符'A'(65)和'b'(98)的差值(-33)。 |
返回值
| 若参数s1和s2所指的内存内容都完全相同则返回0值。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0的值。 |
范例
| #include<string.h> main() { char *a ="aBcDeF"; char *b="AbCdEf"; char *c="aacdef"; char *d="aBcDeF"; printf("memcmp(a,b):%d\n",memcmp((void*)a,(void*) b,6)); printf("memcmp(a,c):%d\n",memcmp((void*)a,(void*) c,6)); printf("memcmp(a,d):%d\n",memcmp((void*)a,(void*) d,6)); |
执行
| memcmp(a,b):1 /*字符串a > 字符串b,返回 1*/ memcmp(a,c):-1 /*字符串a < 字符串c, 返回 -1*/ memcmp(a,d):0 /*字符串a =字符串d,返回 0*/ |
mymemcmp的实现:
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int mymemcmp(const void *s1, const void *s2 , size_t n);
main()
{
char str1[20];
char str2[20];
int flag,n;
printf("input a string[20]:\n");
gets(str1);
printf("input a string[20]:\n");
gets(str2);
n = strlen(str1)<strlen(str2)? strlen(str1) : strlen(str1)== strlen(str2)? strlen(str1):strlen(str2);
flag = mymemcmp(str1,str2,n);
if(flag<0)
printf("memory : %.*s lower than %.*s\n",n,str1,n,str2);
else if(flag >0)
printf("memory : %.*s upper than %.*s\n",n,str1,n,str2);
else
printf("memory : %.*s equel to %.*s\n",n,str1,n,str2);
}
int mymemcmp(const void *s1,const void *s2 , size_t n) //对内存的操作,void *一定要转为 char *来操作 !!!
{
const char *p1 = s1;
const char *p2 = s2;
if(s1 == NULL || s2 == NULL)
{
printf("the address be NULL\n");
return 0;
}
while(n--)
{
if(*p1 != *p2)
return *p1>*p2? 1:-1;
p1++;
p2++;
}
return 0;
}
strcmp:
strcmp(比较字符串) | |
相关函数
| bcmp,memcmp,strcasecmp,strncasecmp,strcoll |
表头文件
| #include<string.h> |
定义函数
| int strcmp(const char *s1,const char *s2); |
函数说明
| strcmp()用来比较参数s1和s2字符串。字符串大小的比较是以ASCII 码表上的顺序来决定,此顺序亦为字符的值。strcmp()首先将s1第一个字符值减去s2第一个字符值,若差值为0则再继续比较下个字符,若差值不为0则将差值返回。例如字符串"Ac"和"ba"比较则会返回字符"A"(65)和'b'(98)的差值(-33)。 |
返回值
| 若参数s1和s2字符串相同则返回0。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0 的值。 |
范例
| #include<string.h> main() { char *a="aBcDeF"; char *b="AbCdEf"; char *c="aacdef"; char *d="aBcDeF"; printf("strcmp(a,b) : %d\n",strcmp(a,b)); printf("strcmp(a,c) : %d\n",strcmp(a,c)); printf("strcmp(a,d) : %d\n",strcmp(a,d)); } |
执行
| strcmp(a,b) : 32 strcmp(a,c) :-31 strcmp(a,d) : 0 |
#include<stdlib.h>
#include<string.h>
int mystrcmp(const char *str1, const char *str2);
main()
{
char str1[20];
char str2[20];
int flag;
printf("input a string[20]:\n");
gets(str1);
printf("input a string[20]:\n");
gets(str2);
flag = mystrcmp(str1,str2);
if(flag<0)
printf("%s lower than %s\n",str1,str2);
else if(flag >0)
printf("%s upper than %s\n",str1,str2);
else
printf("%s equel to %s\n",str1,str2);
}
int mystrcmp(const char *str1, const char *str2)
{
const char *p1 = str1;
const char *p2 = str2;
if(str1 == NULL || str2 == NULL)
{
printf("the string be NULL\n");
return 0;
}
while(*p1 ||*p2)
{
if(*p1 != *p2)
return *p1>*p2? 1:-1;
p1++;
p2++;
}
if(*p1 != *p2) //因为有一个为'\0' = 0 ,这是为了判断哪一个为'\0' 哪一个不为'\0' ,这样就能判断出长度谁长了
return *p1>*p2? 1:-1;
return 0;
}
strncasecmp:
strncasecmp(忽略大小写比较字符串) | |
相关函数
| bcmp,memcmp,strcmp,strcoll,strncmp |
表头文件
| #include<string.h> |
定义函数
| int strncasecmp(const char *s1,const char *s2,size_t n); |
函数说明
| strncasecmp()用来比较参数s1和s2字符串前n个字符,比较时会自动忽略大小写的差异。 |
返回值
| 若参数s1和s2 字符串相同则返回0。s1 若大于s2则返回大于0的值,s1若小于s2则返回小于0 的值。 |
范例
| #include<string.h> main() { char *a="aBcDeF"; char *b="AbCdEf"; if(!strncasecmp(a,b)) printf("%s =%s\n",a,b); } |
执行
| aBcDef=AbCdEf |
strcasecmp:
strcasecmp(忽略大小写比较字符串) | |
相关函数
| bcmp,memcmp,strcmp,strcoll,strncmp |
表头文件
| #include<string.h> |
定义函数
| int strcasecmp (const char *s1, const char *s2); |
函数说明
| strcasecmp()用来比较参数s1和s2字符串,比较时会自动忽略大小写的差异。 |
返回值
| 若参数s1和s2字符串相同则返回0。s1长度大于s2长度则返回大于0 的值,s1 长度若小于s2 长度则返回小于0的值。 |
范例
| #include <string.h> main() { char *a="aBcDeF"; char *b="AbCdEf"; if(!strcasecmp(a,b)) printf("%s=%s\n",a,b); } |
执行
| aBcDeF=AbCdEf |
切割:
strtok:
strtok(分割字符串) | |
相关函数
| index,memchr,rindex,strpbrk,strsep,strspn,strstr |
表头文件
| #include<string.h> |
定义函数
| char * strtok(char *s,const char *delim); |
函数说明
| strtok()用来将字符串分割成一个个片段。参数s指向欲分割的字符串,参数delim则为分割字符串,当strtok()在参数s的字符串中发现到参数delim的分割字符时则会将该字符改为\0 字符。在第一次调用时,strtok()必需给予参数s字符串,往后的调用则将参数s设置成NULL。每次调用成功则返回下一个分割后的字符串指针。若是字符串中若是没有存在分割字符,则返回整个字符串; 即strtok实现二分字符串,用char *delim里头的任意字符作为分隔字符,当 char *s遇到delim中的字符时,此字符就变为“分隔刀”,将前一半字符串 首地址返回,将后一半字符串赋给char *s ,char *s有提供记忆功能,除非重新被赋为一个有效值,否则记录的是上一次切割下来的剩下的那段字符串的首地址。也就是说若要将一字符串string分隔成两串字符串并得到,则要strtok两次,并且后一次的strtok的char *s不赋新值,用NULL代替。 |
返回值
| 返回下一个分割后的字符串指针,如果已无从分割则返回NULL。 |
范例
| #include<string.h> main() { char s[]="ab-cd : ef;gh :i-jkl;mnop;qrs-tu: vwx-y;z"; char *delim="-: "; char *p; printf("%s ",strtok(s,delim)); while((p=strtok(NULL,delim)))printf("%s ",p); printf("\n"); } |
执行
| ab cd ef;gh i jkl;mnop;qrs tu vwx y;z /*-与:字符已经被\0 字符取代* |
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char * mystrtok(char *s,const char *delim);
main()
{
char s1[30] ,s2[30],finds[5];
char *p = NULL;
printf("input a string[30]:\n");
gets(s1);
strcpy(s2,s1);
printf("input a string[10]:\n");
gets(finds);
printf("use \"%s\" cut \"%s\" :\n",finds,s1);
printf("%s ",strtok(s1,finds));
while((p=strtok(NULL,finds))) printf("%s ",p);
printf("\n");
printf("%s ",mystrtok(s2,finds));
while((p=mystrtok(NULL,finds))) printf("%s ",p);
printf("\n");
}
char * mystrtok(char *s,const char *delim)
{
static char *sp;
const char * dep = delim;
int cut_flag = 0;
if(s != NULL)
sp = s; //第一次分割
else
s = sp; //继承前一次的分割
//若上次的分割刚好最后一个字符为分割字符,则此次的sp 指向的就是上一次字符串的末尾结束符'\0'
//那么就不该让它继续
if(!strlen(sp))
return NULL;
while(*sp)
{
while(*dep)
{
if(*dep == *sp)
{
*sp = '\0';
sp++;
cut_flag = 1;
break;
}
dep++;
}
dep = delim;
if(((sp-s) == 1) && cut_flag) //处理首字符就是切割字符的情况
{
s++;
cut_flag = 0;
continue;
}
else if(cut_flag)
break;
else
sp++;
}
return s;
}