จำนวนเต็มเป็นสตริงเลขฐานสิบหกใน C ++

ฉันจะแปลงจำนวนเต็มเป็นสตริงฐานสิบหกในC ++ ได้อย่างไร

ฉันสามารถหาวิธีทำได้ แต่ส่วนใหญ่ดูเหมือนจะมุ่งเป้าไปที่ C ดูเหมือนจะไม่มีวิธีดั้งเดิมที่จะทำใน C ++ มันเป็นปัญหาที่ค่อนข้างง่าย ฉันมีสิ่งintที่ฉันต้องการแปลงเป็นสตริงฐานสิบหกสำหรับการพิมพ์ในภายหลัง

ใช้<iomanip>'s std::hex. หากคุณพิมพ์เพียงส่งไปที่std::coutหากไม่เป็นเช่นนั้นให้ใช้std::stringstream

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

คุณสามารถนำหน้าตัวแรก<<ด้วย<< "0x"หรืออะไรก็ได้ตามต้องการ

ผลประโยชน์อื่น ๆ ได้แก่std::oct(ฐานแปด) และstd::dec(กลับเป็นฐานสิบ)

ปัญหาหนึ่งที่คุณอาจพบคือความจริงที่ว่าสิ่งนี้ทำให้เกิดจำนวนตัวเลขที่แน่นอนที่จำเป็นในการแสดง คุณสามารถใช้setfillและsetwสิ่งนี้เพื่อหลีกเลี่ยงปัญหา:

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

ในที่สุดฉันขอแนะนำฟังก์ชันดังกล่าว:

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

เพื่อให้เบาและเร็วขึ้นฉันขอแนะนำให้ใช้การเติมสตริงโดยตรง

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

ใช้std::stringstreamเพื่อแปลงจำนวนเต็มเป็นสตริงและตัวปรับแต่งพิเศษเพื่อตั้งค่าฐาน ตัวอย่างเช่น:

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

เพียงพิมพ์เป็นเลขฐานสิบหก:

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

คุณสามารถลองทำดังต่อไปนี้ มันทำงาน ...

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

คำถามนี้เก่า แต่ฉันแปลกใจว่าทำไมไม่มีใครพูดถึง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

ขอบคุณความคิดเห็นของลินคอล์นด้านล่างฉันได้เปลี่ยนคำตอบนี้

คำตอบต่อไปนี้จัดการ ints 8 บิตอย่างถูกต้องในเวลาคอมไพล์ อย่างไรก็ตามมันต้องการ C ++ 17 หากคุณไม่มี C ++ 17 คุณจะต้องทำอย่างอื่น (เช่นจัดเตรียมฟังก์ชันนี้มากเกินไปหนึ่งรายการสำหรับ uint8_t และอีกรายการหนึ่งสำหรับ int8_t หรือใช้อย่างอื่นนอกเหนือจาก "if constexpr" อาจจะ 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();
}

คำตอบเดิมที่จัดการ int 8 บิตไม่ถูกต้องอย่างที่คิด:

คำตอบของ Kornel Kisielewicz นั้นยอดเยี่ยมมาก แต่การเพิ่มเล็กน้อยจะช่วยตรวจจับกรณีที่คุณเรียกใช้ฟังก์ชันนี้ด้วยอาร์กิวเมนต์เทมเพลตที่ไม่สมเหตุสมผล (เช่น float) หรืออาจทำให้เกิดข้อผิดพลาดของคอมไพเลอร์ที่ยุ่งเหยิง (เช่นประเภทที่ผู้ใช้กำหนดเอง)

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

ฉันได้แก้ไขสิ่งนี้เพื่อเพิ่มการเรียกไปที่ std :: to_string เนื่องจากประเภทจำนวนเต็ม 8 บิต (เช่นstd::uint8_tค่าที่ส่งผ่าน) std::stringstreamจะถือว่าเป็นถ่านซึ่งไม่ได้ให้ผลลัพธ์ที่คุณต้องการ การส่งจำนวนเต็มดังกล่าวเพื่อstd::to_stringจัดการกับพวกมันอย่างถูกต้องและไม่ทำร้ายสิ่งต่าง ๆ เมื่อใช้จำนวนเต็มชนิดอื่นที่ใหญ่กว่า แน่นอนว่าคุณอาจได้รับผลกระทบด้านประสิทธิภาพเล็กน้อยในกรณีเหล่านี้เนื่องจากไม่จำเป็นต้องใช้การเรียก std :: to_string

หมายเหตุ: ฉันเพิ่งจะเพิ่มสิ่งนี้ในความคิดเห็นในคำตอบเดิม แต่ฉันไม่มีตัวแทนที่จะแสดงความคิดเห็น

สำหรับพวกคุณที่คิดว่าส่วนใหญ่ / ส่วนใหญ่ใช้ios::fmtflagsไม่ได้std::stringstreamแต่เหมือนกับแนวคิดเทมเพลตที่ Kornel โพสต์ย้อนกลับไปเมื่อนั้นสิ่งต่อไปนี้ใช้งานได้และค่อนข้างสะอาด:

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

ฉันทำ:

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

ดูคำตอบSOจาก iFreilicht และไฟล์ส่วนหัวเทมเพลตที่ต้องการจากที่นี่GIST !

ลองดูวิธีแก้ปัญหาของฉัน^[1]ที่ฉันคัดลอกแบบคำต่อคำจากโครงการของฉันดังนั้นจึงมีเอกสาร API ภาษาเยอรมันรวมอยู่ด้วย เป้าหมายของฉันคือการผสมผสานความยืดหยุ่นและความปลอดภัยเข้ากับความต้องการที่แท้จริงของฉัน: ^[2]

• ไม่มีการ0xเพิ่มคำนำหน้า : ผู้โทรอาจตัดสินใจได้
• การหักความกว้างอัตโนมัติ: พิมพ์น้อยลง
• การควบคุมความกว้างอย่างชัดเจน : การขยับขยายสำหรับการจัดรูปแบบ (ไม่สูญเสีย) การย่อขนาดเพื่อประหยัดพื้นที่
• สามารถจัดการกับ long long
• จำกัด เฉพาะประเภทอินทิกรัล : หลีกเลี่ยงความประหลาดใจโดยการแปลงแบบเงียบ
• เข้าใจง่าย
• ไม่มีขีด จำกัด ฮาร์ดโค้ด

#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]จากคำตอบของKornel Kisielewicz
^[2]แปลเป็นภาษาCppTestนี่คือวิธีอ่าน:

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

รหัสสำหรับการอ้างอิงของคุณ:

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

ทางออกของฉัน อนุญาตเฉพาะประเภทอินทิกรัลเท่านั้น

ปรับปรุง คุณสามารถตั้งค่าคำนำหน้าทางเลือก 0x ในพารามิเตอร์ที่สอง

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

ผลลัพธ์:
0xfe
0xfe
0xfffffffe
0xfffffffffffffffffe

fe
fe fffffffe
fffffffffffffffffe

ฉันต้องการเพิ่มคำตอบเพื่อเพลิดเพลินกับความสวยงามของภาษา C ++ ความสามารถในการปรับตัวเพื่อทำงานในระดับสูงและต่ำ มีความสุขในการเขียนโปรแกรม

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

ตัวอย่าง:

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;

การใช้ตัวชี้โมฆะ:

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

การเพิ่ม 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();

ขาออก:

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 (แอดเดรส)
6946500 (แอดเดรสถึงเดค)
0x69fec4 (แอดเดรสเดคเอาต์พุตเป็นเลขฐานสิบหก)

สัญชาตญาณไปกับสิ่งนี้ ...
int address = (int) & var;

เห็นสิ่งนี้ที่อื่น ... ที่
อยู่แบบยาวที่ไม่ได้ลงนาม = reinterpret_cast (& var);

ความคิดเห็นบอกฉันว่าถูกต้อง ...
int address = (int) & var;

เมื่อพูดถึง ความสว่างที่ปกคลุมอย่างดีคุณอยู่ที่ไหน? มีคนชอบมากเกินไป!