笔试题 字符串函数的实现(strcpy, strcat, strcmp, memset, memcpy, memmove)

字符串函数是笔试面试中最易被考到的了，有以下几点需要注意：

1. 总是判断传入指针是否为空；
2. 在有返回值的函数中要记得记录返回地址
3. 根据函数不同形参可能为const, 如strcpy的const char* pSrc
4. strncpy, memset等函数的最后形参(长度或要复制的字数)的类型，本文用int(因实现问题，若使用size_t，有更好的移植性，但写法上要注意)
5. memcpy及memmove函数要判断字符内存重叠的情况
6. 编码规范

另外一些其它人的建议，不确定是否好用

1. 判断指针为空时，要使用if(p==NULL), 而不是if(p)
2. 有导常时，使用throw而不是assert
3. 尽量使用指针的前移(++)，而不是前移(--)，程序不优雅

strcpy

char* strcpy(char* pDest, const char* pSrc)

{

    //要判断空

    if(pDest==NULL || pSrc==NULL)

        throw "Null Argument!";

    //注意记录

    char* pDestCpy = pDest;

    while((*pDestCpy++ = *pSrc++)!='\0')

        ;

    return pDest;

}

strncpy

char* strncpy(char* pDest, const char* pSrc, int size)

{

    assert(pDest!=NULL && pSrc!=NULL);

    assert(size>=0);

    char* pDestCpy = pDest;

    while(size-- && (*pDestCpy++ = *pSrc++)!='\0') 

        ;

    if(size>0)

        while(size--)

            *pDestCpy++='\0';

    return pDest;

}

注意：这种写法长度size类型不能为size_t，因为size_t原类型为unsigned int，当值为0的size_t变量在做--后，值为变成最大的int值; 后面同样

strcat

char* strcat(char* pDest, const char* pSrc)

{

    assert(pDest != NULL && pSrc!=NULL);

    char* pDestCpy = pDest + strlen(pDest);

    while((*pDestCpy++ = *pSrc++)!='\0') ;

    return pDest;    

}

strncat

char* strncat(char* pDest, char* pSrc, int size)

{

    assert(pDest!=NULL && pSrc!=NULL);

    assert(size>=0);

    char* pDestCpy = pDest + strlen(pDest);

    while(size-- && (*pDestCpy++ = *pSrc++)!='\0');

    return pDest;

}

memset

void* memset(void* pDest, int value, int size)

{

    assert(pDest!=NULL && size>=0);

    char* pDestCpy = (char*)pDest;

    while(size--)

        *pDestCpy++ = value;

    return pDest;

}

memcpy

void* memcpy(void* pDest, const void* pSrc, int size)

{

    assert(pDest!=NULL && pSrc!=NULL && size>=0);

    char* pDestCpy = NULL;

    char* pSrcCpy = NULL;

    //要复制的内存有重叠时,从后往前复制

    if(pSrc<pDest && (char*)pSrc+size>(char*)pDest)

    {

        pDestCpy = (char*)pDest+size-1;

        pSrcCpy = (char*)pSrc+size-1;

        while(size--)

            *pDestCpy-- = *pSrcCpy--;

    }

    else

    {

        pDestCpy = (char*)pDest;

        pSrcCpy = (char*)pSrc;

        while(size--)

            *pDestCpy++ = *pSrcCpy++;

    }

    return pDest;

}

memmove

void* memmove(void* dest, const void* src, int size)

{

    assert(dest!=NULL && src!=NULL && size>=0);

    char* pDest = (char*)dest;

    char* pSrc = (char*)src;

        //复制内容重叠时，从后往前复制

    if(pSrc<pDest && pSrc+size>pDest)

    {

        pDest+=size-1;

        pSrc+=size-1;

        while(size--)

            *pDest-- = *pSrc--;

    }

    else

    {

        while(size--)

            *pDest++ = *pSrc++;

    }

    return dest;

}