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

  (andylin02)