题目：实现atof/atoi，考虑正负号

最新推荐文章于 2023-06-29 10:29:46 发布

lanmolei814

最新推荐文章于 2023-06-29 10:29:46 发布

阅读量2.5k

点赞数

分类专栏： Interview question

Interview question 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

一、Data Conversion
函数作用
atof把字符串转换为float型数字
atoi把字符串转换为int型数字
atol把字符串转换为long型数字
__toascii把字符转换为ascii码
tolower把字符转换为小写字符
toupper把字符转换为大写字符
abs取绝对值
strtod 
strtol 
 
二.atof
其实，这种字符串转换的函数，都无非做的同一件事情--解析字符串，根据不同的解析规则，执行不同的转换方式。
atof是借助strtod来实现的，主要步骤为：
1).解析空格  isspace
2).解析正负号  ‘+’or ‘-’
3).解析整数部分数字  isdigit
4).解析小数点及其后小数部分 
    5).解析科学计数部分
6).解析科学计数的正负号
7).还原组合数字
 
实现
 
       1: inline double tAtof(const tChar *pStr) 
       2: { 
       3:     return tStrtod(pStr, NULL); 
       4: } 
       5:   
       6: inline double tStrtod(const tChar *pStr, tChar **pEndStr) 
       7: { 
       8:     // advance beyond any leading whitespace 
       9:     while( ::isspace(*pStr) ) 
        ++pStr; 
   
    // check for optional '+' or '-' 
    unsigned short uNegative = 0; 
    if( *pStr == _T('-') ) 
    { 
        uNegative = 1; 
        ++pStr; 
    } 
    else if( *pStr == _T('+') ) 
        ++pStr; 
   
   
    double dRet = 0.0; 
    int e = 0; 
    int c = 0; 
   
    // 解析整数部分 
    while((c = *pStr) != _T('/0') && isdigit(c) ) 
    { 
        dRet = dRet * 10.0 + (c - _T('0'));  
        ++pStr; 
    } 
   
    // 解析小数部分 
    if( c == _T('.') ) 
    { 
        ++pStr; 
        while((c = *pStr) != _T('/0') && isdigit(c) ) 
        { 
            dRet = dRet * 10.0 + (c - _T('0')); 
            e -= 1; 
   
            ++pStr; 
        } 
    } 
   
    // 解析科学计数 
    if( c == 'e' || c == 'E' ) 
    { 
        int nSign = 1; 
        int nExponet = 0; 
   
        c = *++pStr; 
   
        // 解析正负号 
        if( c == _T('+') ) 
            c = *++pStr; 
        else if( c == _T('-') ) 
        { 
            nSign = -1; 
            c = *++pStr; 
        } 
   
        while( isdigit(c) ) 
        { 
            nExponet = nExponet * 10 + (c - _T('0')); 
            c = *pStr++; 
        } 
   
        e += nExponet * nSign; 
    } 
   
    // 还原组合数字 
    while(e > 0) 
    { 
        dRet *= 10.0; 
        --e; 
    } 
    while(e < 0) 
    { 
        dRet *= 0.1; 
        ++e; 
    } 
   
    return uNegative ? -dRet : dRet; 
} 
   
其实，思想挺简单的，只是有点长~。具体多琢磨琢磨就更清楚了。
测试
 
       1: tChar    *str = NULL; 
       2: double  value = 0; 
       3:   
       4: // An example of the atof function 
       5: // using leading and training spaces. 
       6: str = _T("  3336402735171707160320 "); 
       7: value = CY_CRT::tAtof( str ); 
       8: cout << value << endl; 
       9:   
// Another example of the atof function 
// using the 'd' exponential formatting keyword. 
str = _T("3.1412764583d210"); 
value = CY_CRT::tAtof( str ); 
cout << value << endl; 
   
// An example of the atof function 
// using the 'e' exponential formatting keyword. 
str = _T("-2309.12E-15"); 
value = CY_CRT::tAtof( str ); 
cout << value << endl; 
   
   
str = _T("-0.123e-10"); 
value = CY_CRT::tAtof( str ); 
cout << value << endl; 
   
三、atoi
 原理如下：
1）解析空格  tIsspace
2）判断正负号  ‘-’or  ’+’
3）strtol判断转换进制  16进制、8进制、10进制
4）解析数字字符
5）对每个字符转换为相应数字  tIsdigit  tIsalpha
6) 判断转换后的数字是否超过最大值
7）累加，基于转换进制
8）如果超过最大值则出错处理，负数就返回相反数
9）返回转换后的数字
实现
 
       1: inline int tAtoi(const tChar *pStr) 
       2: { 
       3:     return tStrtol(pStr, NULL, 10); 
       4: } 
       5:   
       6: inline long tStrtol(const tChar *pStr, tChar **pEndPtr, int nBase) 
       7: { 
       8:     /* 
       9:         Skip white space and pick up leading +/- sign if any. 
        If nBase is 0, allow 0x for hex and 0 for octal, else assume decimal 
        If nBase if already 16, allow 0x 
    */ 
   
    const tChar *pStrTmp = pStr; 
    int c = 0; 
   
     
    do  
    { 
        c = *pStrTmp++;            /* skip whitespace */ 
    } while (tIsspace(c)); 
   
    int nNegative = 0;            /* remember minus sign */ 
    if( c == _T('-') ) 
    { 
        nNegative = 1; 
        c = *pStrTmp++; 
    } 
    else if( c == _T('+') ) 
    { 
        c = *pStrTmp++;            /* skip sign */ 
    } 
   
    if( nBase < 0 || nBase == 1 || nBase > 36)  
    { 
        /* bad base! */ 
        if( pEndPtr ) 
            /* store beginning of string in endptr */ 
            *pEndPtr = const_cast(reinterpret_cast<const tChar *>(pStr)); 
        return 0L;              /* return 0 */ 
    } 
   
    // 判断当前是否转换为16进制 
    if( (nBase == 0 || nBase == 16) && 
        (c == _T('0')) && 
        (*pStrTmp == _T('x') || *pStrTmp == _T('X')) ) 
    { 
        c = pStrTmp[1]; 
        pStrTmp += 2; 
        nBase = 16; 
    } 
    // 是否转换为8进制 
    if( nBase == 0 ) 
        nBase = (c == _T('0') ? 8 : 10); 
   
   
    /* if our number exceeds this, we will overflow on multiply */ 
    unsigned long ulCutOff = 0; 
    int nCutLim = 0; 
   
    ulCutOff    = nNegative ? -(unsigned long)(LONG_MIN) : LONG_MAX; 
    nCutLim        = ulCutOff % static_cast<unsigned long>(nBase); 
    ulCutOff    /= static_cast<unsigned long>(nBase); 
   
   
    unsigned long acc =0; 
    int any = 0; 
    for(acc = 0, any = 0; ; c = *pStrTmp++) 
    { 
        /* convert c to value */ 
        if( tIsdigit(c) ) 
            c -= _T('0'); 
        else if( tIsalpha(c) ) 
            c -= tIsupper(c) ? _T('A') - 10 : _T('a') - 10; 
        else 
            break;         /* exit loop if bad digit found */ 
   
        if( c >= nBase ) 
            break; 
   
        /*    we now need to compute number = number * base + digval, 
            but we need to know if overflow occured.  This requires 
            a tricky pre-check.  
        */ 
        if( any < 0 || acc > ulCutOff || acc == ulCutOff && c > nCutLim ) 
            any = -1; 
        else     
        { 
            any = 1; 
            acc *= nBase; 
            acc += c; 
        } 
    } 
   
    if( any < 0 ) 
    { 
        /* we would have overflowed */ 
        acc = nNegative ? LONG_MIN : LONG_MAX; 
        //throw std::overflow_error("LONG_MIN or LONG MAX"); 
    } 
    /* negate result if there was a neg sign */ 
    else if( nNegative ) 
        acc = -acc; 
   
    if( pEndPtr != 0 ) 
        *pEndPtr = const_cast(reinterpret_cast<const tChar *>(any ? pStrTmp - 1: pStr)); 
   
    return acc; 
} 
   
 测试代码为
 
       1: tChar    *str = NULL; 
       2: int     value = 0; 
       3:   
       4: // An example of the atoi function. 
       5: str = _T("  -2309 "); 
       6: value = CY_CRT::tAtoi( str ); 
       7: wcout << value << endl; 
       8:   
       9: // Another example of the atoi function. 
str = _T("31412764"); 
value = CY_CRT::tAtoi( str ); 
wcout << value << endl; 
   

lanmolei814

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

函数	作用
atof	把字符串转换为float型数字
atoi	把字符串转换为int型数字
atol	把字符串转换为long型数字
__toascii	把字符转换为ascii码
tolower	把字符转换为小写字符
toupper	把字符转换为大写字符
abs	取绝对值
strtod
strtol