【C/C++】内存和字符操作整理
目录
在有关内存操作的函数中,其函数参数为void * ,按照ANSI标准,不能对void指针进行算法操作,即不能对void指针进行如p++的操作,所以需要转换为具体的类型指针来操作,例如char *。
注意:若是用使用strcpy、memset 、memcpy 等涉及到修改空间内容的函数或操作(如s[i] = ‘m’)时,要看看原有字符串的‘\0’ 有没有被覆盖掉,或者是cpy时没有将原字符串的尾部‘\0’赋值过来,如果这样的话,要手工给新字符串的末尾添一个‘\0’ 。
================================================================================================
内存清零memset
memset:
void *memset(void *s, int ch, size_t n);
第一个参数是内存起始地址,第二个参数是设置内存空间每个字节的值,第三个参数是设定的内存空间的长度(字节的个数,不是元素个数)。
memset()会将参数指针s所指的内存区域 的前n个字节以参数c填入,然后返回指向s的指针;
int ch 是填入一个字节的,是针对一个字节的值,所以c 的取值只能做到一个字节的空间0~255
因为是void *s ,所以是对一段内存的操作,不管这个内存存储的数据类型是什么,只要指定count大小,都将会将以buffer为起始地址的count字节的存储内容值统一赋为c 。
若我们将int ch = 0; 或int ch = '\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'就结束拷贝。
====================================================================================================================================
拷贝(3+2+2+1)
覆盖: memmove、memccpy、memcpy --3
覆盖:strncpy、strcpy --2
覆盖: strncat、strcat --2
生成:strdup --1
...................对于strcat 和 strcpy 只要空间允许,都会将‘\0’一起复制过去!!!
——能实现空间重叠的只有memmove;
——本身自己能完成字符串赋值的是strcpy
——memcpy和strncpy相对与字符串操作来说是完全相同的,即一段空间覆盖、手工添加'\0'、注意size_t n的大小限制、不能实现空间重叠
——memmove除了允许空间重叠,其它同memcpy和strncpy,即一段空间覆盖、手工添加'\0' ( dest[ n] = '\0')、注意size_t n的大小限制
——strcpy除了实现的是一个完整字符串赋值,还要考虑源字符串与目的字符串合法空间的大小关系,还有一定要遵守的是不能实现空间重叠;
——strncat、strcat其实和strncpy、strcpy的实现是一样的,只不过是将目的字符串指针dest改为字符串的尾部'\0'起始的地址而已,其它的与strncpy、strcpy一样,strncat也要手工添0,strncat和strcat大小也要控制,不过两个都不存在空间重叠的限制,因为dest为尾指针,目的空间是空的。
memcpy、memmove、memccpy、strncpy、strcpy、strncat、strcat都是在已有的字符串空间进行覆盖,是两个实体间部分空间的值的拷贝;但strdup 不一样,它是利用malloc、strcpy来克隆出另一个完完全全相同的字符串实体,只是原有字符串实体空间与新生成字符串实体空间的首地址不同,其它的大小和值都一样,新生成的字符串实体的首地址作为返回值。
——strdup完全没有限制,因为它是完成的是克隆的功能,利用了malloc 和strcpy
名词解释:
空间重叠:即目的字符串的开头不能与源字符串的结尾重叠,而目的字符串的末尾与原字符串的开头重叠是可以的!!!
大小关系:strcpy的大小关系,即是源字符串的大小(包括'\0')要小于目的字符串合法空间的大小——防溢出!
而其它的则是size_t n 要小于等于 (dest 的合法空间大小和src的合法空间大小)的最小值——否则无论n超出哪一个的大小,都会造成溢出!
手工加'\0': 即dest [ n]= '\0' ;
溢出: 即对非法空间进行的操作,造成不可预知的结果!
——原理是利用一个空间的值去覆盖另一个空间,而并不是复制。而没有被覆盖到的原字符串后面的字符仍然保留;若要实现字符串复制的话,则需要要手动添加一个'\0';
——size_t n 一定要注意它的值,最大不能超过(dest 的合法空间大小和src的合法空间)的最小值!!!
——除memmove以外,空间不能重叠,即目的字符串的开头不能与源字符串的结尾重叠,而目的字符串的末尾与 原字符串的开头重叠是可以的!!!
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 |
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:
void * memmove(void *dest,const void *src,size_t n);返回赋值后的dest指针。
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()。 |
memmove的实现:
void *memmove(void *v_dst, const void *v_src, __kernel_size_t c)
{
const char *src = v_src;
char *dst = v_dst;
if (!c) //都要先判断参数是否有效
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:
void *memccpy(void *dest, const void * src, int c,size_t n);返回指向dest中值为c的下一个字节指针。若没有返回值为0
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 |
strcpy、strncpy ------ 的原理其实并不是复制,而是覆盖。而没有被覆盖到的原字符串后面的字符仍然保留;
------还有就是:空间不重叠,即目的字符串的开头不能与源字符串的结尾重叠,而目的字符串的末尾与原字符串的开头重叠是可以的!!!
------ 若要做到用strncpy来实现字符串复制,则一定要在覆盖的末尾手动添加一个'\0';而strcpy本身会自动将源字符串的末尾'\0'一起复制过去;
说明其实本身能实现字符串赋值的只有strcpy , 而其他的都是一段空间的覆盖。
strncpy:
char * strncpy(char *dest,const char *src,size_t n);返回参数dest的字符串起始地址。
strncpy 的效果和 memcpy相对字符串来说其实是一模一样的!!!
——原理是利用一个空间的值去覆盖另一个空间,而并不是复制。而没有被覆盖到的原字符串后面的字符仍然保留;若要实现字符串复制的话,则需要要手动添加一个'\0';
——size_t n 一定要注意它的值,最大不能超过(dest 的合法空间大小和src的合法空间)的最小值!!!
——不能空间重叠,即目的字符串的开头不能与源字符串的结尾重叠,而目的字符串的末尾与 原字符串的开头重叠是可以的!!!
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) |
例子:——strncpy()实现的是覆盖,而至于目标后面没覆盖的空间并不会清空,而是保留原有值。若要实现字符串复制,则要手工添加'\0';
main()
{
int i;
//strcpy 和 strncpy 都只是进行覆盖,后面没有覆盖到的值仍存在
char gs[20];
//?memset(gs,0,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);
for(i = 0; i < 20; i++) //strcpy 和 strncpy 都只是进行覆盖,后面没有覆盖到的值仍存在
printf("%c", gs[i]); //后面的为乱码,说明gets并不会将后面的空值也赋为0,仅是前面的覆盖,所以说数组若未初始化则要马上清零是多么重要!
printf("\n");
}
输出:
input a string:
123456789
gs:123456789
123456789�U̶Y� //输出gs[i]
gs:4567 //输出手动补'\0'后的strncpy
45676789�U̶Y� //输出gs[i]
例子——size_t n 一定要注意它的值,最大不能超过(dest 的合法空间大小和src的合法空间)的最小值!!!
main()
{
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");
strncpy(gs + 3, ks, 20); //溢出了——改变了非法空间的内容,会造成不可预料的结果,甚至是程序崩溃
(gs + 3)[20] = '\0';
//若是想做的不是覆盖而是复制字符串,则一定要格外添加'\0'
printf("gs+3:%s\n", gs);
for(i = 3; i < 20; i++)
printf("%c", gs[i]);
printf("\n");
}
结果:程序崩溃!!
例子——不能空间重叠,即目的字符串的开头不能与源字符串的结尾重叠,而目的字符串的末尾与 原字符串的开头重叠是可以的!!!
strcpy:
strcpy——实现的真的是一个字符串复制,不过还要考虑源字符串与目的字符串合法空间的大小关系,而且一定要遵守的是不能实现空间重叠;
char *strcpy(char *dest,const char *src);返回参数dest的字符串起始地址。
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:
第一个参数dest要有足够的空间来容纳要拷贝的字符串-----否则会造成溢出,结果不可预知
char * strncat(char *dest,const char *src,size_t n);返回参数dest的字符串起始地址。
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:
该函数并不是完成如strncpy、strncpy、strcpy那样在已有的字符串空间进行覆盖,而是实实在在的字符串空间的一份拷贝,生成另一个实体,然后返回给一个无指向指针;
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" |
strdup的实现:
====================================================================================================================================
查找:
查找:memchr 、strchr 、strrchr -- 3 字符查找:返回第一次查找到的地址
查找:index、rindex -- 2 字符查找:返回最后一次查找到的地址
查找: strstr --1 字符串查找:返回第一次查找到的地址
memchr:
void * memchr(const void *s,int c,size_t n);
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:
char * strchr (const char *s,int c);
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 |
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 |
strstr的实现:
#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
(有n、无n)分大小写母,小写大于大写 (有n、无n)不分大小写,小写等于大写
memcmp:
int memcmp (const void *s1,const void *s2,size_tn);
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:
int strcmp(const char *s1,const char *s2);
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 |
strcmp的实现:
#include<stdio.h>
#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:
int strncasecmp(const char *s1,const char *s2,size_tn);
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:
int strcasecmp (const char *s1, const char *s2);
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 字符取代* |
mystrtok的实现:
#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;
}