C++ convertir cadena hexadecimal a entero con signo

Para un método que funcione con C y C++, es posible que desee considerar el uso de la función de biblioteca estándar strtol().

#include <cstdlib>
#include <iostream>
using namespace std;

int main() {
    string s = "abcd";
    char * p;
    long n = strtol( s.c_str(), & p, 16 );
    if ( * p != 0 ) { //my bad edit was here
        cout << "not a number" << endl;
    }
    else {
        cout << n << endl;
    }
}

Andy Buchanan, en cuanto a C++, me gustó el tuyo, pero tengo algunos mods:

template <typename ElemT>
struct HexTo {
    ElemT value;
    operator ElemT() const {return value;}
    friend std::istream& operator>>(std::istream& in, HexTo& out) {
        in >> std::hex >> out.value;
        return in;
    }
};

Usado como

uint32_t value = boost::lexical_cast<HexTo<uint32_t> >("0x2a");

De esa manera no necesitas un impl por tipo int.

El ejemplo de trabajo con strtoul será:

#include <cstdlib>
#include <iostream>
using namespace std;

int main() { 
    string s = "fffefffe";
    char * p;
    long n = strtoul( s.c_str(), & p, 16 ); 
    if ( * p != 0 ) {  
        cout << "not a number" << endl;
    }    else {  
        cout << n << endl;
    }
}

strtol convierte string a long. En mi computadora numeric_limits<long>::max() da 0x7fffffff. Obviamente que 0xfffefffe es mayor que 0x7fffffff. Así que strtol devuelve MAX_LONG en lugar del valor deseado. strtoul convierte string a unsigned long por eso no hay desbordamiento en este caso.

Ok, strtol está considerando la cadena de entrada no como un entero con signo de 32 bits antes de la conversión. Muestra divertida con strtol:

#include <cstdlib>
#include <iostream>
using namespace std;

int main() { 
    string s = "-0x10002";
    char * p;
    long n = strtol( s.c_str(), & p, 16 ); 
    if ( * p != 0 ) {  
        cout << "not a number" << endl;
    }    else {  
        cout << n << endl;
    }
}

El código anterior imprime -65538 en la consola.

Aquí hay un método simple y de trabajo que encontré en otro lugar:

string hexString = "7FF";
int hexNumber;
sscanf(hexString.c_str(), "%x", &hexNumber);

Tenga en cuenta que puede preferir usar unsigned long integer/long integer, para recibir el valor. Otra nota, la función c_str () simplemente convierte la cadena std::a const char* .

Así que si tiene un const char* listo, simplemente siga adelante con el uso de ese nombre de variable directamente, como se muestra a continuación [También estoy mostrando el uso de la variable larga sin signo para un número hexadecimal más grande. No lo confunda con el caso de teniendo const char* en lugar de string]:

const char *hexString = "7FFEA5"; //Just to show the conversion of a bigger hex number
unsigned long hexNumber; //In case your hex number is going to be sufficiently big.
sscanf(hexString, "%x", &hexNumber);

Esto funciona perfectamente bien (siempre que utilice los tipos de datos adecuados según sus necesidades).

Tuve el mismo problema hoy, así es como lo resolví para poder mantener lexical_cast

typedef unsigned int    uint32;
typedef signed int      int32;

class uint32_from_hex   // For use with boost::lexical_cast
{
    uint32 value;
public:
    operator uint32() const { return value; }
    friend std::istream& operator>>( std::istream& in, uint32_from_hex& outValue )
    {
        in >> std::hex >> outValue.value;
    }
};

class int32_from_hex   // For use with boost::lexical_cast
{
    uint32 value;
public:
    operator int32() const { return static_cast<int32>( value ); }
    friend std::istream& operator>>( std::istream& in, int32_from_hex& outValue )
    {
        in >> std::hex >> outvalue.value;
    }
};

uint32 material0 = lexical_cast<uint32_from_hex>( "0x4ad" );
uint32 material1 = lexical_cast<uint32_from_hex>( "4ad" );
uint32 material2 = lexical_cast<uint32>( "1197" );

int32 materialX = lexical_cast<int32_from_hex>( "0xfffefffe" );
int32 materialY = lexical_cast<int32_from_hex>( "fffefffe" );
// etc...

(Encontré esta página cuando estaba buscando una manera menos sucky: -)

Saludos, A.

Esto funcionó para mí:

string string_test = "80123456";
unsigned long x;
signed long val;

std::stringstream ss;
ss << std::hex << string_test;
ss >> x;
// ss >> val;  // if I try this val = 0
val = (signed long)x;  // However, if I cast the unsigned result I get val = 0x80123456 

Otro método

using namespace System;

template <typename NUM>
NUM hexstr2num(String^ h)
{
    NUM v=0;
    String^ k=L"0123456789ABCDEF";
    short l=h->Length;
    char off;
    h=h->ToUpper();

    if(h->Substring(0,1)!=L"H")
        {if(h->Substring(0,2)==L"0X") off=2;}
    else
        {off=1;}

    if(!off) throw;

    char dx=0;
    for(int i=l;i>off;i--)
        {
            if((dx=k->IndexOf(h->Substring(i-1,1)))>=0)
                {v+=dx<<((l-i)<<2);}
            else
                {throw;}
        }
    return v;
}