C字符串处理函数的实现

C字符串处理函数的实现（Linux）
#include <stddef.h>
char * ___strtok = NULL;

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

	while ((*dest++ = *src++) != '\0')
		/* nothing */;
		return tmp;
}

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

	while (count-- && (*dest++ = *src++) != '\0')
		/* nothing */;

		return tmp;
}

char * strcat(char * dest, const char * src)
{
	char *tmp = dest;

	while (*dest)
		dest++;
	while ((*dest++ = *src++) != '\0')
		;
	return tmp;
}

char * strncat(char *dest, const char *src, size_t count)
{
	char *tmp = dest;
	if (count) {
		while (*dest)
			dest++;
		while ((*dest++ = *src++)) {
			if (--count == 0)
				break;
		}
	}

	return tmp;
}
int strcmp(const char * cs,const char * ct)
{
	register signed char __res;

	while (1) {
		if ((__res = *cs - *ct++) != 0 || !*cs++)  /*is !*cs++ necessary? incase more cmp*/
			break;
	}

	return __res;
}

int strncmp(const char * cs,const char * ct,size_t count)
{
	register signed char __res = 0;

	while (count) {
		if ((__res = *cs - *ct++) != 0 || !*cs++)
			break;
		count--;
	}

	return __res;
}

char * strchr(const char * s,char c)
{
	for(; *s != c; ++s)
		if (*s == '\0')
			return NULL;
	return (char *) s;
}

size_t strlen(const char * s)
{
	const char *sc;

	for (sc = s; *sc != '\0'; ++sc)
		/* nothing */;
		return sc - s;
}

size_t strnlen(const char * s, size_t count)
{
	const char *sc;

	for (sc = s; *sc != '\0' && count--; ++sc)
		/* nothing */;
		return sc - s;
}

size_t strspn(const char *s, const char *accept)
{
	const char *p;
	const char *a;
	size_t count = 0;

	for (p = s; *p != '\0'; ++p) {
		for (a = accept; *a != '\0'; ++a) {
			if (*p == *a)
				break;
		}
		if (*a == '\0')
			return count;
		++count;
	}

	return count;
}

char * strpbrk(const char * cs,const char * ct)
{
	const char *sc1,*sc2;

	for( sc1 = cs; *sc1 != '\0'; ++sc1) {
		for( sc2 = ct; *sc2 != '\0'; ++sc2) {
			if (*sc1 == *sc2)
				return (char *) sc1;
		}
	}
	return NULL;
}

char * strtok(char * s,const char * ct)
{
	char *sbegin, *send;

	sbegin  = s ? s : ___strtok;
	if (!sbegin) {
		return NULL;
	}
	sbegin += strspn(sbegin,ct);
	if (*sbegin == '\0') {
		___strtok = NULL;
		return( NULL );
	}
	send = strpbrk( sbegin, ct);
	if (send && *send != '\0')
		*send++ = '\0';
	___strtok = send;
	return (sbegin);
}

void * memset(void * s,char c,size_t count)
{
	char *xs = (char *) s;

	while (count--)
		*xs++ = c;

	return s;
}

char * bcopy(const char * src, char * dest, int count)
{
	char *tmp = dest;

	while (count--)
		*tmp++ = *src++;

	return dest;
}
void * memcpy(void * dest,const void *src,size_t count)
{
	char *tmp = (char *) dest, *s = (char *) src;

	while (count--)
		*tmp++ = *s++;

	return dest;
}

void * memmove(void * dest,const void *src,size_t count)
{
	char *tmp, *s;

	if (dest <= src) {
		tmp = (char *) dest;
		s = (char *) src;
		while (count--)
			*tmp++ = *s++;
	}
	else {
		tmp = (char *) dest + count;
		s = (char *) src + count;
		while (count--)
			*--tmp = *--s;  /*12345678*/
	}     /*12345678*/

	return dest;
}

int memcmp(const void * cs,const void * ct,size_t count)
{
	const unsigned char *su1, *su2;
	signed char res = 0;

	for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
		if ((res = *su1 - *su2) != 0)
			break;
	return res;
}

/*
* find the first occurrence of byte 'c', or 1 past the area if none
*/
void * memscan(void * addr, unsigned char c, size_t size)
{
	unsigned char * p = (unsigned char *) addr;

	while (size) {
		if (*p == c)
			return (void *) p;
		p++;
		size--;
	}
	return (void *) p;
}

void main(void)
{
	return;
}

补充strstr
char *
strstr (const char *haystack, const char *needle)
{
	char *result = (char *)NULL;
	if ((haystack != (char *)NULL) && (needle != (char *)NULL))
	{
		register int i;
		int hl = strlen (haystack);
		int nl = strlen (needle);
		for (i = 0; i < (hl - nl); i++)
			if (strncmp (haystack + i, needle, nl) == 0)
			{
				result = haystack + i;
				break;
			}
	}
	return (result);
}
还有 加州大学的：
char *strstr(const  char *string, const  char *substring)
{  
	const char  *a,  *b;  

	b = substring;  
	if (*b == 0)   
	{  
		return  (char*)string;  
	}  
	for( ; *string != 0; string += 1)
	{
		if (*string !=  *b)   
		{  
			continue;  
		}  
		a = string;  
		while ((*a++ == *b++) && (*b != 0) );

		if (*b == 0)
		{
			return (char*) string;
		}
		b = substring;
	}
}
最后是AT&T:
extern char*
strstr(register const char* s1, register const char* s2)
{
	register int		c1;
	register int		c2;
	register const char*	t1;
	register const char*	t2;
	if (s2)
	{
		if (!*s2)
			return (char*)s1;
		c2 = *s2++;
		while (c1 = *s1++)
			if (c1 == c2)
			{
				t1 = s1;
				t2 = s2;
				do
				{
					if (!*t2)
						return (char*)s1 - 1;
				} while (*t1++ == *t2++);
			}
	}
	return 0;
}
--------------------------------------------------------------------------
http://blog.csdn.net/wzbob/archive/2006/11/10/1377600.aspx
c和汇编实现 一些基本字符串处理函数
1. 将一个字符串(src)拷贝到另一个字符串(dest)，直到遇到NULL 字符后停止。
char *strcpy (char *dest, const char *src)
{
	_asm
	{
		pushf
			mov esi,src
			mov edi,dest
			cld  
l1: lodsb 
	stosb  
	test al,al 
	jne l1 
	popf
	}    
	return dest;   
}


2.拷贝源字符串count 个字节到目的字符串。
char *strncpy (char *dest, const char *src, int count)
{
	_asm{
		pushf
			mov esi,src
			mov edi,dest
			mov ecx,count
			cld  
l1: dec ecx 
	js l2  
	lodsb 
	stosb  
	test al,al 
	jne l1  
	rep stosb 
l2: popf
	}
	return dest;   
}

3.将源字符串拷贝到目的字符串的末尾处。
char *strcat (char *dest, const char *src)
{
	_asm {
		pushf
			mov esi,src
			mov edi,dest
			xor al,al
			mov ecx,0xffffffff
			cld  // 清方向位。
			repne scasb  
			dec edi  
l1: lodsb 
	stosb  
	test al,al 
	jne l1 
	popf
	}
	return dest;   
}

4.将源字符串的count 个字节复制到目的字符串的末尾处，最后添一空字符。
char *strncat (char *dest, const char *src, int count)
{
	_asm {
		pushf
			mov esi,src
			mov edi,dest
			xor al,al
			mov ecx,0xffffffff
			cld  
			repne scasb 
			dec edi 
			mov ecx,count 
l1: dec ecx
	js l2 
	lodsb  
	stosb 
	test al,al 
	jne l1  
l2: xor al,al 
	stosb  
	popf
	}
	return dest;  
}

5. 将一个字符串与另一个字符串进行比较。
int strcmp (const char *csrc, const char *ct)
{
	_asm{
		pushf
			mov edi,csrc
			mov esi,ct
			cld  
l1: lodsb 
	scasb  
	jne l2 
	test al,al 
	jne l1  
	xor eax,eax 
	jmp l3 
l2: mov eax,1 
	jl l3  
	neg eax 
l3: popf
	}
}

------------------------------------------------------------------------------------
1. strlen(),计算字符串长度 
int strlen(const char string) 
{ 
	int i=0; 
	while(string[i]) i++; 
	return i; 
} 
2. strcpy(), 字符串拷贝. 
char *strcpy(char *destination, const char *source) 
{ 
	while(*destinaton++=*source++); 
	return (destination-1); 
} 
3. strcat(), 字符串的连接. 
char *strcat(char *target,const char *source) 
{ 
	char *original=target; 
	while(*target) target++; // Find the end of the string 
	while(*target++=*source++); 
	return(original); 
} 
4. streql(), 判断两个字符串是否相等. 
int streql(char *str1,char *str2) 
{ 
	while((*str1==*str2)&&(*str1)) 
	{ 
		str1++; 
		str2++; 
	} 
	return((*str1==NULL)&&(*str2==NULL)); 
} 
5. strchr(), 在字符串中查找某个字符. 
char *strchr(const char *string,int letter) 
{ 
	while((*string!=letter)&(*string)) 
		string++; 
	return (string); 
} 
6. chrcnt(), 计算某个字符在字符串中出现的次数. 
int chrcnt(const char *string,int letter) 
{ 
	int count=0; 
	while(*string) 
		if(*string==letter)count++; 
	return count; 
} 
7. strcmp(), 判断两个字符串是否相等. 
int strcmp(const char *str1,const char *str2) 
{ 
	while((*str1==*str2)&&(*str1)) 
	{ 
		str1++; 
		str2++; 
	} 
	if((*str1==*str2)&&(!*str1)) //Same strings 
		return o; 
	else if((*str1)&&(!*str2)) //Same but str1 longer 
		return -1; 
	else if((*str2)&&(!*str1)) //Same but str2 longer 
	else 
	return((*str1>*str2)?-1:1); 
}