আমি কীভাবে সি ++ তে একটি পূর্ণসংখ্যাটিকে হেক্স স্ট্রিংয়ে রূপান্তর করব ?
আমি এটি করার কিছু উপায় খুঁজে পেতে পারি তবে তারা বেশিরভাগ সি এর দিকে লক্ষ্যবস্তু বলে মনে হয় এটি সি ++ এ করার কোনও নেটিভ উপায় আছে বলে মনে হয় না। যদিও এটি বেশ সহজ সমস্যা; আমি একটি পেয়েছি 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প্রয়োজন, যে int- এ জন্য প্রবাহ আউটপুট হতে যেহেতু 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_stringstd
নীচে লিংকনের মন্তব্যে ধন্যবাদ, আমি এই উত্তরটি পরিবর্তন করেছি।
নিম্নলিখিত উত্তরগুলি সংকলনের সময় 8-বিট ইনটগুলি সঠিকভাবে পরিচালনা করে। এটি doees, তবে, সি ++ 17 প্রয়োজন। আপনার যদি সি ++ 17 না থাকে তবে আপনাকে অন্য কিছু করতে হবে (উদাঃ এই ফাংশনটির ওভারলোডগুলি, একটি uint8_t এর জন্য এবং একটি int8_t এর জন্য, বা "যদি কনস্টেক্সপ্রে", সম্ভবত সক্ষম_আইফ) এর বাইরে কিছু ব্যবহার করুন)।
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-বিট ইনটগুলি সঠিকভাবে পরিচালনা করে না যেমনটি আমি ভেবেছিলাম:
কর্নেল কিসিলেউইচকের উত্তর দুর্দান্ত। তবে সামান্য সংযোজন এমন ঘটনাগুলি ধরতে সহায়তা করে যেখানে আপনি এই ফাংশনটিকে টেমপ্লেট আর্গুমেন্টগুলির সাথে কল করছেন যা বুদ্ধিমান নয় (উদাহরণস্বরূপ ফ্লোট) বা এর ফলে অগোছালো সংকলক ত্রুটির (যেমন ব্যবহারকারী-সংজ্ঞায়িত প্রকার) হতে পারে।
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::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] যে আমি আমার প্রকল্প থেকে কপি করেছিলাম, সুতরাং সেখানে একটি জার্মান এপিআই ডক অন্তর্ভুক্ত রয়েছে। আমার লক্ষ্যটি ছিল আমার আসল প্রয়োজনের মধ্যে নমনীয়তা এবং সুরক্ষা একত্রিত করা: [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] কর্নেল কিসিলেউইচজের উত্তরের ভিত্তিতে
[২] সিপ্পেস্টেস্টের ভাষায় অনূদিত , এটি এইভাবে পড়ে:
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;
}clearsstreamhexStrreturn sstream.str();clear
sstream.clear();? sstreamঅবজেক্ট স্বয়ংক্রিয়ভাবে সুযোগ শেষে ধ্বংস করা হয়, তাই return sstream.str();এটা করতে হবে।
sstream.clearস্ট্রপটি স্কোপ শেষের আগে শেষ হয়ে যাওয়ার আগে কেবল সামগ্রীটি সাফ করবে (কোনও ব্যর্থ এবং সাফের সাথে পতাকাগুলি সাফ করার জন্য)। প্রকৃতপক্ষে, যখন স্ট্র্যাপ-ভেরিয়েবলের জীবনকাল নিয়ে সুযোগটি মরে যায় এবং সুতরাং sstream.strমান দ্বারা ফিরে আসতে ব্যবহার করা যেতে পারে। [রেফারেন্স: cplusplus.com/references/ios/ios/clear/]
আমার সমাধান। শুধুমাত্র অবিচ্ছেদ্য প্রকারের অনুমতি দেওয়া হয়।
হালনাগাদ. আপনি দ্বিতীয় প্যারামিটারে alচ্ছিক উপসর্গ 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
0xfffffffffffffffe
fe
fe fffffffe
fffffffffffffffe
আমি সি ++ ভাষার সৌন্দর্য উপভোগ করার জন্য একটি উত্তর যুক্ত করতে চাই। উচ্চ এবং নিম্ন স্তরে কাজ করার জন্য এটি অভিযোজ্য। শুভ প্রোগ্রামিং।
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 ঠিকানা = (অন্তর্) & var;
এটি অন্য কোথাও দেখেছি ...
স্বাক্ষরবিহীন দীর্ঘ ঠিকানা = পুনরায় ব্যাখ্যা_কাস্ট (& var);
মন্তব্য আমাকে বলেছে যে এটি সঠিক ...
int ঠিকানা = (অন্তর্) এবং বিভিন্ন;
ভাল covered াকা হালকা কথা বলছেন , আপনি কোথায়? তারা অনেক বেশি পছন্দ পাচ্ছে!
unsigned longকিন্তু std::intptr_t।
intptr_tবিল্ড প্ল্যাটফর্মে কোনো পয়েন্টার সংরক্ষণ করতে পারেন; এটি [অগত্যা] সত্য নয় unsigned int। এবং আবারও, এগুলির কোনওোটাই প্রশ্নের সাথে প্রাসঙ্গিক নয়। আমার কাছ থেকে আর কোনও প্রতিক্রিয়া নেই
int