atoi函数的实现（考虑不同进制、溢出）

最新推荐文章于 2023-03-10 20:13:06 发布
最新推荐文章于 2023-03-10 20:13:06 发布
阅读量656 收藏 1
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/veneno_one/article/details/118155772
版权

atoi就是将ASCII码表示的字符转换为int型数据

对于该函数的实现要考虑以下方面：
1、输入字符串为NULL；
2、输入开始是否包含符号’+’、’-’；
3、输入的字符是否合法（是否为’0’~‘9’）；
4、计算出的数值必须为unsigned int,才能判断是否溢出；
5、数据溢出的处理（上溢出时，反回最大正数；下溢出时，反悔最大负数）；
6、输入的字符包含空格；
7、进制的考虑，考虑16进制和8进制，通过开头为0或0x判断；
8、对于不同进制的判断范围不同；
对8进制：01234567
对10进制：0123456789
对16进制：0123456789ABCDEF或0123456789abcdef

#include <iostream>
#include <cmath>
using namespace std;

#define SIZE 100

//没有区别输入0与\0
//只能对十进制数进行转换
//没有处理溢出
int _atoi_1(char* str)
{
    if (NULL == str)    //输入合法性检查
    {
        cout << "NULL input" << endl;
        exit(0);
    }
     
    int sign = 0;
    int IntNumber = 0;

    while (*str)
    {
        if (0 == sign)
        {
            if ('-' == *str)
            {
                sign = -1;
                ++str;
            }
            else if ('+' == *str)
            {
                sign = 1;
                ++str;
            }
            else if (*str >= '0' && *str <= '9')
            {
                sign = 1;  //不更新str
            }
            else
            {
                cout << "invalid input!" << endl;
                exit(0);
            }
        }
        else if (*str >= '0' && *str <= '9')
        {
            IntNumber = IntNumber * 10 + *str - '0';
            ++str;
        }
        else
        {
            cout << "invalid input!" << endl;
            exit(0);
        }
    }

    return (sign * IntNumber);
}



//加上溢出处理
//并可对10进制、16进制以及8进制转换
//状态标志
bool IsNotNULL = true;
bool IsDigit = true;
bool IsNotOverflow = true;

int IsOverflow(unsigned long int IntNumber, int sign)
{
    unsigned long int MaxPositive = (long int)pow((float)2, (int)(8 * sizeof(long int) - 1)) - 1;

    if ((sign == 1) && !(IntNumber >= 0 && IntNumber <= MaxPositive))   //判断是否溢出
    {
        IsNotOverflow = true;
        return 1;
    }

    if ((sign == -1) && !(IntNumber > 0 && IntNumber <= (MaxPositive + 1)))   //判断是否溢出
    {
        IsNotOverflow = true;
        return -1;
    }

    return 0;
}

long int _atoi_2(char* str)
{
    if (NULL == str)
    {
        IsNotNULL = false;
        return 0;
    }

    int sign = 0;
    unsigned long int MaxPositive = (long int)pow((float)2, (int)(8 * sizeof(long int) - 1)) - 1;
    unsigned long int IntNumber = 0;   //要表示最小负数，须用unsigned long int，若用long int，其范围为-2^31到2^31 -1,不能表示2^31
    unsigned int base = 0;

    while (*str)
    {
        while (' ' == *str || '\t' == *str)     //忽略前导的空格或TAB
            ++str;

        if (0 == sign)  //判断数值的符号
        {
            if ('+' == *str)
            {
                sign = 1;
                ++str;
            }
            else if ('-' == *str)
            {
                sign = -1;
                ++str;
            }
            else if (isdigit(*str))
            {
                sign = 1;
            }
        }
        else
        {
            if (isdigit(*str))
            {
                if (0 == base)    //判断数值的进制
                {
                    if ('0' == *str && ('x' == *(str + 1) || 'X' == *(str + 1)))
                    {
                        base = 16;
                        str = str + 2;
                    }
                    else if ('0' == *str && !('x' == *(str + 1) || 'X' == *(str + 1)))
                    {
                        base = 8;
                        str = str + 1;
                    }
                    else
                    {
                        base = 10;   //不更新str
                    }
                }
                else
                {
                    IntNumber = IntNumber * base + *str - '0';

                    if (IsOverflow(IntNumber, sign) == 1)
                    {
                        return MaxPositive;
                    }

                    if (IsOverflow(IntNumber, sign) == -1)
                    {
                        return -((MaxPositive + 1));
                    }

                    ++str;
                }
            }
            else
            {
                IsDigit = false;
                return 0;
            }
        }
    }

    return (sign * IntNumber);   //如果为空串，也即第一个字符即为\0，返回值为0
}

//对不同的进制，判断的范围不同
//对16进制0123456789ABCDEF
//对8进制01234567
//对10进制0123456789
long int _atoi_3(char* str)
{
    if (NULL == str)    //输入合法性检查
    {
        IsNotNULL = false;
        return 0;
    }

    int sign = 0;
    unsigned long int IntNumber = 0;   //要表示最小负数，须用unsigned long int，若用long int，其范围为-2^31到2^31 -1,不能表示2^31
    unsigned long int MaxPositive = (long int)pow((float)2, (int)(8 * sizeof(long int) - 1)) - 1;
    unsigned int base = 0;

    while (*str)
    {
        while (' ' == *str || '\t' == *str)     //忽略前导的空格或TAB
            ++str;

        if (0 == sign)  //判断数值的符号
        {
            if ('+' == *str)
            {
                sign = 1;
                ++str;
            }
            else if ('-' == *str)
            {
                sign = -1;
                ++str;
            }
            else if (isdigit(*str))
            {
                sign = 1;
            }
            else
            {
                IsDigit = false;
                return 0;
            }
        }
        else
        {
            if (0 == base)    //判断数值的进制
            {
                if ('0' == *str && ('x' == *(str + 1) || 'X' == *(str + 1)))
                {
                    base = 16;
                    str = str + 2;
                }
                else if ('0' == *str && !('x' == *(str + 1) || 'X' == *(str + 1)))
                {
                    base = 8;
                    str = str + 1;
                }
                else
                {
                    base = 10;   //不更新str
                }
            }
            else
            {
                if (10 == base)
                {
                    if (isdigit(*str))
                    {
                        IntNumber = IntNumber * base + *str - '0';
                        if (IsOverflow(IntNumber, sign) == 1)
                        {
                            return MaxPositive;
                        }

                        if (IsOverflow(IntNumber, sign) == -1)
                        {
                            return -((MaxPositive + 1));
                        }
                        ++str;
                    }
                    else
                    {
                        IsDigit = false;
                        return 0;
                    }
                }
                else if (16 == base)
                {
                    if (isdigit(*str) || (*str >= 'a' && *str <= 'f') || (*str >= 'A' && *str <= 'F'))
                    {
                        if (isdigit(*str))
                        {
                            IntNumber = IntNumber * base + *str - '0';
                        }
                        else if (*str >= 'a' && *str <= 'f')
                        {
                            IntNumber = IntNumber * base + *str - 'a' + 10;
                        }
                        else if (*str >= 'A' && *str <= 'F')
                        {
                            IntNumber = IntNumber * base + *str - 'A' + 10;
                        }

                        if (IsOverflow(IntNumber, sign) == 1)
                        {
                            return MaxPositive;
                        }

                        if (IsOverflow(IntNumber, sign) == -1)
                        {
                            return -((MaxPositive + 1));
                        }
                        ++str;
                    }
                    else
                    {
                        IsDigit = false;
                        return 0;
                    }
                }
                else
                {
                    if (*str >= '0' && *str <= '7')
                    {
                        IntNumber = IntNumber * base + *str - '0';
                        if (IsOverflow(IntNumber, sign) == 1)
                        {
                            return MaxPositive;
                        }

                        if (IsOverflow(IntNumber, sign) == -1)
                        {
                            return -((MaxPositive + 1));
                        }
                        ++str;
                    }
                    else
                    {
                        IsDigit = false;
                        return 0;
                    }
                }
            }
        }
    }

    return (sign * IntNumber);   //如果为空串，也即第一个字符即为\0，返回值为0
}

//测试程序
int main()
{
    char str[SIZE];

    cout << "size of type int is : " << sizeof(int) << endl;   //4
    cout << "size of type long int is : " << sizeof(long int) << endl;    //4
    cout << "size of type float is : " << sizeof(float) << endl;    //4
    cout << "size of type long double is : " << sizeof(long double) << endl;    //8
    /*char str[SIZE] = "100278";
    char str[SIZE] = "+1267
    char str[SIZE] = "-12";
    char str[SIZE] = "+";
    char str[SIZE] = "-";
    char str[SIZE] = "";
    char str[SIZE] = "z98";
    char str[SIZE] = "-9s8";*/

    //test _atoi_1...
    cout << "test _atoi_1..." << endl;
    cout << "please enter the string :" << endl;
    while (cin >> str)
    {
        cout << "the string is :" << str << endl;
        cout << "the int number is : " << _atoi_1(str) << endl;
        cout << "please enter the string :" << endl;
    }

    cin.clear();
    cin.sync();
    cout << endl;

    //test _atoi_2...
    cout << "test _atoi_2..." << endl;
    cout << "please enter the string :" << endl;
    while (cin >> str)
    {
        cout << "the string is :" << str << endl;
        cout << "the int number is : " << _atoi_2(str) << endl;
        cout << "please enter the string :" << endl;
    }

    cin.clear();
    cin.sync();
    cout << endl;

    //test _atoi_3...
    cout << "test _atoi_3..." << endl;
    cout << "please enter the string :" << endl;
    while (cin >> str)
    {
        cout << "the string is :" << str << endl;
        cout << "the int number is : " << _atoi_3(str) << endl;
        cout << "please enter the string :" << endl;
    }

    return 0;
}

参考文献

veneno_one
关注
2021.11.21 进阶的atoi函数(进制转换)和strtol函数
weixin_58631717的博客
11-21 1611
1. 十六进制、十进制、八进制 #include<stdio.h> #include<stdlib.h> #include<ctype.h> #include<assert.h> static int to_Hex(const char *str)//十六进制函数 { //十六进制只有 0123456789abcdef/ABCDEF int sum = 0; while (isxdigit(*str))//isxdigit()判断是否为十六进制数
【atoi函数的功能介绍及使用与模拟实现——超详细版本】
最新发布
qq_73900397的博客
09-12 683
atoi函数的功能介绍及使用与模拟实现——超详细版本
itoa()、atoi()、任意进制转换
weixin_30887919的博客
04-05 536
头文件：<stdlib.h> itoa --功能：将任意类型的数字转换为字符串。在<stdlib.h>中与之有相反功能的函数是atoi。 atoi----功 能: 将字符串转换成整型数；atoi()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负号才开始做转换，而再遇到非数字或字符串时（'\0'）才结束转化，并将结果返回（返回转换后的整型数）。 用...
atoi函数的实现（十进制 十六进制的实现）
热门推荐
RopenYuan的专栏
03-14 1万+
#include int atoi(char * str) {         int value = 0;         int sign = 1;         int radix;         if(*str == '-')         {                 sign = -1;                 str++;
atoi函数的详细实现（考虑溢出）
辉
08-14 7710
atoi()函数的功能：将字符串转换成整型数。atoi()会扫描参数str字符串，跳过前面的空白字符，直到遇上数字或正负号才开始做转换，而再遇到非数字或字符串时（'\0'）才结束转化，并将结果返回（返回转换后的整型数）。 写atoi函数的时候需要注意一下几点 1. 忽略字符串前的空白字符 2. 字符串所表示数值的正负号 3. 结束条件，遇到非数字或者字符'\0'结束 4. 考虑溢
10进制，16进制的atoi
gmq_syy的博客
04-20 3641
#include #include int my_atoi(char * str) {//用于录入16进制的MAC地址 int value = 0; int sign = 1; int radix = 16; if(*str == '-') { sign = -1; str++; } // if(*str == ' ') //空格不录入 // ret
自己实现的atoi函数
03-27
这个实现不包括溢出检查，实际应用中可能需要考虑整数范围限制。 这个自定义的`atoi`函数有以下特点： 1. 只处理十进制数字。 2. 忽略前导空格。 3. 支持正负数。 4. 不处理非数字字符，遇到即停止转换。 在测试...
c语言，atoi函数的详解，以及atoi函数的模拟实现
qq_63250879的博客
03-10 574
c语言，atoi函数的详解，以及atoi函数的模拟实现 模拟实现atoi函数
atoi函数的实现(字符串转32位整数)两大巨坑
CppYyds的博客
04-16 993
文章目录关于aoti函数：代码实现： 关于aoti函数： 读入字符串并丢弃无用的前导空格 检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。 读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。 将前面步骤读入的这些数字转换为整数（即，“123” -> 123， “0032” -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。 如果整数数超过
c++实现atoi以及itoa函数
qq_33185750的博客
06-27 588
atoi函数 int atoi(char * str) 将字符串转为整形数，跳过前面的空格字符，直到遇上数字或者正负号才开始进行转换，而在遇到非数字或者字符’\0’结束转化，然后返回结果（int）。 当正溢出时返回INT_MAX,负溢出返回INT_MIN 题目思路比较简单，但是有挺多细节地方： 跳过前面的空格 使用stringstream >> string 正负号处理 将第一个有效字符单独拿出来讨论，为+，为-，为数字，为其他。 溢出处理 int的范围是[−231,231−1][-2^{31
字符串 转 16进制
08-28
字符串 转 16进制, 扩展了atoi的功能
atoi 十六进制_十六进制与十进制的互化
weixin_39887577的博客
11-02 1073
十六进制为计算机领域的一种重要的数制。 十六进制，逢16进1，每个数位上可以是：0、1、2、3、4、5、6、7、8、9、A(10)、B(11)、C(12)、D(13)、E(14)、F(15)，共16个大小不同的数字。 一个数位只能用一个数字，因此，十六进制数位上大于9的数字，只得一次用字母A、B、C、D、E、F表示。 十六进制转换成十进制的方法为：要从右到左用十六进...
任意进制的atoi()
一码算一码
02-28 1390
#include #include int main() { char a[] = "12ae"; char *p = &str[2]; int c; c = strtol(str, &p, 16);//16进制 if(!(*p)) { printf("0x%x, ", c ); } else {
atoi
梦想，就现在！
11-07 763
字符串转整形def atoi(str): if bool(str) == False: return 0 INT_MAX, INT_MIN = 2147483647, -2147483648 sign, base, i, n = 1, 0, 0, len(str) while i < n and str[i] == ' ': i = i
字符串转16进制_16、atoi-整数字符串转整数-leetcode8-中等
weixin_33289964的博客
01-30 541
思路：借助正则表达式。class Solution: def myAtoi(self, s: str) -> int: import re pattern = re.compile(r'^[-+]?d+') # 生成pattern s = s.lstrip() #去除左侧空格 num_str = pattern.find...
8. 字符串转换整数 (atoi)
二进制杯莫停的博客
07-23 343
8. 字符串转换整数 (atoi) 请你来实现一个 atoi 函数，使其能将字符串转换成整数。 首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。接下来的转化规则如下： 如果第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字字符组合起来，形成一个有符号整数。 假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成一个整数。 该字符串在有效的整数部分之后也可能会存在多余的字符，那么这些字符可以被忽略，它们对函数不应该造成影响。 注意：假如该字符
字符串转整数(atoi) 十进制实现
Net_Wolf_007的专栏
06-20 1557
atoi实现
C语言 字符串-数字转换函数整理
xiaolong0211的专栏
04-25 232
转自：http://blog.csdn.net/zuopai/article/details/2226612   atof(将字符串转换成浮点型数)atoi(将字符串转换成整型数)atol(将字符串转换成长整型数)strtod(将字符串转换成浮点数)strtol(将字符串转换成长整型数)strtoul(将字符串转换成无符号长整型数)toascii(将整型数转换成合法的ASCII 码字符)t...
C语言中atoi与atof函数详解及其区别
### atoi函数 `atoi`函数的定义如下： ```c int atoi(const char *str); ``` 它接受一个字符串参数`str`，这个字符串应该表示一个十进制整数。函数会扫描字符串，直到遇到非数字字符或字符串结束符`\0`为止。然后...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值