Número inteiro para hexadecimal em C ++

Como converter um número inteiro em uma sequência hexadecimal em C ++ ?

Posso encontrar algumas maneiras de fazer isso, mas elas parecem direcionadas para C. Parece que não há uma maneira nativa de fazer isso em C ++. É um problema bastante simples; Eu tenho um intque gostaria de converter em uma sequência hexadecimal para impressão posterior.

Use <iomanip>'s std::hex. Se você imprimir, basta enviá-lo para std::cout, caso contrário, usestd::stringstream

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

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

Outras manips 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 setfille setwisso para contornar o problema:

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

Então, finalmente, sugiro uma função:

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 rápido, sugiro usar o preenchimento direto de uma corda.

template <typename I> 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<hex_len; ++i,j-=4)
        rc[i] = digits[(w>>j) & 0x0f];
    return rc;
}

Use std::stringstreampara converter números 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 <iostream>
#include <fstream>
#include <string>
#include <sstream>
using namespace std;

template <class T>
string to_string(T t, ios_base & (*f)(ios_base&))
{
  ostringstream oss;
  oss << f << t;
  return oss.str();
}

int main ()
{
  cout<<to_string<long>(123456, hex)<<endl;
  system("PAUSE");
  return 0;
}

Esta pergunta é antiga, mas estou surpreso por que ninguém mencionou boost::format:

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

int num = 30;
std::cout << std::hex << num << endl; // This should give you hexa- decimal of 30

Graças ao comentário de Lincoln abaixo, alterei esta resposta.

A resposta a seguir lida corretamente com entradas de 8 bits em tempo de compilação. No entanto, eles exigem C ++ 17. Se você não possui C ++ 17, precisará fazer outra coisa (por exemplo, fornecer sobrecargas dessa função, uma para uint8_t e outra para int8_t, ou usar algo além de "if constexpr", talvez enable_if).

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<T>::value, "Template argument 'T' must be a fundamental integer type (e.g. int, short, etc..).");

    std::stringstream stream;
    stream << "0x" << std::setfill ('0') << std::setw(sizeof(T)*2) << std::hex;

    // If T is an 8-bit integer type (e.g. uint8_t or int8_t) it will be 
    // treated as an ASCII code, giving the wrong result. So we use C++17's
    // "if constexpr" to have the compiler decides at compile-time if it's 
    // converting an 8-bit int or not.
    if constexpr (std::is_same_v<std::uint8_t, T>)
    {        
        // Unsigned 8-bit unsigned int type. Cast to int (thanks Lincoln) to 
        // avoid ASCII code interpretation of the int. The number of hex digits 
        // in the  returned string will still be two, which is correct for 8 bits, 
        // because of the 'sizeof(T)' above.
        stream << static_cast<int>(i);
    }        
    else if (std::is_same_v<std::int8_t, T>)
    {
        // For 8-bit signed int, same as above, except we must first cast to unsigned 
        // int, because values above 127d (0x7f) in the int will cause further issues.
        // if we cast directly to int.
        stream << static_cast<int>(static_cast<uint8_t>(i));
    }
    else
    {
        // No cast needed for ints wider than 8 bits.
        stream << i;
    }

    return stream.str();
}

Resposta original que não lida com ints de 8 bits corretamente como eu pensava:

A resposta de Kornel Kisielewicz é ótima. Porém, um pequeno acréscimo ajuda a capturar casos em que você está chamando essa função com argumentos de modelo que não fazem sentido (por exemplo, flutuação) ou que resultariam em erros confusos do compilador (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<T>::value, "Template argument 'T' must be a fundamental integer type (e.g. 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_tvalores passados) std::stringstreamsão tratados como char, o que não fornece o resultado desejado. Passar esses números inteiros para std::to_stringmanipulá-los corretamente e não prejudica as coisas ao usar outros tipos inteiros maiores. É claro que você pode sofrer um leve impacto no desempenho nesses casos, pois a chamada std :: to_string é desnecessária.

Nota: eu teria acabado de adicionar isso em um comentário à resposta original, mas não tenho o representante para comentar.

Para aqueles de vocês que descobriram que muitos / a maioria ios::fmtflagsainda não trabalha std::stringstreamcomo a ideia de modelo que Kornel postou quando, o seguinte funciona e é relativamente limpo:

#include <iomanip>
#include <sstream>


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);

Eu faço:

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

Dê uma olhada na resposta SO da iFreilicht e no arquivo de cabeçalho do modelo necessário a partir daqui GIST !

Basta dar uma olhada na minha solução, ^[1] que eu copiei literalmente do meu projeto, para que haja um documento de API em alemão incluído. Meu objetivo era combinar flexibilidade e segurança às minhas necessidades reais: ^[2]

• nenhum 0xprefixo adicionado: o chamador pode decidir
• dedução automática da largura : menos digitação
• controle explícito de largura : ampliando para formatação, (sem perdas) diminuindo para economizar espaço
• capaz de lidar com long long
• restrito a tipos integrais : evite surpresas por conversões silenciosas
• facilidade de entendimento
• sem limite codificado

#include <string>
#include <sstream>
#include <iomanip>

/// 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 <typename T>
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] Com} base 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");
// with deduction test as suggested by Lightness Races in Orbit:
TEST_ASSERT(int_to_hex(short(0x12)) == "0012"); 

Código para sua referência:

#include <iomanip>
#include <sstream>
...
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;
}

Minha solução Somente tipos integrais são permitidos.

Atualizar. Você pode definir o prefixo opcional 0x no segundo parâmetro.

definition.h

#include  <iomanip>
#include <sstream>

template <class T, class T2 = typename std::enable_if<std::is_integral<T>::value>::type>
static std::string ToHex(const T & data, bool addPrefix = true);



template<class T, class>
inline std::string Convert::ToHex(const T & data, bool addPrefix)
{
    std::stringstream sstream;
    sstream << std::hex;
    std::string ret;
    if (typeid(T) == typeid(char) || typeid(T) == typeid(unsigned char) || sizeof(T)==1)
    {
        sstream << static_cast<int>(data);
        ret = sstream.str();
        if (ret.length() > 2)
        {
            ret = ret.substr(ret.length() - 2, 2);
        }
    }
    else
    {
        sstream << data;
        ret = sstream.str();
    }
    return (addPrefix ? u8"0x" : u8"") + ret;
}

main.cpp

#include <definition.h>
int main()
{
    std::cout << ToHex<unsigned char>(254) << std::endl;
    std::cout << ToHex<char>(-2) << std::endl;
    std::cout << ToHex<int>(-2) << std::endl;
    std::cout << ToHex<long long>(-2) << std::endl;

    std::cout<< std::endl;
    std::cout << ToHex<unsigned char>(254, false) << std::endl;
    std::cout << ToHex<char>(-2, false) << std::endl;
    std::cout << ToHex<int>(-2, false) << std::endl;
    std::cout << ToHex<long long>(-2, false) << std::endl;
    return 0;
}

Resultados:
0xfe
0xfe
0xfffffffe
0xfffffffffffffffe

fe
fe fffffffe
fffffffffffffffe

Gostaria de adicionar uma resposta para apreciar a beleza da linguagem C ++. Sua adaptabilidade para trabalhar em níveis altos e baixos. Feliz programação.

public:template <class T,class U> U* Int2Hex(T lnumber, U* buffer)
{
    const char* ref = "0123456789ABCDEF";
    T hNibbles = (lnumber >> 4);

    unsigned char* b_lNibbles = (unsigned char*)&lnumber;
    unsigned char* b_hNibbles = (unsigned char*)&hNibbles;

    U* pointer = buffer + (sizeof(lnumber) << 1);

    *pointer = 0;
    do {
        *--pointer = ref[(*b_lNibbles++) & 0xF];
        *--pointer = ref[(*b_hNibbles++) & 0xF];
    } while (pointer > buffer);

    return buffer;
}

Exemplos:

char buffer[100] = { 0 };
Int2Hex(305419896ULL, buffer);//returns "0000000012345678"
Int2Hex(305419896UL, buffer);//returns "12345678"
Int2Hex((short)65533, buffer);//returns "FFFD"
Int2Hex((char)18, buffer);//returns "12"

wchar_t buffer[100] = { 0 };
Int2Hex(305419896ULL, buffer);//returns L"0000000012345678"
Int2Hex(305419896UL, buffer);//returns L"12345678"
Int2Hex((short)65533, buffer);//returns L"FFFD"
Int2Hex((char)18, buffer);//returns L"12"

#include <iostream> 
#include <sstream>  

int main()
{
unsigned int i = 4967295; // random number
std::string str1, str2;
unsigned int u1, u2;

std::stringstream ss;

Usando ponteiro nulo:

// INT to HEX
ss << (void*)i;       // <- FULL hex address using void pointer
ss >> str1;          //     giving address value of one given in decimals.
ss.clear();         // <- Clear bits
// HEX to INT
ss << std::hex << str1;   // <- Capitals doesn't matter so no need to do extra here
ss >> u1;
ss.clear();

Adicionando 0x:

// INT to HEX with 0x
ss << "0x" << (void*)i;   // <- Same as above but adding 0x to beginning
ss >> str2;
ss.clear();
// HEX to INT with 0x
ss << std::hex << str2;   // <- 0x is also understood so need to do extra here
ss >> u2;
ss.clear();

Saídas:

std::cout << str1 << std::endl; // 004BCB7F
std::cout << u1 << std::endl;   // 4967295
std::cout << std::endl;
std::cout << str2 << std::endl; // 0x004BCB7F
std::cout << u2 << std::endl;   // 4967295


return 0;
}

int var = 20;
cout <<                          &var << endl;
cout <<                     (int)&var << endl;
cout << std::hex << "0x" << (int)&var << endl << std::dec; // output in hex, reset back to dec

0x69fec4 (endereço)
6946500 (endereço para dec)
0x69fec4 (endereço para dec, saída em hexadecimal)

instintivamente foi com isso ...
int address = (int) & var;

vi isso em outro lugar ...
endereço longo não assinado = reinterpret_cast (& var);

o comentário me disse que isso está correto ...
int address = (int) & var;

falando de leveza bem coberta , onde você está? eles estão recebendo muitos gostos!