string.c

心已赠人 2022-08-09 09:38 148阅读 0赞

//拼接字符串，把p2拼到p1后面
    char *mystrcat(char *p1,const char *p2)
    {
        if (p1 == NULL || p2 == NULL)
            return NULL;
        char *q = p1;
        while (*p1 != '\0')
            p1++;
        while ((*p1++ = *p2++) != '\0');
        return q;
    }

char *strcpy_1(char *dst,const char *src)
    {
    　　 while(*dst++=*src++);
    　　 return dst;
    　　 //notice: wrong return!!!! 
    } 
    //this is a fault function 
    //Left it to remind me never commit the same question 
    　　 
    char * strcpy_2(char * dst, const char * src)
    {
    　 char * cp = dst;//这样定义一个变量是有必要的 
    　 while( *cp++ = *src++ ) ; 
    　 return dst ;
    }
    　　
    　　 
    　　
    int mystrlen_1(const char *str)
    {
    	int i=0;
    	while(*str++)
    		i++;
    	return i;
    } 
    
    
    int mystrlen_2(const char *str)
    {
    	const char *p=str;
    	while(*str++);
    	
    	return (int)(str-p-1);
    } 
    　　
    　　 
    char *mystrcat(char *dst,const char *src)
    {
    	char *p=dst;
    	while(*p)//如果这里是*p++则p指向了'\0'的下一个位置 
    		++p;
    　　 
    	while(*p++ = *src++);
    	return dst;
    } 
    　　
    char *mystrncat(char *dst,const char *src,int n)
    {
    	char *p=dst;
    　　 while(*p)
    　　 ++p;
    　　 while((*p++=*src++)&&n--);
    　　 //注意：这里的 *p++=*src++两边得加括号
    　　 //逻辑 与 的优先级高于 赋值 
    　　 *p='\0';
    　　 return dst;
    } 
    　　
    char *mystrncpy (char *dst,const char *src,int n)
    {
    　　char *p=dst;
    　　while(n--&&(*p++=*src++));
    　　*p='\0';
    　　return dst;
    } 
    　　
    　　
    int mystrcmp( const char *dst,const char *src)
    {
    　　 //用dst去减src 
    　　 //int t='a'-'c';
    　　 int t=0;//=*dst - *src;
    　　 while(!(t=*dst - *src)&&*src)//notice!*src or *dst? 
    　　 		++dst,++src;
    　　 if(t>0)
    　　	 return 1;
    　　 if(t==0)
    　　	 return 0;
    　　 else 
    　　 	return -1;
    } 
    
    
    int my_strcmp(const char *source,const char *dest)
    {
    　　int ret = 0 ;
    　　
    　　 while( ! (ret = *( unsigned char *)source - *(unsigned char *)dest) && *dest) 
    　　//is it necessory to change const char * into unsigned char *???
    　　 		source++, dest++;
    　　
    　　 if ( ret < 0 )
     		ret = -1 ;
    　　else if ( ret > 0 )
    　	   ret = 1 ;
    　　return(ret);
    }
    　　
    	
    int mystrncmp(const char * dst,const char *src,int n)
    {
    　　 if(!n)
    　　 	return 0;
    　　 int t=0;//=*dst - *src;
    　　 while(n--&&!(t=*dst - *src)&&*src)//notice!*src or *dst? 
    　　 		++dst,++src;
    　　 if(t>0)
    　　 	return 1;
    　　 if(t==0)
    　　 	return 0;
    　　 else 
    　　 	return -1;
    } 
    　　
    int mystricmp( const char *dst,const char *src)
    {
    　　 //用dst去减src 不区分大小写 
    　　 
    　　 int t=0;//=*dst - *src;
    　　 while(!(t=(*dst - *src)%32)&&*src)//notice! *src or *dst? 
    　　 	++dst,++src; //小技巧：%32 
    　　 if(t>0)
    　　	 return 1;
    　　 if(t==0)
    　　 	return 0;
    　　 else 
    　　 	return -1;
    } 
    　　
    int mystrnicmp( const char *dst,const char *src,int n)
    {
    　　 //用dst去减src 不区分大小写 
    　　 if(!n)
    　　	 return 0;
    　　 int t=0;//=*dst - *src;
    　　 while(n--&&!(t=(*dst - *src)%32)&&*src)//notice! *src or *dst? 
    　　	 ++dst,++src; //小技巧：%32 
    　　 if(t>0)
    　　	 return 1;
    　　 if(t==0)
    　　	 return 0;
    　　 else 
    		 return -1;
    } 
    　　 
    　　 
    char *mystrchr(char * src,int c)
    {
    　　// Searches a string for a given character, which may be the null character 
    　　 
    　　 while(*src&&*src!=c)
    　　 	++src;
    　　 
    　　 if(*src==c)
    　　 	return src;
    　　 
    　　 else
    　　	 return NULL;
    } 
    　　
    	
    char *mystrrchr(char *src,int c)
    {
    　　 char *p=NULL;
    　　 while(*src)
    　　 {
    　　	 if(*src==c)
    　		 	p=src;
    　　 		++src; 
    　　 }
    　　 return p;
    } 
    　　
    　　
    char *mystrdup(const char *str)
    {
    　　 /* Allocates enough storage via malloc() for a copy of the string,
    　　 *copies the string into the new memory, 
    　　 *and returns a pointer to it. 
    　　 */
    　　 char *p;
    　　 if(!str)
    　　 	return NULL;
    　　 if( p=(char *)malloc((mystrlen(str)+1)*sizeof(char)) )
    　　 	return mystrcpy(p,str);
    　　 else
    　　 {
    　　 	printf("there is't enough memory!\n");
    　　 	exit(0);
    　　 }
    } 
    　　
    char *mystrlwr(char * str)
    {
    　　 /*change the upper string to lower
    　　 * notice:please call this function like this:
    　　 * char str[]="AAZZZsss";
    　　 * never to be:char *str="AAZZZsss";
    　　 * puts(mystrlwr);
    　　 */
    　　 char *p=str;
    　　 while(*p)
    　　 {
    　　 	if(*p>='A'&&*p<='Z')
    　　 	*p+=32;
    　　 	++p;
    　　 }
    　　 return str;
    } 
    　　 
    char *mystrupr(char *str)
    {
    　　 /*change the lower string to upper*/
    　　 char *p=str;
    　　 while(*p)
    　　 {
    　　 	if(*p>='a'&&*p<='z')
    　　 	*p-=32;
    　　 	++p;
    　　 }
    　　 return str;
    } 
    　　
    　　
    char *mystrset(char *src,int c)
    {
    　　 /*change all the strings tobe c*/
    　　 char *p=src;
    　　 while(*p)
    　　 	*p++=c;
    　　 return src;
    } 
    　　 
    char *mystrnset(char *src , int c,int count)
    {
    　　 /* Sets the first count characters of string the character value.
    　　 If the length of string is less than count, 
    　　 the length of string is used in place of n 
    　　 */ 
    　　 char *p=src;
    　　 	while(count--&&*p)
    　　 *p++=c;
    　　 
    　　 return src;
    } 
    　
    	　 
    int mystrspn(const char *str1,const char *str2)
    {
    　　 //get the first position which str1 don't contane str2;
    　　 const char *p=str1;
    　　 const char *t=str2;
    　　 while(*p)
    　　 {
    　　 	for(t=str2;*t;++t)
    　　 	{
    　　 		if(*p==*t)
    　　 		break;
    　　 	}
    　　 	if(!*t)
    　　 		break;
    　　 
    　　 	++p;
    　　 } 
    　　 return (p-str1); 
    　　 return (p-str1-1);
    } 
    　　 
    int mystrcspn(const char *str1,const char *str2)
    {
    　　 //get the first position which str1 contain str2'
    　　 const char *p=str1;
    　　 const char *t=str2;
    　　 /* for(;*p&&*t==0;++p)
    　　 {
    　　 t=str2;
    　　 while(*t)
    　　 {
    　　 if(*p==*t)
    　　 
    　　 break;
    　　 ++t;
    　　 } 
    　　 }
    　　 return (p-str1);*/
    　　 while(*p)
    　　 {
    　　 	for(t=str2;*t;++t)
    　　 	{
    　　 		if(*p==*t)
    　　 		break;
    　　 	}
    　　 	if(*t)
    　　 		break;
    　　 
    　　 	++p;
    　　 } 
    　　 return (p-str1); 
    } 
    　　 
    　　 
    char *mystrpbrk(const char *str1,const char *str2)
    　　{
    　　//return the point in str1 which contain the any char of str2 firstly
    　　//if not ,return the NULL ;
    　　 if(!*str1)
    　　 return NULL;
    　　 const char *p=str1;
    　　 const char *t=str2; 
    　　 while(*p)
    　　 {
    　　 	for(t=str2;*t;++t)
    　　 	{
    　　 		if(*p==*t)
    　　 			break;
    　　 	}
    　　 	if(*t)
    　　 		break;
    　　 
    　　 	++p;
    　　 } 
    
    　　 if(!*t)
    　　 	return NULL;
    　　 else 
    　　 	return (char *)p; 
    } 
    　　 
    　　
    char *mystrstr(const char *str1,const char *str2)
    {
    　　//return the point in str1 which contain the whole str2 firstly
    　　//notice 返回的是相同字符串在str1中的其实位置
    　　//如果没有，返回str1 
    　　 if(!*str1)//||!*str2)//如果str2为NULL则返回str1 
    　　 return NULL;
    　　 const char *p=str1;
    　　 const char *t=str2;
    　　 while(*p)
    　　 {
    　　 	const char *temp=p; 
    　　 	for(t=str2;*t;++t)
    　　 	{
    　　 		if(*t!=*temp)
    　　 		break;
    　　 		++temp;
    　　 	}
    　　 	if(!*t)
    　　 		break;
    　　 	++p;
    　　 } 
    
    　　if(!*p)
    　　 return NULL;
    　　else 
    　　 return (char *)p;
    } 
    　　 
    　　
    void *mymemset(void *str,int c,int count)
    {
    　　//初始化str前count个字符为c
    　　// 库函数中并没有对count进行检查 
    　　 void *p=str;
    　　 while(count--)//这里不能为(count--&&*(char *)p)如果dst初始化为{0}则不运行while 
    　　 {
    　　 	*(char *)p=(char)c;
    　　 	++p;
    　　 }
    　　 return str;
    } 
    　　 
    void *mymemcpy(void *dst , const void *src,int count)
    {
    　　//复制src中的前count个字符到dst中去
    　　 void *p=dst;
    　　 while(count--)//这里不能为(count--&&*(char *)p)如果dst初始化为{0}则不运行while 
    　　 	*(char *)p++=*(char *)src++;
    　　 
    　　 return dst;
    } 
    　　/*memmove考虑重叠。memmemcpy不考虑 
    　　*重叠通常就是三种情况，
    　　*一是目标区域的首地址落在源区域内；
    　　*二是目标区域的尾地址落在源区域内；
    　　*三是两个区域完全重叠。
    　　*只有第一种情况会出现意外！！！
    　　*memmove就是处理这种情况的，它判断后从后面往前复制！！！ 
    　　*/
    　　
    void *mymemmove(void *dst,const void *src,int count)
    {
    　　 void *p=dst;
    　　 if(dstsrc+count)
    　　 {
    　　 	while(count--)
    　　 	*(char *)p++=*(char *)src++;
    　　 }
    　　 else
    　　 {
    　　 	p+=count-1;//notice: why must be count-1 ?
    　　 	src+=count-1;
    　　 	while(count--)
    　　 		*(char *)p--=*(char *)src--;
    　　 } 
    　　 return dst; 
    } 
    　　
    　　
    　　
    　　
    void * mymemchr(const char * str,int c,int count)
    {
    　　//在str中的前count个字符中查找字符c，返回第一次出现c的指针。
    　　//如果没有找到则返回NULL
    　　 while(count--)
    　　 {
    　　 	if(*str==c)
    　　 		break;
    　　 	++str;
    　　 } 
    　　 return (++count ? (char *)str : NULL) ;
    } 
    　　
    int mymemcmp(const void *str1,const void *str2,int count)
    {
    　　//比较两个字符串前count个字符，如果str1>str2 return 1
    　　//str1　　//str1==str2 return 0 
    　　if(!count)
    　　 return 0;
    
    　　while(count--)
    　　{
    　　 if(*(char *)str1!=*(char *)str2)
    　　 		break;
    　　 ++str1;
    　　 ++str2;
    　　}
    
    　　if(*(char *)str1-*(char *)str2>0)
    　　 	return 1;
    　　else 
    　　 	if (*(char *)str1-*(char *)str2<0)
    　　 		return -1;
    　　 	else 
    　　 		return 0; 
    } 
    　　
    int mymemicmp(const void *str1,const void *str2,int count)
    {
    　　//比较两个字符串前count个字符，与mymemcmp的区别在于本函数不区分大小写 
    　　//如果str1>str2 return 1
    　　//str1　　//str1==str2 return 0 
    　　
    	if(!count)
    　　 return 0;
    	int t=0;
    　　
    	while(count--)
    　　{
    　　 t=(*(char *)str1-*(char *)str2)%32;
    　　 if(t)
    　　 	break;
    　　 ++str1;
    　　 ++str2;
    　　}
    
    　　
    	if(t>0)
    　　 return 1;
    　　
    	else 
    　　 if (t<0)
    　　 	return -1;
    　　 else 
    　　 	return 0; 
    } 
    　　
    
    
    void *mymemccpy(void * dst, const void *src,int c,int count)
    {
    　　//函数说明memccpy()用来拷贝src所指的内存内容前n个字节到dest所指的地址
    　　//上。与memcpy()不同的是，memccpy()会在复制时检查参数c是否出
    　　//现，若出现则返回dest中值为c的下一个字节地址。
    　　//返回值返回指向dest中值为c的下一个字节指针。返回值为0表示在src所指
    　　//内存前n个字节中没有值为c的字节。
    　　
    　　 while(count)
    　　 {
    　　 	*(char *)dst++=*(char *)src;
    　　 	if(*(char *)src==c)
    　　 		break;
    　　 	++src;
    　　 	--count; 
    　　 } 
    　　
    	 return (count ? dst : NULL);
    } 
    　　
    　　
    　　
    char *re_str(char *str)
    {
    　　 //将字符串逆续输出 
    　　 //printf("dfs");
    　　 char *start=str;
    　　 char *left=str;
    　　 while(*str++);
    　　 	str-=2;//注意这里！！！！ 
    　　 // printf("%c\n",*str);
    
    　　 while(left)　　 
    	{
    　　 	char c=*left;
    　　 	*left++=*str;
    　　 	*str=c;
    　　 	--str;
    　　 }
    　　 return start;
    }

string.c

发表评论取消回复

还没有评论，来说两句吧...

相关阅读