C ++ 'da tamsayı onaltılık dizeye

C ++ 'da bir tamsayıyı onaltılık dizeye nasıl dönüştürebilirim ?

Bunu yapmanın bazı yollarını bulabilirim, ancak bunlar çoğunlukla C'yi hedef alıyor gibi görünüyor. Bunu C ++ 'da yapmanın yerel bir yolu yok gibi görünüyor. Yine de oldukça basit bir sorundur; Daha intsonra yazdırmak için onaltılık dizeye dönüştürmek istediğim bir tane var .

<iomanip>'S kullanın std::hex. Yazdırırsanız, yalnızca adresine gönderin std::cout, değilse, sonra kullanınstd::stringstream

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

İlk başa ekleyebilir <<ile << "0x"ya da isterseniz nasıl istersen.

Diğer ilgi türleri std::oct(sekizlik) ve std::dec(ondalık sayıya geri).

Karşılaşabileceğiniz bir sorun, bunun onu temsil etmek için gereken tam rakam miktarını üretmesidir. Sorunu aşmak için setfillve setwbunu kullanabilirsiniz :

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

Son olarak, böyle bir işlevi öneriyorum:

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

Daha hafif ve daha hızlı hale getirmek için bir dizeyi doğrudan doldurmanızı öneririm.

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

Tam std::stringstreamsayıları dizelere ve tabanı ayarlamak için özel manipülatörlerine dönüştürmek için kullanın . Örneğin bunun gibi:

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

Onaltılık sayı olarak yazdırmanız yeterlidir:

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

Aşağıdakileri deneyebilirsiniz. İşe yarıyor...

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

Bu soru eski, ama neden kimsenin bahsetmediğine şaşırıyorum 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

Lincoln'ün aşağıdaki yorumu sayesinde, bu cevabı değiştirdim.

Aşağıdaki yanıt, derleme zamanında 8 bitlik girişleri doğru şekilde işler. Ancak, C ++ 17 gerektirir. C ++ 17'niz yoksa, başka bir şey yapmanız gerekir (örneğin, bu işlevin aşırı yüklemelerini sağlayın, biri uint8_t ve diğeri int8_t için veya "if constexpr", belki enable_if dışında bir şey kullanın).

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

8 bitlik girişleri düşündüğüm gibi doğru şekilde işlemeyen orijinal cevap:

Kornel Kisielewicz'in cevabı harika. Ancak küçük bir ekleme, mantıklı olmayan (örn. Float) veya karmaşık derleyici hatalarına neden olan (örn. Kullanıcı tanımlı tür) şablon argümanlarıyla bu işlevi çağırdığınız durumları yakalamaya yardımcı olur.

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

Bunu std :: to_string'e bir çağrı eklemek için düzenledim çünkü 8 bitlik tamsayı türleri (örn. Aktarılan std::uint8_tdeğerler) std::stringstreamchar olarak değerlendirilir, bu da size istediğiniz sonucu vermez. Bu tür tamsayıları std::to_stringdoğru şekilde ele almak için geçirmek ve diğer, daha büyük tam sayı türlerini kullanırken bir şeylere zarar vermez. Elbette, std :: to_string çağrısı gereksiz olduğundan, bu durumlarda muhtemelen küçük bir performans düşüşü yaşayabilirsiniz.

Not: Bunu sadece orijinal cevaba bir yoruma eklerdim, ancak yorum yapacak bir temsilcim yok.

Birçoğunun / çoğunun henüz ios::fmtflagsçalışmadığını std::stringstreamanlayanlarınız için, Kornel'in çok eski zamanlarda yayınladığı şablon fikri gibi, aşağıdaki işler işe yarıyor ve nispeten temiz:

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

Yaparım:

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

İFreilicht'ten SO cevabına ve buradan gerekli şablon başlık dosyasına bir göz atın GIST !

Sadece projemden aynen kopyaladığım ^[1] çözümüme bir göz atın , böylece bir Almanca API dokümanı içerir. Amacım, gerçek ihtiyaçlarım içinde esneklik ve güvenliği birleştirmekti: ^[2]

• hayır 0xönek ekledi: Arayan karar verebilir
• otomatik genişlik kesintisi : daha az yazım
• açık genişlik kontrolü: biçimlendirme için genişletme, (kayıpsız) yerden tasarruf etmek için küçültme
• başa çıkabilen long long
• integral türlerle sınırlıdır : sessiz dönüşümlerle sürprizlerden kaçının
• anlama kolaylığı
• sabit kodlanmış sınır yok

#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'in
^[2] cevabına göre CppTest'in diline çevrilmiştir , şöyle okur:

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

Referans için kod:

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

Çözümüm. Yalnızca integral türlerine izin verilir.

Güncelleme. İkinci parametrede isteğe bağlı 0x önekini ayarlayabilirsiniz.

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

Sonuçlar:
0xfe
0xfe
0xfffffffe
0xfffffffffffffffe

fe
fe fffffffe
fffffffffffffffe

C ++ dilinin güzelliğinin tadını çıkarmak için bir cevap eklemek istiyorum. Yüksek ve alçak seviyelerde çalışmaya uyarlanabilirliği. Mutlu programlar.

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

Örnekler:

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;

Void işaretçisini kullanma:

// 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 ekleniyor:

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

Çıktılar:

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 (adres)
6946500 (ondalık adres) 0x69fec4 (
ondalık adrese, onaltılık olarak çıktı)

içgüdüsel olarak bu ...
int adres = (int) & var;

bunu başka bir yerde gördüm ...
imzasız uzun adres = reinterpret_cast (& var);

yorum bana bunun doğru olduğunu söyledi ...
int adres = (int) & var;

iyi örtülmüş hafiflikten bahsederken , neredesin? çok fazla beğeni alıyorlar!