Integer ke string hex di C ++

Bagaimana cara mengubah integer menjadi string hex di C ++ ?

Saya dapat menemukan beberapa cara untuk melakukannya, tetapi sebagian besar tampaknya ditargetkan ke C. Tampaknya tidak ada cara asli untuk melakukannya di C ++. Ini adalah masalah yang cukup sederhana; Saya punya intyang ingin saya ubah menjadi string hex untuk dicetak nanti.

Gunakan <iomanip>'s std::hex. Jika Anda mencetak, kirimkan saja ke std::cout, jika tidak, gunakanstd::stringstream

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

Anda dapat menambahkan yang pertama <<dengan << "0x"atau apa pun yang Anda suka jika Anda mau.

Manip lain yang menarik adalah std::oct(oktal) dan std::dec(kembali ke desimal).

Satu masalah yang mungkin Anda temui adalah kenyataan bahwa ini menghasilkan jumlah digit yang tepat yang diperlukan untuk mewakilinya. Anda dapat menggunakan setfilldan setwini untuk menghindari masalah:

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

Jadi akhirnya, saya menyarankan fungsi seperti itu:

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

Untuk membuatnya lebih ringan dan cepat saya sarankan untuk menggunakan pengisian langsung dari sebuah string.

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

Gunakan std::stringstreamuntuk mengubah bilangan bulat menjadi string dan manipulator khususnya untuk mengatur basis. Contohnya seperti itu:

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

Cetak saja sebagai angka heksadesimal:

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

Anda dapat mencoba yang berikut ini. Bekerja...

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

Pertanyaan ini sudah lama, tapi saya heran mengapa tidak ada yang menyebutkan 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

Berkat komentar Lincoln di bawah ini, saya telah mengubah jawaban ini.

Jawaban berikut menangani int 8-bit dengan benar pada waktu kompilasi. Itu doees, bagaimanapun, membutuhkan C ++ 17. Jika Anda tidak memiliki C ++ 17, Anda harus melakukan sesuatu yang lain (misalnya memberikan kelebihan beban dari fungsi ini, satu untuk uint8_t dan satu untuk int8_t, atau menggunakan sesuatu selain "if constexpr", mungkin 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();
}

Jawaban asli yang tidak menangani int 8-bit dengan benar seperti yang saya duga:

Jawaban Kornel Kisielewicz bagus. Tetapi sedikit tambahan membantu menangkap kasus di mana Anda memanggil fungsi ini dengan argumen template yang tidak masuk akal (misalnya float) atau yang akan menghasilkan kesalahan compiler yang berantakan (misalnya tipe yang ditentukan pengguna).

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

Saya telah mengedit ini untuk menambahkan panggilan ke std :: to_string karena tipe integer 8-bit (misalnya std::uint8_tnilai yang diteruskan) std::stringstreamdiperlakukan sebagai char, yang tidak memberikan hasil yang Anda inginkan. Meneruskan bilangan bulat seperti itu untuk std::to_stringmenanganinya dengan benar dan tidak mengganggu saat menggunakan jenis bilangan bulat lain yang lebih besar. Tentu saja Anda mungkin mengalami sedikit penurunan kinerja dalam kasus ini karena panggilan std :: to_string tidak diperlukan.

Catatan: Saya baru saja menambahkan ini di komentar ke jawaban asli, tapi saya tidak punya perwakilan untuk berkomentar.

Bagi Anda yang mengetahui bahwa banyak / sebagian besar ios::fmtflagstidak berfungsi std::stringstreamnamun menyukai ide template yang diposting Kornel dulu, berikut ini berfungsi dan relatif bersih:

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

Saya melakukan:

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

Lihatlah jawaban SO dari iFreilicht dan file header template yang diperlukan dari sini GIST !

Coba lihat solusi saya, ^[1] yang saya salin kata demi kata dari proyek saya, jadi ada dokumen API Jerman yang disertakan. Tujuan saya adalah menggabungkan fleksibilitas dan keamanan dalam kebutuhan saya yang sebenarnya: ^[2]

• tidak ada 0xawalan yang ditambahkan: penelepon dapat memutuskan
• pengurangan lebar otomatis : lebih sedikit mengetik
• kontrol lebar eksplisit : pelebaran untuk pemformatan, (lossless) menyusut untuk menghemat ruang
• mampu menangani long long
• terbatas pada tipe integral : hindari kejutan dengan konversi diam
• kemudahan pemahaman
• tidak ada batasan hard-code

#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] berdasarkan jawaban Kornel Kisielewicz
^[2] Diterjemahkan ke dalam bahasa CppTest , begini bunyinya:

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

Kode untuk referensi Anda:

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

Solusi saya. Hanya tipe integral yang diperbolehkan.

Memperbarui. Anda dapat menyetel awalan opsional 0x di parameter kedua.

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

Hasil:
0xfe
0xfe
0xfffffffe
0xfffffffffffffffe

fe
fe fffffffe
fffffffffffffffe

Saya ingin menambahkan jawaban untuk menikmati indahnya bahasa C ++. Kemampuan adaptasinya untuk bekerja pada level tinggi dan rendah. Selamat memprogram.

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

Contoh:

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;

Menggunakan void pointer:

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

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

Keluaran:

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 (alamat)
6946500 (alamat ke dec)
0x69fec4 (alamat ke dec, keluaran dalam hex)

secara naluriah pergi dengan ini ...
int address = (int) & var;

melihat ini di tempat lain ...
alamat panjang tak bertanda tangan = reinterpret_cast (& var);

komentar mengatakan kepada saya bahwa ini benar ...
int address = (int) & var;

berbicara tentang cahaya yang tertutup rapat , di mana Anda berada? mereka mendapatkan terlalu banyak suka!