Question

我正在寻找一种可移植的方法来a）将字符串转换为64位有符号整数（int64_t），以及b）确定它是否适合（溢出）。有没有办法做到这一点？

Answer 1

strtoll已经非常便携了。如果不是在你的情况下，你可以随时使用GNU C运行时库并将其添加到项目......

errno = 0;
long long val = strtoll (string, NULL, 0);
if (errno == ERANGE)
   // there was an overflow conversion error

Answer 2

一次运行一个字符串的字符并生成整数。如果您正在解析的字符会导致溢出，那么您就知道您将要溢出。这段代码是基本的想法 - 不处理错误或负数，但应该给你一个想法......

bool ConvertToInt( const char* inString, int64_t& outInt )
{
    int64_t kInt64Max = 0x7fffffffffffffff;
    const char* c = inString;
    outInt = 0;
    while( *c != '\0' )
    {
          int charValue = *c - '0';
          //outInt will be assigned outInt * 10 + charValue, so to check if that will overflow
          //use algebra and move stuff around so that you can do the math without overflowing
          if( outInt > ( kInt64Max - charValue ) / 10 )
          {
               //overflow
               return false;
          }
          outInt = outInt * 10 + charValue;
          ++c;
    }
    return true;
}

如果您想要完成作业，请务必处理负数和非数字字符。 [编辑增加c ptr-感谢小费:)）

Answer 3

那么'长久'？签名的int64_可以保存从-9,223,372,036,854,775,808到9,223,372,036,854,775,807，你可以从字符串中看到它。例如，使用std :: string：

int stringLength;
string myString("123456789");
stringLength = myString.length();

该代码获取字符串的长度。要确定它是否溢出，只需检查位数，如果可能有溢出，请检查第一个数字。要转换为int64_，请使用强制转换：

http://www.learncpp.com/cpp-tutorial/44-type-conversion-and-casting/

该链接应该回答您的问题。（但是它适用于C风格的字符串。）最后一个澄清，你的字符串是否是std :: string？

Answer 4

为了迎合Visual C ++ 10.0（因为我写这篇11.0是测试版），显然没有strtoll或任何等价物，

#include <assert.h>     // assert
#include <errno.h>      // errno
#include <stdint.h>     // int64_t
#include <string>       // std::string
#include <stdexcept>    // std::runtime_error, std::range_error
#include <stdlib.h>     // EXIT_FAILURE, EXIT_SUCCESS, strtoll
#include <iostream>
using namespace std;

#if defined( _MSC_VER )
#   if _MSC_VER <= 1600
#       include <ole2.h>
        inline long long strtoll( char const *str, char **str_end, int base )
        {
            assert(( "Only base 10 for Visual C++ 10 and earlier", base == 10 ));
            std::wstring const  ws( str, str + strlen( str ) );
            LONG64          result;
            HRESULT const   hr    = VarI8FromStr(
                ws.c_str(), 0, LOCALE_NOUSEROVERRIDE, &result
                );
            switch( hr )
            {
            case S_OK:
                if( str_end != 0 )
                {
                    *str_end = const_cast<char*>( str + strlen( str ) );
                }
                return result;
            case DISP_E_OVERFLOW:
                errno = ERANGE;
                if( str_end != 0 )
                {
                    *str_end = const_cast<char*>( str );
                }
                return (*str == '-'? LLONG_MIN : LLONG_MAX);
            default:
                errno = EILSEQ;
                if( str_end != 0 )
                {
                    *str_end = const_cast<char*>( str );
                }
                return 0;
            }
        }
#   endif
#endif

template< class Type >
bool hopefully( Type const& v ) { return !!v; }

bool throwX( string const& s )      { throw runtime_error( s ); }
bool throwRangeX( string const& s ) { throw range_error( s ); }

int64_t int64From( string const& s )
{
    errno = 0;

    int64_t const   result  = strtoll( s.c_str(), nullptr, 10 );

    if( errno == ERANGE )
        throwRangeX( "int64From: specificed nr too large" );
    else if( errno != 0 )
        throwX( "int64From: parsing failed" );
    return result;
}

int main( int argc, char** argv )
{
    try
    {
        int64_t const x   = int64From( argv[argc - 1] );
        wcout << x << endl;
        return EXIT_SUCCESS;
    }
    catch( runtime_error const& x )
    {
        cerr << "!" << x.what() << endl;
    }
    return EXIT_FAILURE;
}

然后对于Visual C ++ 10及更早版本，请链接[oleaut32.lib]。

我用MinGW g ++和Visual C ++测试了这个。

PS：或者你只能istringstream，但它不能可靠地告诉你为什么它失败时失败 - 而且似乎要求检测溢出。

Answer 5

基于Joshua Glazer的有用回应，我提出了以下解决方案，它可以进行错误检查，也适用于负整数：

#define __STDC_LIMIT_MACROS
#include <stdint.h>

// convert a string to an integer, return whether successful
bool string_to_int(string in, int64_t &out) {
  size_t pos = 0;
  if (in.size() == 0)
    return false;
  if (in[pos] == '+')
    pos++;
    out = 0;
  if (in[pos] == '-') {
    pos++;
    while (pos < in.size()) {
      if (in[pos] < '0' || in[pos] > '9')
        return false;
      int c = in[pos]-'0';
      if (out < (INT64_MIN+c)/10)
        return false;
      out = out*10-c;
      pos++;
    }
  } else {
    while (pos < in.size()) {
      if (in[pos] < '0' || in[pos] > '9')
        return false;
      int c = in[pos]-'0';
      if (out > (INT64_MAX-c)/10)
        return false;
      out = out*10+c;
      pos++;
    }
  }
  return true;
}

确定一个数字（编码为字符串）是否适合C ++中的64位整数？

5 个答案: