linux 下面字符串处理函数实现 抄来看一下 抄自［http://blog.csdn.net/BeWithLei/article/details/1719242］

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);
}