C中atoi和strcpy的自定义实现

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

atoi实现：

 1 #include <iostream>

 2 #include<ctype.h>

 3 using namespace std;

 4 

 5 typedef enum status{

 6     OK,ERROR

 7 }Status;

 8 

 9 Status myErrno = ERROR;

10 int my_atoi(const char *p);

11 int main()

12 {

13     char *mystr = "45678910";

14     int ret = my_atoi(mystr);

15     cout << ret << endl;

16     return 0;

17 }

18 

19 //实现atoi函数，将字符串转换为数字

20 int my_atoi(const char *p){

21     myErrno = ERROR;

22     if(NULL == p)

23         return 0;

24 

25     int ret = 0;

26 

27     const char *temp = p;

28 

29     //判断如果是前几位为空格，则向前移动字符串位置

30     while(isspace(*temp))

31         temp++;

32 

33     //判断符号位，是否为负数

34     bool minus = *temp=='-' ? true : false;

35 

36     //有符号位

37     if('+' == *temp || '-' == *temp)

38         ++temp;

39 

40     while(*temp != '\0'){

41         if(isdigit(*temp)){ //是数字情况下

42             if((!minus && ret > 0x7FFFFFFF) || (minus && -minus < 0x80000000)){

43                 //若当前数值范围超出int所能表达的范围

44                 myErrno = ERROR;

45                 return 0;

46             }

47 

48             ret = ret*10 + (*temp++ - '0');

49         }else{

50             //某位不是数字

51             myErrno = ERROR;

52             return 0;

53         }

54 

55     }

56 

57     if(*temp == '\0'){

58         myErrno = OK;

59     }

60 

61     return minus ? -ret : ret;

62 }

strcpy的实现：

1 //实现trcpy函数

2 char *my_strcpy(char *dest,const char *src){

3     assert(dest != NULL && src != NULL);

4 

5     char *ret = dest;

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

7 

8     return ret;

9 }

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

　　char *str = 'abcde';

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

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

 

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

1 char *my_strcpy(char *dest,const char *src){

2     assert(dest != NULL && src != NULL);

3 

4     char *ret = dest;

5     memcpy(dst,src,strlen(src)+1);  

6 

7     return ret;

8 }

 

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

 1 void * my_memcpy(void *dst,const void *src,unsigned int count)

 2 {

 3      assert(dst);

 4      assert(src);

 5      void * ret = dst;

 6      if (dst <= src || (char *)dst >= ((char *)src + count))//源地址和目的地址不重叠，低字节向高字节拷贝

 7      {

 8          while(count--)

 9          {

10              *(char *)dst = *(char *)src;

11              dst = (char *)dst + 1;

12              src = (char *)src + 1;

13          }

14      }

15      else                        //源地址和目的地址重叠，高字节向低字节拷贝

16      { 

17          dst = (char *)dst + count - 1;

18          src = (char *)src + count - 1; 

19          while(count--) 

20          {

21              *(char *)dst = *(char *)src;

22              dst = (char *)dst - 1;

23              src = (char *)src - 1;

24          }

25     }

26     return ret;

27 }