模拟实现C库的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 ;

     }

输出结果：

巴特西

模拟实现C库的atoi、atof和itoa

1.函数atoi

2、模拟实现此函数

3、函数atof

4、模拟实现此函数

5、函数itoa

6、模拟实现此函数

最新文章

热门文章