自定义实现字符串处理函数 strlen strcmp strcpy strncpy strcat strncat strchr strstr

/******************************************************************************
 *  author : kangquan@scut2008
 *
 *  blog : http://blog.csdn.net/kangquan2008
 *
 *  discription: 自定义实现字符串处理函数 
 *  size_t strlen (const char * str);
 *  int strcmp (const char * src,const char * dst);
 *  char * strcat (char * dst, const char * src);
 *  char * strcpy(char * dst, const char * src);
 *  char * strncat (char * front,const char * back, size_t count);
 *  char * strncpy (char * dest, const char * source, size_t count);
 *  char * strchr (const char * string,int ch);
 *  char * strstr (const char * str1, const char * str2);
 *
 *****************************************************************************/
#include <stdio.h>
#include <stdlib.h>


size_t strlen (const char * str)
{
	const char * eos = str;
	
	while( *eos++ ); 
	// *eos == '\0' 时，还加1，因为strlen是不包含'\0'的，
	// 所以下面-1.
	
	return (eos - str - 1);// 不包含 '\0'
}

// ugly implement 
// 这个实现不是很好，首先没考虑const,然后返回值为有符号整数
int my_strlen ( char * str )
{
	int len = 0;

	while( *str++ )
		len++;

	return len;
}

int strcmp (const char * src,const char * dst)
{
	int ret;

	// 转为unsigned char，好处是？
	// 另外只判断 *dst != 0,因为此时已经有*src == *dst
	while( !(ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst )
		src++,dst++;

	if(ret < 0)
		ret = -1;
	else if(ret > 0)
		ret = 1;

	return ret;
}

// ugly implement
// 这个实现并不好，因为没有考虑strcat嵌套使用的情况，好的实现见strcat
char * my_strcat (char * dst, const char * src)
{
	while( *dst )
		dst++; // 移到末尾

	while( *dst++ = *src++);

	*dst = '\0'; // 记得是*dst = '\0';而不是dst = '\0'

	return dst;
}

char * strcat (char * dst, const char * src)
{
	char * tmp = dst;   // 设置临时变量，

	while( *dst )
		dst++; // 移到末尾

	while( *dst++ = *src++);

	*dst = '\0';

	return tmp;
}

char * strcpy(char * dst, const char * src)
{
	char * tmp = dst;

	while( *dst++ = *src++ )
		;

	return tmp;
}

char * strncat (char * dst,const char * src, size_t count)
{
	char * tmp = dst;

	while( *dst )
		dst ++;
	
	while( count-- ) // 先返回，后自增.count到1,则count个
		if( !( *dst++ = *src++ ) ) 
			return tmp;	 // 已经发现'\0',直接返回，不要再加'\0'
	
	*dst = '\0';

	return tmp;
}

char * strncpy(char * dst, const char * src, size_t count)
{
	char * tmp = dst;

	while( count && (*dst++ = *src++) )
		count --;

	if( !count )      // 复制了count个，加上'\0'
		*dst = '\0';
	else{
		while( --count ) // 在遇到'\0'且未复制够count个字符，补上'\0'
			*dst++ = '\0';
	}

	return tmp;
}
 
// '\0'也可以找
char * strchr (const char * string,int ch)
{
//	while( *string && *string++ != (char)ch ) // == 时还自增，这是不对的.
//		;

	while (*string && *string != (char)ch)
		string++;

	if(*string == (char)ch)
		return (char *)string;
	return NULL;
}


char * strstr (const char * str1, const char * str2)
{
	char * index = (char *)str1;
	char *s1,*s2;

	if( !*str2)
		return (char *)str1; // 要查找的为空，直接返回.

	while( *index )
	{
		s1 = index;
		s2 = (char *)str2;

		while( *s1 && *s2 && \
				!(*(unsigned char *)s1-*(unsigned char *)s2))
			s1++,s2++;

		if( !*s2 )
			return index;
		
		index++;
	}

	return NULL;
	
}

int main()
{
	char dst[] = "I come from ";
	char dst2[] = "I come from ";
	char src[] = "scut";
	char * tmp = NULL;
	char ch = 'c';
	char str[] = "from";

	printf("my_strlen: %d\n",my_strlen(dst));
	printf("strlen: %d\n",strlen(dst));
	my_strcat(dst,src);
	printf("my_strcat: %s\n",dst);
	printf("strcat: %s\n",strcat(dst,src));
	printf("strncat: %s\n",strncat(dst,src,3));
	printf("strcpy: %s\n",strcpy(dst,src));
	printf("strncpy: %s\n",strncpy(dst,src,3));
	printf("strchr: %s\n",strchr(dst,ch) ? strchr(dst,ch):"NULL" );
	printf("strstr: %s\n",strstr(dst2,str)? strstr(dst2,str):"NULL" );

	return 0;
}