conversion - decimal a hexadecimal c++

Entero a cadena hexadecimal en C++

Question

¿Cómo convierto un entero a una cadena hexadecimal en C++ ?

Puedo encontrar algunas formas de hacerlo, pero en su mayoría parecen dirigidas hacia C. No parece que haya una forma nativa de hacerlo en C ++. Sin embargo, es un problema bastante simple; Tengo un int que me gustaría convertir a una cadena hexadecimal para imprimirlo más tarde.

Answer 1

Código para su referencia:

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

Answer 2

Hago:

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

¡Eche un vistazo a la respuesta SO de iFreilicht y al archivo de encabezado de plantilla requerido desde aquí GIST !

Answer 3

La respuesta de Kornel Kisielewicz es genial. Pero una pequeña adición ayuda a detectar casos en los que llama a esta función con argumentos de plantilla que no tienen sentido (por ejemplo, float) o que daría lugar a errores del compilador desordenados (por ejemplo, tipo definido por el usuario).

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

He editado esto para agregar una llamada a std :: to_string porque los tipos enteros de 8 bits (por ejemplo, std::uint8_t values ​​passed) to std::stringstream se tratan como char, lo que no le da el resultado que desea. Pasar dichos enteros a std::to_string maneja correctamente y no daña las cosas cuando se usan otros tipos enteros más grandes. Por supuesto, es posible que sufra un ligero golpe de rendimiento en estos casos, ya que la llamada std :: to_string es innecesaria.

Nota: Acabo de agregar esto en un comentario a la respuesta original, pero no tengo el representante para comentar.

Answer 4

Para aquellos de ustedes que descubrieron que muchos / la mayoría de los ios::fmtflags no funcionan con std::stringstream como la idea de la plantilla que Kornel publicó mucho tiempo atrás, lo siguiente funciona y está relativamente limpio:

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

Answer 5

Para que sea más ligero y rápido, sugiero usar relleno directo de una cuerda.

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

Answer 6

Prueba esto:

#include<iostream>

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
}

Answer 7

Puedes probar lo siguiente. Esta 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;
}

Answer 8

Simplemente imprímalo como un número hexadecimal:

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

Answer 9

Solo eche un vistazo a mi solución, ^[1] que literalmente copié de mi proyecto, por lo que hay un documento de API de alemán incluido. Mi objetivo era combinar flexibilidad y seguridad dentro de mis necesidades reales: ^[2]

• no se agregó el prefijo 0x : el que llama puede decidir
• deducción automática del ancho : menos tipeo
• control de ancho explícito : ensanchamiento para formatear, (sin pérdida) encogimiento para ahorrar espacio
• capaz de hacer frente a long long
• restringido a tipos integrales : evitar sorpresas por conversiones silenciosas
• facilidad de comprensión
• sin límite 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://.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] basado en la respuesta de Kornel Kisielewicz
^[2] Traducido al lenguaje de CppTest , así es como se lee:

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

Answer 10

Use <iomanip> ''s std::hex . Si imprime, solo envíelo a std::cout , si no, use std::stringstream

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

Puede anteponer el primer << con << "0x" o lo que quiera si lo desea.

Otros manípulos de interés son std::oct (octal) y std::dec (de nuevo a decimal).

Un problema que puede encontrar es el hecho de que esto produce la cantidad exacta de dígitos necesarios para representarlo. Puede usar setfill y setw para eludir el problema:

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

Entonces, finalmente, sugeriría tal función:

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

Answer 11

Utilice std::stringstream para convertir enteros en cadenas y sus manipuladores especiales para establecer la base. Por ejemplo, así:

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

Answer 12

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