与这个美丽的世界说再见的atoi——使用字符串来判断是否溢出

/*
题目1:(简答题:10.0分)
编程实现将字符串转换为整型数；
int my_atoi(const char *str);
1.遇到非数字字母，停止转换；
示例： str = “234.324” ; 返回值是234；
2.首先出现空格的字符串可以转换，转换开始后，遇到空格停止转换；
示例: str =" 342 456"; 返回值是342；
3.可以处理正负号；
示例： str = " +234.bad" ; 返回值是 234； str = " -342ab.234" ; 返回值是：-342；
4.可以处理八进制，和十六进制；
示例： str = " +0xff"; 返回值是 255； str = " 0123" ; 返回值是 83；
5 可以处理int 型溢出的情况；
示例； str = “567898765678987656789”; str = 2147483647; (INT_MAX 宏在 limits.h 头文件中）
str = "-234324665544325345325; str = - 2147483648; (INT_MIN 宏在limits.h 头文件中）
*/

#include <iostream>
#include <ctype.h>
#include <limits.h>
#include <stack>

using namespace std;

const  char * HEX_MAX = "7fffffff";
const  char * DEC_MAX = "2147483647";
const  char * OCT_MAX = "17777777777";
const  char * HEX_MIN = "80000000";
const  char * DEC_MIN = "2147483648";
const  char * OCT_MIN = "20000000000";
const  int HEX_LEN = 8;
const  int DEC_LEN = 10;
const  int OCT_LEN = 11;


//对字符创进行筛选，截取到有用的字符串,返回值为字符串有效长度，
//用来进行比较,16进制下，会将大写字母变成小写字母进行存储
int  Screen_str(char *des,const char*src,int sys)
{
    int i = 0;
    if(sys == 8)
    {
        while(src[i] != '\0' && isdigit(src[i]) && i <= OCT_LEN)
        {
            des[i] = src[i];
            ++i;
        }
    }
    else if(sys == 10)
    {
        while(src[i] != '\0' && isdigit(src[i]) && i <= DEC_LEN)
        {
            des[i] = src[i];
            ++i;
        }
    }
    else if(sys == 16) 
    {
        while(src[i] != '\0' && i <= HEX_LEN && (isdigit(src[i])|| isalnum(src[i])))
        {
            if(isdigit(src[i]))//如果是数字
            {
                des[i] = src[i];
            }
            else if(isalnum(src[i]))//如果是字母
            {
                char x = src[i];
                x = tolower(x);
                des[i] = x;
            }
            ++i;
        }
    }
    printf("%d\n",i);
    return i;
}


//判断是否发生越界问题，1发生越界，0刚好到达临界值，-1没发生越界
int Judge_boundary(const char*str,bool tag,int sys)
{
    char  tmp[12] = {0};
    int tmp_len = Screen_str(tmp,str,sys);
    if(sys == 10)
    {
        if(tmp_len  > DEC_LEN)
        {
            return 1;
        }
        else if(tmp_len  == DEC_LEN)
        {
            if(tag)
            {
                return strcmp(tmp, DEC_MAX);
            }
            else
            {
                return strcmp(tmp, DEC_MIN);
            }
        }
    }
    else if(sys == 8)
    {
        if(tmp_len  > OCT_LEN)
        {
            return 1;
        }
        else if(tmp_len  == OCT_LEN)
        {
            if(tag)
            {
                return strcmp(tmp, OCT_MAX);
            }
            else
            {
                return strcmp(tmp, OCT_MIN);
            }
        }
    }
    else if(sys == 16)
    {
        if(tmp_len  > HEX_LEN)
        {
            return 1;
        }
        else if(tmp_len  == HEX_LEN)
        {
            if(tag)
            {
                return strcmp(tmp, HEX_MAX);
            }
            else
            {
                return strcmp(tmp, HEX_MIN);
            }
        }
    }
    return -1;
}

//十进制
int  dec_atoi(const char*str,bool tag)
{
	int  sum = 0;
	int i = 0;
    if(Judge_boundary(str,tag,16) != -1)
    {
        if(tag)
        {
            return  INT_MAX;
        }
        return  INT_MIN;
    }
	while(str[i] != '\0' && isdigit(str[i]))
	{
        sum = sum*10+str[i] - '0';
        i++;
	}
	if(tag == false)
	{
		return sum*-1;
	}
	return sum;
}

//八进制
int oct_atoi(const char *str,bool tag)
{
	int sum = 0;
	int i = 0;
    if(Judge_boundary(str,tag,8) != -1)
    {
        if(tag)
        {
            return  INT_MAX;
        }
        return  INT_MIN;
    }
	while(str[i] != '\0' && isdigit(str[i]) && isdigit(str[i]) < 8)
	{
        sum = sum*8+str[i] - '0';
        i++;
	}
	if(tag == false)
	{
		return sum*-1;
	}
	return sum;
}


//十六进制的情况
int  hex_atoi(const char*str,bool tag)
{
	int  sum = 0;
	int i = 0;
    if(Judge_boundary(str,tag,16) != -1)
    {
        if(tag)
        {
            return  INT_MAX;
        }
        return  INT_MIN;
    }
	while(str[i] != '\0' && (isdigit(str[i]) || isalnum(str[i])))
	{
		char x = str[i] - '0';
		if(isdigit(str[i]))//如果是数字
		{
            sum = sum*16+str[i] - '0';
		}
		else if(isalnum(str[i]))//如果是字母
		{
			char x = str[i];
			x = tolower(x);
            sum = sum*16+(x-'a'+10);
        }
         i++;
	}
	if(tag == false)
	{
		return sum*-1;
	}
	return sum;
};


int  my_atoi(const char *str)
{
	if(str == NULL) return -1;
	int num = 0;
	bool flag = true;//1 + ,0 -
	while(*str == ' ') str++;
	while(*str != '\0')
	{
		if(*str == '-')
		{
			flag = false;
		}
		if(*str == '+')
		{
			flag = true;
		}
		if(*str == '0') 
		{
			if(*(str+1) == 'x' || *(str+1) == 'X')//十六进制
			{
				num = hex_atoi(str+2,flag);
				break;
			}
			else 
			{
				num = oct_atoi(str+1,flag);
				break;
			}
		}
		if(isdigit(*str))
		{
			num = dec_atoi(str,flag);
			break;
		}
		str++;
	}
	return num;
}

int main()
{
    char str[][20]= {"0xdadad65"};
    int n = sizeof(str)/sizeof(str[0]);
    for(int i = 0;i < n;++i)
    {
        cout<<str[i]<<"  -->  "<< my_atoi(str[i])<<endl;
    }
}