将带前导“0x”的十六进制字符串转换为C++中的带符号短符号？

Question

我发现使用strtol将十六进制字符串转换为signed int的代码，但我找不到短int（2字节）的内容。这里的代码我的作品：

while (!sCurrentFile.eof()) 
{ 
    getline (sCurrentFile,currentString); 
    sOutputFile<<strtol(currentString.c_str(),NULL,16)<<endl; 
} 

我的想法是读取文件用2个字节宽值（如0xFFEE），将其转换为符号的int和输出文件中写入结果。执行速度不是问题。

我能找到一些方法来避免这个问题，但我想用“一条线”的解决方案，所以也许你可以帮助这个:)

编辑：文件看起来是这样的：

0x0400 
0x03fe 
0x03fe 
... 

编辑：我已经尝试过使用十六进制运算符，但我仍然必须将字符串转换为整数，然后才能这样做。

// This won't work as currentString is not an integer 
myInt << std::hex << currentString.c_str(); 

Answer 1

您是否认为sscanf带有“％hx”转换限定符？

Answer 2

您可以使用stringtream类的>>操作符与十六进制操纵器。

Answer 3

如果你确定的数据可以从currentString.c_str()被信任，那么你可以很容易地也做

myInt << std::hex << atoi(currentString.c_str()); 

Answer 4

如果你知道数据总是要在该格式，不能你只是做是这样的：

myInt << std::hex << currentString.c_str() +2; // skip the leading "0x" 

Answer 5

这应该是简单的：

std::ifstream file("DataFile"); 
int    value; 

while(file >> std::hex >> value) // Reads a hex string and converts it to an int. 
{ 
    std::cout << "Value: " << std::hex << value << "\n"; 
} 

虽然我们TAL关于文件的国王：
你应该不做到这一点：

while (!sCurrentFile.eof()) 
{ 
    getline (sCurrentFile,currentString); 
    ... STUFF ... 
} 

这是因为当你读到最后一行它不设置EOF。所以，当你循环并在最后一行之后读取行时，getline（）将会失败，并且你将在上次创建时在currentString中做什么。因此，您将最后一行处理两次。

正确地遍历文件是：

while (getline(sCurrentFile,currentString)) 
{ 
    // If the get fails then you have read past EOF and loop is not entered. 
    ... STUFF ... 
} 

Answer 6

// convert unsigned-integer to it's hexadecimal string represention 
// 0x12345678 -> '12345678' 
// N is BYTE/WORD/UINT/ULONGLONG 
// T is char or wchar_t 
template <class N, class T> inline T* UnsignedToHexStr(N n    , // [i ] 
                 T* pcStr   , // [i/o] filled with string 
                 UINT nDigits  , // [i ] number of digits in output string/0 (auto) 
                 bool bNullTerminate) // [i ] whether to add NULL termination 
{ 
    if ((N)-1 < (N)1)    // if type of N is floating-point/signed-integer 
     if (::IsDebuggerPresent()) 
     { 
      ::OutputDebugString(_T("UnsignedToHexStr: Incorrect type passed\n")); 
      ::DebugBreak(); 
     } 

    if (!nDigits) 
     nDigits= GetUnsignedHexDigits(n); 

    if (1 == sizeof(T)) 
    { 
     const char _czIntHexConv[]= "ABCDEF"; 
     for (int i= nDigits-1; i>= 0; i--) 
     { 
      char* pLoc= (char*)&pcStr[i]; 
      *pLoc= _czIntHexConv[n & 0x0F]; 
      n >>= 4; 
     } 
    } 
    else 
    { 
     const wchar_t _czIntHexConv[]= L"ABCDEF"; 
     for (int i= nDigits-1; i>= 0; i--) 
     { 
      wchar_t* pLoc= (wchar_t*)&pcStr[i]; 
      *pLoc= _czIntHexConv[n & 0x0F]; 
      n >>= 4; 
     } 
    } 

    if (bNullTerminate) 
     pcStr[nDigits]= 0; 

    return pcStr; 
} 



// -------------------------------------------------------------------------- 
// convert unsigned-integer in HEX string represention to it's numerical value 
// '1234' -> 0x1234 
// N is BYTE/WORD/UINT/ULONGLONG 
// T is char or wchar_t 
template <class N, class T> inline bool HexStrToUnsigned(const T* pczSrc     , 
                 N&  n       , 
                 bool  bSpecificTerminator= false, // whether string should terminate with specific terminating char 
                 T  cTerminator  = 0 ) // specific terminating char 
{ 
    n= 0; 

    if (!pczSrc) 
     return false; 

    while ((32 == *pczSrc) || (9 == *pczSrc)) 
     pczSrc++; 

    bool bLeadZeros= *pczSrc == _T('0'); 
    while (*pczSrc == _T('0')) // skip leading zeros 
     pczSrc++; 

    BYTE nMaxDigits= 2*sizeof(N); 
    BYTE nDigits = 0   ; 

    while (true) 
    { 
     if ((*pczSrc >= _T('0')) && (*pczSrc <= _T('9'))) 
     { if (nDigits==nMaxDigits) return false; n= (n<<4) + (*pczSrc-_T('0') ); pczSrc++; nDigits++; continue; } 

     if ((*pczSrc >= _T('A')) && (*pczSrc <= _T('F'))) 
     { if (nDigits==nMaxDigits) return false; n= (n<<4) + (*pczSrc-_T('A')+10); pczSrc++; nDigits++; continue; } 

     if ((*pczSrc >= _T('a')) && (*pczSrc <= _T('f'))) 
     { if (nDigits==nMaxDigits) return false; n= (n<<4) + (*pczSrc-_T('a')+10); pczSrc++; nDigits++; continue; } 

     if (bSpecificTerminator) 
      if (*pczSrc != cTerminator) 
       return false; 

     break; 
    } 

    return (nDigits>0) || bLeadZeros; // at least one digit 
}