string.c_char *mystrcat(char*p1,const char*p2)-CSDN博客

本文链接：https://blog.csdn.net/linbounconstraint/article/details/49206655

//拼接字符串，把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;
}