Inteiro para string hexadecimal em C ++

Como faço para converter um inteiro em uma string hexadecimal em C ++ ?

Eu posso encontrar algumas maneiras de fazê-lo, mas eles geralmente parecem direcionados para C. Não parece haver uma maneira nativa de fazer isso em C ++. É um problema bem simples; Eu tenho um int que gostaria de converter em uma seqüência hexadecimal para impressão posterior.

Use o std::hex . Se você imprimir, apenas envie para std::cout , se não, então use std::stringstream

 std::stringstream stream; stream < < std::hex << your_int; std::string result( stream.str() ); 

Você pode preceder o primeiro < < com < < "0x" ou o que quiser, se desejar.

Outros manípulos de interesse são std::oct (octal) e std::dec (de volta ao decimal).

Um problema que você pode encontrar é o fato de que isso produz a quantidade exata de dígitos necessários para representá-lo. Você pode usar setfill e setw para contornar o problema:

 stream < < std::setfill ('0') << std::setw(sizeof(your_type)*2) << std::hex << your_int; 

Então, finalmente, eu sugeriria tal function:

 template< typename T > std::string int_to_hex( T i ) { std::stringstream stream; stream < < "0x" << std::setfill ('0') << std::setw(sizeof(T)*2) << std::hex << i; return stream.str(); } 

Para torná-lo mais leve e mais rápido, sugiro usar o preenchimento direto de uma string.

 template  std::string n2hexstr(I w, size_t hex_len = sizeof(I)< <1) { static const char* digits = "0123456789ABCDEF"; std::string rc(hex_len,'0'); for (size_t i=0, j=(hex_len-1)*4 ; i>j) & 0x0f]; return rc; } 

Use std::stringstream para converter inteiros em strings e seus manipuladores especiais para definir a base. Por exemplo, assim:

 std::stringstream sstream; sstream < < std::hex << my_integer; std::string result = sstream.str(); 

Basta imprimi-lo como um número hexadecimal:

 int i = /* ... */; std::cout < < std::hex << i; 

Você pode tentar o seguinte. Está funcionando…

 #include  #include  #include  #include  using namespace std; template  string to_string(T t, ios_base & (*f)(ios_base&)) { ostringstream oss; oss < < f << t; return oss.str(); } int main () { cout<(123456, hex)<  
 int num = 30; std::cout < < std::hex << num << endl; // This should give you hexa- decimal of 30 

Para aqueles de vocês que descobriram que muitos / a maioria dos ios::fmtflags não funcionam com std::stringstream mas como a idéia de modelo que o Kornel publicou há algum tempo, o seguinte funciona e é relativamente limpo:

 #include  #include  template< typename T > std::string hexify(T i) { std::stringbuf buf; std::ostream os(&buf); os < < "0x" << std::setfill('0') << std::setw(sizeof(T) * 2) << std::hex << i; return buf.str().c_str(); } int someNumber = 314159265; std::string hexified = hexify< int >(someNumber); 

Código para sua referência:

 #include  ... string intToHexString(int intValue) { string hexStr; /// integer value to hex-string std::stringstream sstream; sstream < < "0x" << std::setfill ('0') << std::setw(2) << std::hex << (int)intValue; hexStr= sstream.str(); sstream.clear(); //clears out the stream-string return hexStr; } 

Basta dar uma olhada na minha solução, [1] que eu literalmente copiei do meu projeto, de modo que há um alemão incluído no documento da API. Meu objective era combinar flexibilidade e segurança dentro das minhas necessidades reais: [2]

  • nenhum prefixo 0x adicionado: o chamador pode decidir
  • dedução de largura automática: menos digitação
  • controle de largura explícito : ampliação para formatação, (sem perdas) encolhimento para economizar espaço
  • capaz de lidar com long long
  • restrito a tipos integrais : evite surpresas por conversões silenciosas
  • facilidade de compreensão
  • sem limite codificado
 #include  #include  #include  /// Vertextet einen Ganzzahlwert val im Hexadezimalformat. /// Auf die Minimal-Breite width wird mit führenden Nullen aufgefüllt; /// falls nicht angegeben, wird diese Breite aus dem Typ des Arguments /// abgeleitet. Funktion geeignet von char bis long long. /// Zeiger, Fließkommazahlen u.ä. werden nicht unterstützt, ihre /// Übergabe führt zu einem (beabsichtigten!) Compilerfehler. /// Grundlagen aus: http://stackoverflow.com/a/5100745/2932052 template  inline std::string int_to_hex(T val, size_t width=sizeof(T)*2) { std::stringstream ss; ss < < std::setfill('0') << std::setw(width) << std::hex << (val|0); return ss.str(); } 

[1] baseado na resposta de Kornel Kisielewicz
[2] Traduzido para o idioma do CppTest , é assim que se lê:

 TEST_ASSERT(int_to_hex(char(0x12)) == "12"); TEST_ASSERT(int_to_hex(short(0x1234)) == "1234"); TEST_ASSERT(int_to_hex(long(0x12345678)) == "12345678"); TEST_ASSERT(int_to_hex((long long)(0x123456789abcdef0)) == "123456789abcdef0"); TEST_ASSERT(int_to_hex(0x123, 1) == "123"); TEST_ASSERT(int_to_hex(0x123, 8) == "00000123"); 

Eu faço:

 int hex = 10; std::string hexstring = stringFormat("%X", hex); 

Dê uma olhada na resposta do iFreilicht e do arquivo de header de modelo necessário aqui GIST !

A resposta de Kornel Kisielewicz é ótima. Mas uma ligeira adição ajuda a capturar casos em que você está chamando essa function com argumentos de modelo que não fazem sentido (por exemplo, float) ou que resultariam em erros de compilador confusos (por exemplo, tipo definido pelo usuário).

 template< typename T > std::string int_to_hex( T i ) { // Ensure this function is called with a template parameter that makes sense. Note: static_assert is only available in C++11 and higher. static_assert(std::is_integral::value, "Template argument 'T' must be a fundamental integer type (eg int, short, etc..)."); std::stringstream stream; stream < < "0x" << std::setfill ('0') << std::setw(sizeof(T)*2) << std::hex << i; // Optional: replace above line with this to handle 8-bit integers. // << std::hex << std::to_string(i); return stream.str(); } 

Eu editei isso para adicionar uma chamada para std :: to_string porque os tipos inteiros de 8 bits (por exemplo, std::uint8_t values ​​passed) para std::stringstream são tratados como char, o que não lhe dá o resultado desejado. Passar tais números inteiros para std::to_string manipula corretamente e não faz mal ao usar outros tipos inteiros maiores. É claro que você pode sofrer um pequeno desempenho nesses casos, já que a chamada std :: to_string é desnecessária.

Nota: Eu teria apenas adicionado isso em um comentário para a resposta original, mas eu não tenho o representante para comentar.

Essa pergunta é antiga, mas estou surpresa porque ninguém mencionou boost::format :

 cout < < (boost::format("%x") % 1234).str(); // output is: 4d2 

Tente isto:

 #include using namespace std; int main() { int *a = new int;//or put a number exept new int //use * for pointer cin >> *a; cout < < a; //if integer that is made as pointer printed without *, than it will print hex value return 0; //I hope i help you }