मैं C ++ में एक पूर्णांक को हेक्स स्ट्रिंग में कैसे बदलूं ?
मुझे इसे करने के कुछ तरीके मिल सकते हैं, लेकिन वे ज्यादातर सी की ओर लक्षित होते हैं। ऐसा नहीं लगता है कि इसे सी ++ में करने का कोई मूल तरीका है। यह एक बहुत ही सरल समस्या है; मैं एक है intजो मैं बाद में मुद्रण के लिए एक हेक्स स्ट्रिंग में परिवर्तित करना चाहते हैं मिल गया है ।
जवाबों:
उपयोग <iomanip>की 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();
}std::setwजरूरत है, हर पूर्णांक के लिए धारा में उत्पादन होने के लिए जबकि std::hex, std::setfill, std::uppercase, ... केवल एक बार उत्पादन धारा के लिए भेजा जाना चाहिए। यह असंगत लगता है?
इसे हल्का और तेज करने के लिए मैं एक स्ट्रिंग के सीधे भरने का उपयोग करने का सुझाव देता हूं।
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;
}doubleऔर float(और संकेत के लिए नहीं)
0000FFFFहै 0xFFFF। मुझे 0xFFFFआउटपुट के रूप में पसंद है ।
बस इसे हेक्साडेसिमल नंबर के रूप में प्रिंट करें:
int i = /* ... */;
std::cout << std::hex << i;std::cout<<std::hex<<i<<std::dec;, अन्यथा बाद में स्ट्रीम किए गए सभी पूर्णांक हेक्स में होंगे। आपको ऐसा करने की आवश्यकता नहीं है कि अन्य उत्तरों के लिए जो उपयोग करते हैं stringstreamक्योंकि धारा का उपयोग करने के बाद छोड़ दिया जाता है, लेकिन coutहमेशा के लिए रहता है।
आप निम्नलिखित की कोशिश कर सकते हैं। यह काम कर रहा है...
#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;
}to_stringनाम स्थान का हिस्सा हैstd
नीचे लिंकन की टिप्पणी के लिए धन्यवाद, मैंने इस उत्तर को बदल दिया है।
निम्नलिखित उत्तर संकलन समय पर 8-बिट ints को ठीक से संभालता है। हालांकि, इसके लिए C ++ 17 की आवश्यकता होती है। यदि आपके पास C ++ 17 नहीं है, तो आपको कुछ और करना होगा (जैसे कि इस फ़ंक्शन के ओवरलोड प्रदान करते हैं, एक uint8_t के लिए और एक int8_t के लिए, या "अगर कॉन्स्ट्रेक्स" के अलावा कुछ का उपयोग करें, तो 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();
}मूल उत्तर जो कि 8-बिट इन्टल्स को सही ढंग से हैंडल नहीं करता है जैसा कि मैंने सोचा था कि यह किया था:
Kornel Kisielewicz का जवाब बहुत अच्छा है। लेकिन एक मामूली जोड़ उन मामलों को पकड़ने में मदद करता है, जहां आप इस फ़ंक्शन को टेम्प्लेट तर्कों के साथ बुला रहे हैं जो समझ में नहीं आते हैं (उदाहरण के लिए फ्लोट) या जिसके परिणामस्वरूप गन्दा संकलक त्रुटियां (जैसे उपयोगकर्ता-परिभाषित प्रकार) होगी।
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 कॉल अनावश्यक है।
नोट: मैंने इसे मूल उत्तर की टिप्पणी में जोड़ा होगा, लेकिन मेरे पास टिप्पणी करने के लिए रिपीट नहीं है।
char(जो दोनों से अलग है uint8_tऔर int8_tअधिकांश कार्यान्वयन में (जहां वे क्रमशः हैं unsigned charऔर signed char))।
... && !std::is_same_v<char, T> && !std::is_same_v<bool, T>आदि ...
आप में से उन लोगों के लिए जिन्होंने यह पता लगाया है कि कई / अधिकांश अभी तक ios::fmtflagsकाम नहीं करते हैं std::stringstreamजैसे कि कोर्नेल ने इस तरह से पोस्ट किया कि निम्नलिखित तरीके से काम करते हैं और अपेक्षाकृत साफ होते हैं:
#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);बस मेरे समाधान पर एक नज़र है, [1] जिसे मैंने अपने प्रोजेक्ट से कॉपी किया है, इसलिए वहां एक जर्मन एपीआई डॉक्स शामिल है। मेरा लक्ष्य मेरी वास्तविक जरूरतों के भीतर लचीलापन और सुरक्षा को जोड़ना था: [२]
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] कोर्नेल किसलीलेविक द्वारा उत्तर के आधार पर
[२] कैप्पेस्ट की भाषा में अनुवादित , यह इस प्रकार है:
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"); 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;
}clearसे व्यर्थ है sstream(इसे तब भी नष्ट कर दिया जाएगा जब फ़ंक्शन अगली पंक्ति पर किसी भी तरह वापस आ जाता है)। आप hexStrपूरी तरह से और return sstream.str();बिना clearआईएनजी के नाम से बच सकते हैं और एक ही प्रभाव प्राप्त कर सकते हैं, जिससे कोड की चार लाइनें कम हो सकती हैं।
sstream.clear();? sstreamवस्तु स्वचालित रूप से दायरे के अंत में नष्ट हो जाता है, तो return sstream.str();यह करना होगा।
sstream.clearकेवल सामग्री को साफ़ कर देगा, इससे पहले कि स्कोप स्कोप के अंत के साथ समाप्त हो जाए (किसी भी विफल और स्पष्ट झंडे को स्पष्ट करने के लिए)। दरअसल, जब गुंजाइश मर जाती है, स्ट्रीम-चर के जीवन-काल के साथ, और इसलिए sstream.strमूल्य द्वारा लौटने के लिए उपयोग किया जा सकता है। [संदर्भ: cplusplus.com/reference/ios/ios/clear/]
मेरा समाधान। केवल अभिन्न प्रकार की अनुमति है।
अपडेट करें। आप दूसरे पैरामीटर में वैकल्पिक उपसर्ग 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
0xffffffffffffff
fe
fe fffffffe
fffffffffffffffe
मैं 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 dec0x69fec4 (पता)
6946500 (पता करने के लिए)
0x69fec4 (पता करने के लिए पता, आउटपुट में हेक्स)
सहज रूप से इस के साथ चला गया ...
int पता = (int) & var;
यह कहीं और देखा ...
अहस्ताक्षरित लंबा पता = reinterpret_cast (& var);
टिप्पणी मुझे बताया कि यह सही है ...
int पता = (int) & var;
अच्छी तरह से ढके हुए हल्केपन की बात करते हुए , आप कहाँ हैं? उन्हें बहुत अधिक लाइक मिल रहे हैं!
unsigned long, लेकिन std::intptr_t।
intptr_tनिर्माण मंच पर किसी भी सूचक स्टोर कर सकते हैं; यह [जरूरी] सच नहीं है unsigned int। और, फिर से, इस प्रश्न में से कोई भी प्रासंगिक नहीं है। मेरी ओर से कोई और प्रतिक्रिया नहीं
intटाइप पर अपने सुझाव का परीक्षण करें ;)