面试中常见C/C++库函数实现

<pre>
//@yansha:字串末尾要加结束符'\0'，不然输出错位结果
char *strncpy(char *strDes, const char *strSrc, unsigned int count)    
{    
    assert(strDes != NULL && strSrc != NULL);    
    char *address = strDes;    
    while (count-- && *strSrc != '\0')    
        *strDes++ = *strSrc++; 
*strDes = '\0';
    return address;    
} 


//查找字符串s中首次出现字符c的位置 
char *strchr(const char *str, int c) 
{ 
    assert(str != NULL); 
    for (; *str != (char)c; ++ str) 
        if (*str == '\0') 
            return NULL; 
return str; 
} 


int strcmp(const char *s, const char *t) 
{ 
    assert(s != NULL && t != NULL); 
    while (*s && *t && *s == *t) 
    { 
        ++ s; 
        ++ t; 
    } 
    return (*s - *t); 
} 


char *strcat(char *strDes, const char *strSrc) 
{ 
    assert((strDes != NULL) && (strSrc != NULL)); 
    char *address = strDes; 
    while (*strDes != '\0') 
        ++ strDes; 
    while ((*strDes ++ = *strSrc ++) != '\0') 
        NULL; 
    return address; 
} 


int strlen(const char *str) 
{ 
    assert(str != NULL); 
    int len = 0; 
    while (*str ++ != '\0') 
        ++ len; 
    return len; 
} 


//此函数，梦修改如下   
char *strdup_(char *strSrc)   
//将字符串拷贝到新的位置   
{   
    if(strSrc!=NULL)   
    {   
        char *start=strSrc;   
        int len=0;   
        while(*strSrc++!='\0')   
            len++;   

        char *address=(char *)malloc(len+1);   
assert(address != NULL);

        while((*address++=*start++)!='\0');    
        return address-(len+1);    
    }   
    return NULL;   
}   


//多谢laoyi19861011指正
char *strstr(const char *strSrc, const char *str) 
{ 
    assert(strSrc != NULL && str != NULL); 
    const char *s = strSrc; 
    const char *t = str; 
    for (; *strSrc != '\0'; ++ strSrc) 
    { 
        for (s = strSrc, t = str; *t != '\0' && *s == *t; ++s, ++t) 
            NULL; 
        if (*t == '\0') 
            return (char *) strSrc; 
    } 
    return NULL; 
} 


char *strncpy(char *strDes, const char *strSrc, unsigned int count)    
{    
    assert(strDes != NULL && strSrc != NULL);    
    char *address = strDes;    
    while (count -- && *strSrc != '\0')    
        *strDes ++ = *strSrc ++;    
    *strDes = '\0';
    return address;    
}    




char *strncat(char *strDes, const char *strSrc, unsigned int count) 
{ 
    assert((strDes != NULL) && (strSrc != NULL)); 
    char *address = strDes; 
    while (*strDes != '\0') 
        ++ strDes; 
    while (count -- && *strSrc != '\0' ) 
        *strDes ++ = *strSrc ++; 
    *strDes = '\0'; 
    return address; 
} 


int strncmp(const char *s, const char *t, unsigned int count) 
{ 
    assert((s != NULL) && (t != NULL)); 
    while (*s && *t && *s == *t && count --) 
    { 
        ++ s; 
        ++ t; 
    } 
    return (*s - *t); 
} 


char *strpbrk(const char *strSrc, const char *str) 
{ 
    assert((strSrc != NULL) && (str != NULL)); 
    const char *s; 
    while (*strSrc != '\0') 
    { 
        s = str; 
        while (*s != '\0') 
        { 
            if (*strSrc == *s) 
                return (char *) strSrc; 
            ++ s; 
        } 
        ++ strSrc; 
    } 
    return NULL; 
} 


int strcspn(const char *strSrc, const char *str) 
{ 
    assert((strSrc != NULL) && (str != NULL)); 
    const char *s; 
    const char *t = strSrc; 
    while (*t != '\0') 
    { 
        s = str; 
        while (*s != '\0') 
        { 
            if (*t == *s) 
                return t - strSrc; 
            ++ s; 
        } 
        ++ t; 
    } 
    return 0; 
} 


int strspn(const char *strSrc, const char *str) 
{ 
    assert((strSrc != NULL) && (str != NULL)); 
    const char *s; 
    const char *t = strSrc; 
    while (*t != '\0') 
    { 
        s = str; 
        while (*s != '\0') 
        { 
            if (*t == *s) 
                break; 
            ++ s; 
        } 
        if (*s == '\0') 
            return t - strSrc; 
        ++ t; 
    } 
    return 0; 
} 


char *strrchr(const char *str, int c) 
{ 
    assert(str != NULL); 
    const char *s = str; 
    while (*s != '\0') 
        ++ s; 
    for (-- s; *s != (char) c; -- s) 
        if (s == str) 
            return NULL; 
return (char *) s; 
} 


char* strrev(char *str) 
{ 
    assert(str != NULL); 
    char *s = str, *t = str, c; 
    while (*t != '\0') 
        ++ t; 
    for (-- t; s < t; ++ s, -- t) 
    { 
        c = *s; 
        *s = *t; 
        *t = c; 
    } 
    return str; 
} 


char *strnset(char *str, int c, unsigned int count) 
{ 
    assert(str != NULL); 
    char *s = str; 
    for (; *s != '\0' && s - str < count; ++ s) 
        *s = (char) c; 
    return str; 
} 


char *strset(char *str, int c) 
{ 
    assert(str != NULL); 
    char *s = str; 
    for (; *s != '\0'; ++ s) 
        *s = (char) c; 
    return str; 
} 


char *strtok(char *strToken, const char *str) 
{ 
    assert(strToken != NULL && str != NULL); 
    char *s = strToken; 
    const char *t = str; 
    while (*s != '\0') 
    { 
        t = str; 
        while (*t != '\0') 
        { 
            if (*s == *t) 
            { 
                *(strToken + (s - strToken)) = '\0'; 
                return strToken; 
            } 
            ++ t; 
        } 
        ++ s; 
    } 
    return NULL; 
} 


char *strupr(char *str) 
{ 
    assert(str != NULL); 
    char *s = str; 
    while (*s != '\0') 
    { 
        if (*s >= 'a' && *s <= 'z') 
            *s -= 0x20; 
        s ++; 
    } 
    return str; 
} 


char *strlwr(char *str) 
{ 
    assert(str != NULL); 
    char *s = str; 
    while (*s != '\0') 
    { 
        if (*s >= 'A' && *s <= 'Z') 
            *s += 0x20; 
        s ++; 
    } 
    return str; 
} 


void *memcpy(void *dest, const void *src, unsigned int count) 
{ 
    assert((dest != NULL) && (src != NULL)); 
    void *address = dest; 
    while (count --) 
    { 
        *(char *) dest = *(char *) src; 
        dest = (char *) dest + 1; 
        src = (char *) src + 1; 
    } 
    return address; 
} 


void *memccpy(void *dest, const void *src, int c, unsigned int count) 
{ 
    assert((dest != NULL) && (src != NULL)); 
    while (count --) 
    { 
        *(char *) dest = *(char *) src; 
        if (* (char *) src == (char) c) 
            return ((char *)dest + 1); 
        dest = (char *) dest + 1; 
        src = (char *) src + 1; 
    } 
    return NULL; 
} 


void *memchr(const void *buf, int c, unsigned int count) 
{ 
    assert(buf != NULL); 
    while (count --) 
    { 
        if (*(char *) buf == c) 
            return (void *) buf; 
        buf = (char *) buf + 1; 
    } 
    return NULL; 
} 


int memcmp(const void *s, const void *t, unsigned int count) 
{ 
    assert((s != NULL) && (t != NULL)); 
    while (*(char *) s && *(char *) t && *(char *) s == *(char *) t && count --) 
    { 
        s = (char *) s + 1; 
        t = (char *) t + 1; 
    } 
    return (*(char *) s - *(char *) t); 
} 


//@big：
//要处理src和dest有重叠的情况，不是从尾巴开始移动就没问题了。
//一种情况是dest小于src有重叠，这个时候要从头开始移动，
//另一种是dest大于src有重叠，这个时候要从尾开始移动。
void *memmove(void *dest, const void *src, unsigned int count) 
{
    assert(dest != NULL && src != NULL);
    void* ret = dst;
    char* pdest = (char*) dest;
    char* psrc = (char*) src;

//pdest在psrc后面，且两者距离小于count时，从尾部开始移动. 其他情况从头部开始移动
        if( pdst>psrc && (psrc+n)>pdst )
    {
        pdst += (n-1);
        psrc += (n-1);


        while(n>0){
            *pdst--=*psrc--;
            n--;
        }
    }
    else{
        while(n>0){
            *pdst++=*psrc++;
            n--;
        }
    }


    return ret;
}


void *memset(void *str, int c, unsigned int count) 
{ 
    assert(str != NULL); 
    void *s = str; 
    while (count --) 
    { 
        *(char *) s = (char) c; 
        s = (char *) s + 1; 
    } 
    return str; 
}

</pre>

<pre>
void* memcpy(void* dest, void* source, size_t count)
{
    void* ret = dest;
    int i=0;
    while( i<count )
    {
        *((char*)dest+i) = *((char*)source+i);
        i++;
    }
    return ret;
}


memmove - Copy source buffer to destination buffer
;
;Purpose:
;       memmove() copies a source memory buffer to a destination memory buffer.
;       This routine recognize overlapping buffers to avoid propogation.
;       For cases where propogation is not a problem, memcpy() can be used.
;
;   Algorithm:


    void* memmove(void* dest, void* source, size_t count)


   {


       void* ret = dest;




      if (dest <= source || dest >= (source + count))


       {


          //Non-Overlapping Buffers
         //copy from lower addresses to higher addresses


         while (count --)


               *dest++ = *source++;


     }


     else


     {


        //Overlapping Buffers
       //copy from higher addresses to lower addresses




       dest += count - 1;


       source += count - 1;


       while (count--)


                *dest-- = *source--;l


     }


      return ret;


   }
</pre>