C中atoi和strcpy的自定义实现

　　这是两道经常考到的笔试题，看似简单的实现，其实专注到细节，还是有很多需要注意扣分的地方。

atoi实现：

#include <iostream>
#include<ctype.h>
using namespace std;

typedef enum status{
    OK,ERROR
}Status;

Status myErrno = ERROR;
int my_atoi(const char *p);
int main()
{
    char *mystr = "45678910";
    int ret = my_atoi(mystr);
    cout << ret << endl;
    return 0;
}

//实现atoi函数，将字符串转换为数字
int my_atoi(const char *p){
    myErrno = ERROR;
    if(NULL == p)
        return 0;

    int ret = 0;

    const char *temp = p;

    //判断如果是前几位为空格，则向前移动字符串位置
    while(isspace(*temp))
        temp++;

    //判断符号位，是否为负数
    bool minus = *temp=='-' ? true : false;

    //有符号位
    if('+' == *temp || '-' == *temp)
        ++temp;

    while(*temp != '\0'){
        if(isdigit(*temp)){ //是数字情况下
            if((!minus && ret > 0x7FFFFFFF) || (minus && -minus < 0x80000000)){
                //若当前数值范围超出int所能表达的范围
                myErrno = ERROR;
                return 0;
            }

            ret = ret*10 + (*temp++ - '0');
        }else{
            //某位不是数字
            myErrno = ERROR;
            return 0;
        }

    }

    if(*temp == '\0'){
        myErrno = OK;
    }

    return minus ? -ret : ret;
}

strcpy的实现：

//实现trcpy函数
char *my_strcpy(char *dest,const char *src){
    assert(dest != NULL && src != NULL);

    char *ret = dest;
    while((*dest++ = *src++) != '\0');

    return ret;
}

　　对于strcpy的实现，还是会有问题的，需要考虑到内存重叠的情况，比如:

　　char *str = 'abcde';

　　strcpy(str,str+1);　　//结果为bcde

　　strcpy(str+1,str);　　//期望结果：aabcde，但运行会报错，因为str内存有重叠，会把'\0'覆盖掉

 

　　但是如果调用系统中的strcpy是不会有这个问题，其实要解决这个问题需要配合memcpy来使用　　

char *my_strcpy(char *dest,const char *src){
    assert(dest != NULL && src != NULL);

    char *ret = dest;
    memcpy(dst,src,strlen(src)+1);  

    return ret;
}

 

　　至于memcpy的实现，建议参考 http://blog.csdn.net/gpengtao 这为大牛的实现：

void * my_memcpy(void *dst,const void *src,unsigned int count)
{
     assert(dst);
     assert(src);
     void * ret = dst;
     if (dst <= src || (char *)dst >= ((char *)src + count))//源地址和目的地址不重叠，低字节向高字节拷贝
     {
         while(count--)
         {
             *(char *)dst = *(char *)src;
             dst = (char *)dst + 1;
             src = (char *)src + 1;
         }
     }
     else                        //源地址和目的地址重叠，高字节向低字节拷贝
     { 
         dst = (char *)dst + count - 1;
         src = (char *)src + count - 1; 
         while(count--) 
         {
             *(char *)dst = *(char *)src;
             dst = (char *)dst - 1;
             src = (char *)src - 1;
         }
    }
    return ret;
}