Konvertieren von hexadezimal-string mit führendem "0x" unterzeichnet short in C++?

Fand ich den code konvertiert eine hexadezimale Zeichenkette in einen signed int mit strtol, aber ich kann nicht finden, etwas für ein short int (2 bytes). Hier' mein Stück code :

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

Meine Idee ist, Lesen Sie eine Datei mit eine Breite von 2 Byte Werten (wie 0xFFEE), konvertieren Sie es in signed int und schreiben das Ergebnis in eine Ausgabedatei. Die Ausführungsgeschwindigkeit ist nicht ein Problem.

Ich könnte finden einige Möglichkeiten, um das problem zu vermeiden, aber ich würde gerne eine "one-line" - Lösung, so können Sie vielleicht helfen, für diese 🙂

Edit : Die Dateien wie folgt Aussehen :

0x0400
0x03fe
0x03fe
...

Edit : ich habe bereits versucht mit dem hex-Betreiber, aber ich habe noch zu konvertieren Sie die Zeichenfolge in eine ganze Zahl, vor so tun.

//This won't work as currentString is not an integer
myInt << std::hex << currentString.c_str();
  • Was macht deine input-Datei Aussehen? Es ist ziemlich schwer zu machen irgendwelche Empfehlungen, ohne diese Informationen.
  • bitte siehe strtol gibt lange , nicht signiert, int,
  • sscanf gibt ein int, aber der Rückgabewert von scanf-Familie Funktionen ist die Anzahl der Felder, die Sie erfolgreich konvertiert. Während ich Schätze die Werbung, die Sie transkribiert es falsch. 🙂
  • edit : my bad, ich wollte reduzieren Sie den code und nicht nicht Aussehen, was ich Tat - es war das Ende meines Arbeitstages 🙂
  • Es sieht aus wie Loki ist die einzige person, die tatsächlich die Frage beantworten.
InformationsquelleAutor gramm | 2009-09-28
  1. 3

    Haben Sie als sscanf mit "%hx" conversion-qualifier?

    • Oder, wenn Sie don ' T haben keine Besondere Notwendigkeit zur Verwendung von C++ - I/O-streams, gehen Sie direkt zu fscanf... Hängt davon ab, wie viel code, den du kontrollierst.
    • fscanf und sscanf sind, wie ich meistens. Ich habe ein Programm jetzt, dass liest CRC hex-strings ähnlich wie diese aus: sscanf(cstr_fileCRC, "%lX", &ul_fileCRC);
    • Die Frage ist tagged-C++. Plus, sscanf ist in der Regel verpönt, weil der sicherheitsrelevante Probleme es mit sich bringt.
    InformationsquelleAutor ChrisV
  2. 5

    Dieser sollte einfach sein:

    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";
}

    Während wir reden über die Dateien:

    Sollten Sie NICHT hierzu:

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

    Dies ist, weil, wenn Sie Lesen, die Letzte Zeile tut es NICHT legen Sie die EOF. Also, wenn Sie die Schleife um und Lesen Sie dann die Zeile nach der letzten Zeile getline() schlägt fehl, und Sie werden Dinge tun, auf das, was war in currentString aus der letzten Zeit, war es eingerichtet. So in-Effekt werden Sie verarbeitet die Letzte Zeile doppelt.

    Den richtigen Weg, um eine Schleife über eine Datei:

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

    Können Sie wahrscheinlich verwenden stringtream - Klasse >> operator mit dem hex-manipulator.

    • Genau das, was ich brauchte, es ist nur eine Zeile groß !
    • Man sollte sich wohl ein Beispiel geben. Die führenden 0x erscheint, um die Ursache zu analysieren, zu scheitern.
    InformationsquelleAutor Naveen
  4. 0
    //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[]= "0123456789ABCDEF";
        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"0123456789ABCDEF";
        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
}
    • Sie sind offensichtlich verrückt 🙂
    InformationsquelleAutor Lior Kogan
  5. -1

    Wenn Sie sicher sind, dass die Daten vertrauenswürdig aus currentString.c_str(), dann könnten Sie auch leicht tun

    myInt << std::hex << atoi(currentString.c_str());
    • Warum verwenden Sie die C-Funktionen als C++ - stream-schon macht die ganze Arbeit.
    • Die Frage ist tagged-C++, nicht C.
    InformationsquelleAutor Chaosteil
  6. -1

    Wenn Sie wissen, werden die Daten immer in diesem format, könnte man nicht nur etwas tun wie:

    myInt << std::hex << currentString.c_str() +2; //skip the leading "0x"
    • Hier der std::hex tut nichts, als es die Verarbeitung einer Zeichenfolge. Sie sind nur neu drucken die Zeichenfolge, die Sie Lesen (abzüglich der ersten beiden Zeichen).
    InformationsquelleAutor
Schreibe einen Kommentar