模拟实现库函数的atoi、atof和itoa

1.函数atoi

　atoi (表示 alphanumeric to integer)是把字符串转换成整型数的一个函数。广泛的应用在计算机程序和办公软件中。atoi( ) 函数会扫描参数 nptr字符串，跳过前面的空白字符（例如空格，tab缩进等）。

原型：int atoi(const char *nptr)，nptr：要进行转换的字符串；

功能：把字符串转换成整型数；

返回值：函数返回一个 int 值，此值由将输入字符作为数字解析而生成。 如果该输入无法转换为该类型的值，则atoi的返回值为 0。

说明：如果字符存在（如果是空格，会跳过，全是空格的话返回0），是数字或者正负号则开始做类型转换，当出现一个字符不能识别为数字时，函数将停止读入输入字符串，(包括结束符 \0) 字符时停止转换，返回整型数。否则，返回零。

使用示例：

 int main(void)
 {
     int s1, s2, s3, s4, s5, s6, s7;
     char *str1 = "12345.67";
     char *str2 = "     12345.67";
     char *str3 = "\012345.67";
     char *str4 = "\0 12345.67";
     char *str5 = "-12345";
     char *str6 = "abc-123";
     char *str7 = "-8362865623872387698";
     s1 = atoi(str1);
     s2 = atoi(str2);
     s3 = atoi(str3);
     s4 = atoi(str4);
     s5 = atoi(str5);
     s6 = atoi(str6);
     s7 = atoi(str7);
     printf("s1=%d\n", s1);
     printf("s2=%d\n", s2);
     printf("s3=%d\n", s3);
     printf("s4=%d\n", s4);
     printf("s5=%d\n", s5);
     printf("s6=%d\n", s6);
     printf("s7=%d\n", s7);
     getchar();
     return ;
 }

输出结果：

2、模拟实现此函数

 int my_atoi(const char* nptr)
 {
     int num = ;
     bool flag = false;
     while (*nptr == ' ')
     {
         nptr++;
     }
     if (*nptr == '-' || *nptr == ' ')
     {
         if (*nptr++ == '-')
             flag = true;
     }
     while (*nptr >= '' && *nptr <= '')
     {
         num = num *  + *nptr++ - '';
         if (num < )
         {
             num = ;
             break;
         }
     }
     return num*(flag ? - : );
 }

测试代码：

 int main(void)
 {
     int mys1, mys2, mys3, mys4, mys5, mys6, mys7;
     char *str1 = "12345.67";
     char *str2 = "     12345.67";
     char *str3 = "\012345.67";
     char *str4 = "\0 12345.67";
     char *str5 = "-12345";
     char *str6 = "abc-123";
     char *str7 = "-8362865623872387698";
     mys1 = my_atoi(str1);
     mys2 = my_atoi(str2);
     mys3 = my_atoi(str3);
     mys4 = my_atoi(str4);
     mys5 = my_atoi(str5);
     mys6 = my_atoi(str6);
     mys7 = my_atoi(str7);
     printf("s1=%d\n", mys1);
     printf("s2=%d\n", mys2);
     printf("s3=%d\n", mys3);
     printf("s4=%d\n", mys4);
     printf("s5=%d\n", mys5);
     printf("s6=%d\n", mys6);
     printf("s7=%d\n", mys7);
     getchar();
     return ;
 }

输出结果

3、函数atof

atof()，是C 语言标准库中的一个字符串处理函数，功能是把字符串转换成浮点数，所使用的头文件为<stdlib.h>。该函数名是 “ascii to floating point numbers” 的缩写。

函数原型：double atof(const char *nptr )，nptr：要转换的字符串；

功 能： 把字符串转换成浮点数；

返回值：每个函数返回 double 值，此值由将输入字符作为数字解析而生成。 如果该输入无法转换为该类型的值，则返回值为 0.0。

函数说明 ：atof()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时('\0')才结束转换，并将结果返回，nptr字符串可包含正负号、小数点或E(e)来表示指数部分。

使用示例：

 #include<stdlib.h>
 #include<stdio.h>
 int main()
 {
     double c;
     double d;
     char*a = "-100.23";
     char*b = "200e-2";
     char str[] = "123.456";
     d = atof(str);
     printf("str = %s\ndouble = %lf\n", str, d);
     c = atof(a) + atof(b);
     printf("a = %.2lf\nb = %.2lf\na + b = %.2lf\n", atof(a), atof(b), c);
     getchar();
     return ;
 }

输出结果为：

4、模拟实现此函数

 double my_atof(const char* nptr)
 {
     double sum = 0.0;
     double d = 10.0;
     int num = ;
     bool flag = false;
     while (*nptr == ' ')//当开始遇到空格时
     {
         nptr++;
     }
     if (*nptr == '-' || *nptr == '+')  //记录数字正负
     {
         if (*nptr == '-')
             flag = true;
         nptr++;
     }
     if (!(*nptr >= '' && *nptr <= ''))//如果一开始就为非数字则退出，返回0.0
     {
         return sum;
     }
     while (*nptr >= '' && *nptr <= '' && *nptr != '.') //计算小数点前整数部分
     {
         sum = sum*10.0 + *nptr - '';
         nptr++;
     }
     if (*nptr == '.')
     {
         nptr++;
     }
     while (*nptr >= '' && *nptr <= '')//计算小数部分
     {
         sum = sum + (*nptr - '') / d;
         d *= 10.0;
         nptr++;
     }
     if (*nptr == 'e' || *nptr == 'E')//考虑科学计数法
     {
         nptr++;
         char tmp = *nptr;
         if (tmp == '-' || tmp == '+')
         {
             nptr++;
             while (*nptr >= '' && *nptr <= '')
             {
                 num = num *  + *nptr - '';
                 nptr++;
             }
             while (num > )
             {
                 if (tmp == '-')
                 {
                     sum /= ;
                 }
                 else if(tmp == '+') {
                     sum *= ;
                 }
                 num--;
             }
         }
     }
     return sum*(flag ? -1.0 : 1.0);
 }

测试代码：

 int main()
 {
     char *s1 = "  123.456567567e+10";
     char *a1 = "  123.456567567e+10";
     char *s2 = "1234567.235e-10";
     char *a2 = "1234567.235e-10";
     char *s3 = "  123.45656\07567e-10";
     char *a3 = "  123.45656\07567e-10";

     double sum_1 = my_atof(s1);
     double sum1 = atof(a1);
     double sum_2 = my_atof(s2);
     double sum2 = atof(a2);
     double sum_3 = my_atof(s3);//遇到'\0'结束
     double sum3 = atof(a3);

     printf("my_atof:%lf\n", sum_1);
     printf("atof   :%lf\n", sum1 );
     printf("my_atof:%lf\n", sum_2);
     printf("atof   :%lf\n", sum2 );
     printf("my_atof:%lf\n", sum_3);
     printf("atof   :%lf\n", sum3 );
     getchar();
     return ;
 }

测试结果：

5、函数itoa

　　itoa（Integer to ASCII）是广泛应用的非标准C语言和C++语言扩展函数。由于它不是标准C/C++语言函数，所以不一定能在所有的编译器中使用。但是，大多数的编译器（如Windows上的）通常在<stdlib.h>/<cstdlib>头文件中包含这个函数。

原型：char *_itoa( int value, char *str, int radix )；

原型说明：value：欲转换的数据，string：目标字符串的地址，radix：转换后的进制数，可以是10进制、16进制等，范围必须在 2-36。

功能：将整数value 转换成字符串存入string 指向的内存空间 ,radix 为转换时所用基数(保存到字符串中的数据的进制基数)。

返回值：函数返回一个指向 str，无错误返回。

注意：itoa并不是一个标准的C函数，它是Windows特有的，如果要写跨平台的程序，请用sprintf。

使用示例：

 int main(void)
 {
     int number = ;
     char string[];
     _itoa(number, string, );//按十进制转换
     printf("integer=%d string=%s\n", number, string);
     _itoa(number, string, );//按16进制转换
     printf("integer=%d string=%s\n", number, string);
     getchar();
     return ;
 }

输出结果：

MSDN的例子：

 /*ITOA.C:Thisprogramconvertsintegersofvarious
 *sizestostringsinvariousradixes.
 */
 #include<stdlib.h>
 #include<stdio.h>
 int main(void)
 {
     char buffer[];
     int i = ;
     long l = -344115L;
     unsigned long ul = 1234567890UL;
     _itoa(i, buffer, );
     printf("String of integer%d(radix10):%s\n", i, buffer);
     _itoa(i, buffer, );
     printf("String of integer%d(radix16):0x%s\n", i, buffer);
     _itoa(i, buffer, );
     printf("String of integer%d(radix2):%s\n", i, buffer);
     _ltoa(l, buffer, );
     printf("String of long int%ld(radix16):0x%s\n", l, buffer);
     _ultoa(ul, buffer, );
     printf("String of unsigned long%lu(radix16):0x%s\n", ul, buffer);
     getchar();
     return ;
 }

输出结果：

6、模拟实现此函数

 char *my_itoa(int value, char *str, int radix)
 {
     int a[] = {  };
     int sum = value;
     char* cp = str;
     int i = ;
     char zm[] = "0123456789abcdefghijklmnopqrstuvwxyz";
     if (radix <  || radix > )//增加了对错误的检测
     {
         printf("error!");
         return str;
     }
     if (sum < ) //如果是负数，先转为正数
     {
         sum = -sum;
     }
     while (sum > )//从个位开始变为字符，直到最高位
     {
         a[i++] = zm[sum % radix];
         sum /= radix;
     }
     if (value < )//如果是负数，补上负号
     {
         *cp++ = '-';
     }
     for (int j = i - ; j >= ; j--)
     {
         *cp++ = a[j]; //从高位到低位转换
     }
     *cp = '\0';//最后加上字符串结束符
     return str;
 }

测试代码：

 int main(void)
 {
     char buffer[];
     int i = ;
     long l = 344115L;
     unsigned long ul = 1234567890UL;
     my_itoa(i, buffer, );
     printf("String of integer%d(radix10):%s\n", i, buffer);
     my_itoa(i, buffer, );
     printf("String of integer%d(radix16):0x%s\n", i, buffer);
     my_itoa(i, buffer, );
     printf("String of integer%d(radix2):%s\n", i, buffer);
     my_itoa(l, buffer, );
     printf("String of long int%ld(radix16):0x%s\n", l, buffer);
     my_itoa(ul, buffer, );
     printf("String of unsigned long%lu(radix16):0x%s\n", ul, buffer);
     getchar();
     return ;
 }

输出结果：

附：常用十进制的转换模拟函数

     #include <stdio.h>
     //反转字符串
     char *reverse(char *s)
     {
         char temp;
         char *p = s;    //p指向s的头部
         char *q = s;    //q指向s的尾部
         while(*q)
             ++q;
         q--;
         //交换移动指针，直到p和q交叉
         while(q > p)
         {
             temp = *p;
             *p++ = *q;
             *q-- = temp;
         }
         return s;
     }
     /*
      * 功能：整数转换为字符串
      * char s[] 的作用是存储整数的每一位
      */
     char *my_itoa(int n)
     {
         int i = ,isNegative = ;
         static char s[];      //必须为static变量，或者是全局变量
         if((isNegative = n) < ) //如果是负数，先转为正数
         {
             n = -n;
         }
         do      //从各位开始变为字符，直到最高位，最后应该反转
         {
             s[i++] = n% + '';
             n = n/;
         }while(n > );  

         if(isNegative < )   //如果是负数，补上负号
         {
             s[i++] = '-';
         }
         s[i] = '\0';    //最后加上字符串结束符
         return reverse(s);
     }
     int main(void)
     {
         int m;
         printf("请输入int型整数m：");
         scanf("%d",&m);
         printf("整数=%d,字符串=%s\n",m,my_itoa(m));
         return ;
     }  

输出结果：