আমার আছে:
uint8 buf[] = {0, 1, 10, 11};
আমি বাইট অ্যারেটিকে একটি স্ট্রিতে রূপান্তর করতে চাই যাতে আমি প্রিন্টফ ব্যবহার করে স্ট্রিংটি মুদ্রণ করতে পারি:
printf("%s\n", str);
এবং পান (কলোনগুলি প্রয়োজনীয় নয়):
"00:01:0A:0B"
কোন সাহায্যের ব্যাপকভাবে প্রশংসা হবে।
উত্তর:
printf("%02X:%02X:%02X:%02X", buf[0], buf[1], buf[2], buf[3]);
আরও সাধারণ উপায় জন্য:
int i;
for (i = 0; i < x; i++)
{
if (i > 0) printf(":");
printf("%02X", buf[i]);
}
printf("\n");
স্ট্রিংয়ের সাথে যুক্ত হতে, কয়েকটি উপায় আপনি এটি করতে পারেন ... আমি সম্ভবত স্ট্রিংয়ের শেষে একটি পয়েন্টার রেখেছি এবং স্প্রিন্টফ ব্যবহার করব। বরাদ্দকৃত জায়গার চেয়ে এটি আরও বড় হয় না তা নিশ্চিত করতে আপনার অ্যারের আকারের উপর নজর রাখতে হবে:
int i;
char* buf2 = stringbuf;
char* endofbuf = stringbuf + sizeof(stringbuf);
for (i = 0; i < x; i++)
{
/* i use 5 here since we are going to add at most
3 chars, need a space for the end '\n' and need
a null terminator */
if (buf2 + 5 < endofbuf)
{
if (i > 0)
{
buf2 += sprintf(buf2, ":");
}
buf2 += sprintf(buf2, "%02X", buf[i]);
}
}
buf2 += sprintf(buf2, "\n");
printf("%02X", (unsigned char)buf[i]);মূল হিসাবে ব্যবহার করা উচিত স্বাক্ষরযুক্ত চরগুলির জন্য উপচে
printf("%02hhX", buf[i])?
কমপ্লিটডের জন্য, আপনি কোনও ভারী লাইব্রেরি ফাংশন (কোনও স্নারপ্রিন্টফ, কোনও স্ট্রিকাট, এমনকি মেমকিও নাও) কল না করে সহজেই এটি করতে পারেন। এটি দরকারী হতে পারে, আপনি যদি এমন কোনও মাইক্রোকন্ট্রোলার বা ওএস কার্নেল প্রোগ্রামিং করছেন যেখানে libc উপলব্ধ নেই say
আপনি যদি এর জন্য গুগল করেন তবে আশেপাশে তেমন কোনও কোড খুঁজে পাওয়া যায় না ancy সত্যিই এটি স্নিপ্রিন্টফ কল করার চেয়ে বেশি জটিল নয় এবং আরও দ্রুত।
#include <stdio.h>
int main(){
unsigned char buf[] = {0, 1, 10, 11};
/* target buffer should be large enough */
char str[12];
unsigned char * pin = buf;
const char * hex = "0123456789ABCDEF";
char * pout = str;
int i = 0;
for(; i < sizeof(buf)-1; ++i){
*pout++ = hex[(*pin>>4)&0xF];
*pout++ = hex[(*pin++)&0xF];
*pout++ = ':';
}
*pout++ = hex[(*pin>>4)&0xF];
*pout++ = hex[(*pin)&0xF];
*pout = 0;
printf("%s\n", str);
}
এখানে আরেকটি সংক্ষিপ্ততর সংস্করণ। এটি কেবলমাত্র মধ্যবর্তী সূচী ভেরিয়েবল আই এবং ডুপ্লিকেট করা লাস্ট কেস কোডটি এড়িয়ে যায় (তবে শেষের অক্ষরটি দুটি বার লেখা হয়)।
#include <stdio.h>
int main(){
unsigned char buf[] = {0, 1, 10, 11};
/* target buffer should be large enough */
char str[12];
unsigned char * pin = buf;
const char * hex = "0123456789ABCDEF";
char * pout = str;
for(; pin < buf+sizeof(buf); pout+=3, pin++){
pout[0] = hex[(*pin>>4) & 0xF];
pout[1] = hex[ *pin & 0xF];
pout[2] = ':';
}
pout[-1] = 0;
printf("%s\n", str);
}
নীচে একটি মন্তব্যের জবাব দেওয়ার জন্য আরও একটি সংস্করণ রয়েছে যে ইনপুট বাফারটির আকার জানতে আমি "কৌশল" ব্যবহার করেছি। আসলে এটি কোনও কৌশল নয় বরং প্রয়োজনীয় ইনপুট জ্ঞান (আপনার রূপান্তরকারী ডেটার আকারটি আপনার জানা দরকার)। আমি আলাদা ফাংশনে রূপান্তর কোডটি বের করে এই পরিষ্কার করেছি। আমি টার্গেট বাফারের জন্য সীমানা চেক কোডও যুক্ত করেছি, যা আমরা যদি জানি যে আমরা কী করছি তা সত্যিই প্রয়োজনীয় নয়।
#include <stdio.h>
void tohex(unsigned char * in, size_t insz, char * out, size_t outsz)
{
unsigned char * pin = in;
const char * hex = "0123456789ABCDEF";
char * pout = out;
for(; pin < in+insz; pout +=3, pin++){
pout[0] = hex[(*pin>>4) & 0xF];
pout[1] = hex[ *pin & 0xF];
pout[2] = ':';
if (pout + 3 - out > outsz){
/* Better to truncate output string than overflow buffer */
/* it would be still better to either return a status */
/* or ensure the target buffer is large enough and it never happen */
break;
}
}
pout[-1] = 0;
}
int main(){
enum {insz = 4, outsz = 3*insz};
unsigned char buf[] = {0, 1, 10, 11};
char str[outsz];
tohex(buf, insz, str, outsz);
printf("%s\n", str);
}
inএবং আউটপুট বাফারটিকে কল করতে আপনি আরও বেশি অর্থ কী চান out? আমি আউটপুট বাফার সরবরাহের পরিবর্তে একটি স্ট্রিং ব্যবহার এবং একটি অনুলিপি ফেরানোর বিকল্প বেছে নিতে পারি, আধুনিক সি ++ অপ্টিমাইজারগুলিতে বেশি যত্ন নেওয়ার পক্ষে যথেষ্ট।
এখানে একটি পদ্ধতি যা দ্রুততর উপায়:
#include <stdlib.h>
#include <stdio.h>
unsigned char * bin_to_strhex(const unsigned char *bin, unsigned int binsz,
unsigned char **result)
{
unsigned char hex_str[]= "0123456789abcdef";
unsigned int i;
if (!(*result = (unsigned char *)malloc(binsz * 2 + 1)))
return (NULL);
(*result)[binsz * 2] = 0;
if (!binsz)
return (NULL);
for (i = 0; i < binsz; i++)
{
(*result)[i * 2 + 0] = hex_str[(bin[i] >> 4) & 0x0F];
(*result)[i * 2 + 1] = hex_str[(bin[i] ) & 0x0F];
}
return (*result);
}
int main()
{
//the calling
unsigned char buf[] = {0,1,10,11};
unsigned char * result;
printf("result : %s\n", bin_to_strhex((unsigned char *)buf, sizeof(buf), &result));
free(result);
return 0
}
ca9e3c972f1c5db40c0b4a66ab5bc1a20ca4457bdbe5e0f8925896d5ed37d726এবং আপনি ÌaÌe3cÌ72f1c5dÌ40c0b4a66Ìb5bÌ1Ì20cÌ4457bÌbÌ5Ì0Ì8Ì258Ì6Ì5Ìd37Ì726বেরিয়ে যাবেন । এটি ঠিক করতে, hex_strলুপের জন্য প্রথম লাইনটির (input[i] >> 4) & 0x0Fবিটটির ভিতরে @ ক্রিসের উত্তর হিসাবে পরিবর্তন করা দরকার। তারপরে এটি কাজ করে।
অনুরূপ উত্তরগুলি ইতিমধ্যে উপরে রয়েছে, নিম্নলিখিত কোডের লাইনটি ঠিক কীভাবে কাজ করে তা ব্যাখ্যা করার জন্য আমি এটিকে যুক্ত করেছি:
ptr += sprintf(ptr, "%02X", buf[i])
এটি শান্ত কৌশল এবং বুঝতে সহজ নয়, আমি নীচের মন্তব্যে ব্যাখ্যাটি রেখেছি:
uint8 buf[] = {0, 1, 10, 11};
/* Allocate twice the number of bytes in the "buf" array because each byte would
* be converted to two hex characters, also add an extra space for the terminating
* null byte.
* [size] is the size of the buf array */
char output[(size * 2) + 1];
/* pointer to the first item (0 index) of the output array */
char *ptr = &output[0];
int i;
for (i = 0; i < size; i++) {
/* "sprintf" converts each byte in the "buf" array into a 2 hex string
* characters appended with a null byte, for example 10 => "0A\0".
*
* This string would then be added to the output array starting from the
* position pointed at by "ptr". For example if "ptr" is pointing at the 0
* index then "0A\0" would be written as output[0] = '0', output[1] = 'A' and
* output[2] = '\0'.
*
* "sprintf" returns the number of chars in its output excluding the null
* byte, in our case this would be 2. So we move the "ptr" location two
* steps ahead so that the next hex string would be written at the new
* location, overriding the null byte from the previous hex string.
*
* We don't need to add a terminating null byte because it's been already
* added for us from the last hex string. */
ptr += sprintf(ptr, "%02X", buf[i]);
}
printf("%s\n", output);
আমি কেবল নিম্নলিখিতটি যুক্ত করতে চেয়েছিলাম, যদিও এটি সামান্য অফ-টপিক (মান সি নয়), তবে আমি নিজেকে প্রায়শই এটি খুঁজছি এবং প্রথম অনুসন্ধানের মধ্যে এই প্রশ্নটির পিছনে হোঁচট খাচ্ছি। লিনাক্স কার্নেল প্রিন্ট ফাংশন,printk ফাংশনটিতে একটি একক বিন্যাস নির্দিষ্টকরণকারকের মাধ্যমে অ্যারে / মেমরির বিষয়বস্তুগুলি "সরাসরি" আউটপুট দেওয়ার জন্য ফর্ম্যাট স্পেসিফায়ারও রয়েছে:
https://www.kernel.org/doc/Docamentation/printk-formats.txt
Raw buffer as a hex string:
%*ph 00 01 02 ... 3f
%*phC 00:01:02: ... :3f
%*phD 00-01-02- ... -3f
%*phN 000102 ... 3f
For printing a small buffers (up to 64 bytes long) as a hex string with
certain separator. For the larger buffers consider to use
print_hex_dump().
... তবে, এই ফর্ম্যাট নির্দিষ্টকরণগুলির স্ট্যান্ডার্ড, ব্যবহারকারী-স্পেসের জন্য উপস্থিত রয়েছে বলে মনে হয় না (s)printf।
ফাংশন btoxঅবাধ তথ্য পরিবর্তন করে *bbএকটি অসমাপ্ত স্ট্রিং *xpএর nহেক্সাডেসিমেল সংখ্যা:
void btox(char *xp, const char *bb, int n)
{
const char xx[]= "0123456789ABCDEF";
while (--n >= 0) xp[n] = xx[(bb[n>>1] >> ((1 - (n&1)) << 2)) & 0xF];
}
#include <stdio.h>
typedef unsigned char uint8;
void main(void)
{
uint8 buf[] = {0, 1, 10, 11};
int n = sizeof buf << 1;
char hexstr[n + 1];
btox(hexstr, buf, n);
hexstr[n] = 0; /* Terminate! */
printf("%s\n", hexstr);
}
ফলাফল: 00010A0B।
লাইভ: Tio.run ।
রূপান্তর সম্পাদনের এটি একটি উপায়:
#include<stdio.h>
#include<stdlib.h>
#define l_word 15
#define u_word 240
char *hex_str[]={"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"};
main(int argc,char *argv[]) {
char *str = malloc(50);
char *tmp;
char *tmp2;
int i=0;
while( i < (argc-1)) {
tmp = hex_str[*(argv[i]) & l_word];
tmp2 = hex_str[*(argv[i]) & u_word];
if(i == 0) { memcpy(str,tmp2,1); strcat(str,tmp);}
else { strcat(str,tmp2); strcat(str,tmp);}
i++;
}
printf("\n********* %s *************** \n", str);
}
অল্প পরিমাণে ইয়েনিথ সংস্করণ সংশোধিত। এটি কেবলমাত্র আমি এটির ফেরতের মান হিসাবে পেতে চাই
typedef struct {
size_t len;
uint8_t *bytes;
} vdata;
char* vdata_get_hex(const vdata data)
{
char hex_str[]= "0123456789abcdef";
char* out;
out = (char *)malloc(data.len * 2 + 1);
(out)[data.len * 2] = 0;
if (!data.len) return NULL;
for (size_t i = 0; i < data.len; i++) {
(out)[i * 2 + 0] = hex_str[(data.bytes[i] >> 4) & 0x0F];
(out)[i * 2 + 1] = hex_str[(data.bytes[i] ) & 0x0F];
}
return out;
}এই ফাংশনটি উপযুক্ত যেখানে ব্যবহারকারী / কলার হেক্স স্ট্রিংটিকে একটি বৈশিষ্ট্যযুক্ত অ্যারে / বাফারে রাখতে চান। ক্যারেক্টার বাফারে হেক্স স্ট্রিং সহ ব্যবহারকারী / কলার তার নিজের ম্যাক্রো / ফাংশনটি এটির যে কোনও স্থানে (যেমন কোনও ফাইলের জন্য) প্রদর্শন করতে বা লগ করতে ব্যবহার করতে পারে। এই ফাংশনটি কলারকে প্রতিটি লাইনে লাগানোর (হেক্স) বাইট সংখ্যা নিয়ন্ত্রণ করতে দেয়।
/**
* @fn
* get_hex
*
* @brief
* Converts a char into bunary string
*
* @param[in]
* buf Value to be converted to hex string
* @param[in]
* buf_len Length of the buffer
* @param[in]
* hex_ Pointer to space to put Hex string into
* @param[in]
* hex_len Length of the hex string space
* @param[in]
* num_col Number of columns in display hex string
* @param[out]
* hex_ Contains the hex string
* @return void
*/
static inline void
get_hex(char *buf, int buf_len, char* hex_, int hex_len, int num_col)
{
int i;
#define ONE_BYTE_HEX_STRING_SIZE 3
unsigned int byte_no = 0;
if (buf_len <= 0) {
if (hex_len > 0) {
hex_[0] = '\0';
}
return;
}
if(hex_len < ONE_BYTE_HEX_STRING_SIZE + 1)
{
return;
}
do {
for (i = 0; ((i < num_col) && (buf_len > 0) && (hex_len > 0)); ++i )
{
snprintf(hex_, hex_len, "%02X ", buf[byte_no++] & 0xff);
hex_ += ONE_BYTE_HEX_STRING_SIZE;
hex_len -=ONE_BYTE_HEX_STRING_SIZE;
buf_len--;
}
if (buf_len > 1)
{
snprintf(hex_, hex_len, "\n");
hex_ += 1;
}
} while ((buf_len) > 0 && (hex_len > 0));
}
উদাহরণ: কোড
#define DATA_HEX_STR_LEN 5000
char data_hex_str[DATA_HEX_STR_LEN];
get_hex(pkt, pkt_len, data_hex_str, DATA_HEX_STR_LEN, 16);
// ^^^^^^^^^^^^ ^^
// Input byte array Number of (hex) byte
// to be converted to hex string columns in hex string
printf("pkt:\n%s",data_hex_str)
আউটপুট
pkt:
BB 31 32 00 00 00 00 00 FF FF FF FF FF FF DE E5
A8 E2 8E C1 08 06 00 01 08 00 06 04 00 01 DE E5
A8 E2 8E C1 67 1E 5A 02 00 00 00 00 00 00 67 1E
5A 01
আপনি যদি একটি char *স্ট্রিংয়ে হেক্স মানগুলি সঞ্চয় করতে চান তবে আপনি ব্যবহার করতে পারেনsnprintf । আপনাকে নেতৃস্থানীয় শূন্য এবং কোলন সহ সমস্ত মুদ্রিত অক্ষরের জন্য স্থান বরাদ্দ করতে হবে।
মার্কের উত্তরটি প্রসারিত:
char str_buf* = malloc(3*X + 1); // X is the number of bytes to be converted
int i;
for (i = 0; i < x; i++)
{
if (i > 0) snprintf(str_buf, 1, ":");
snprintf(str_buf, 2, "%02X", num_buf[i]); // need 2 characters for a single hex value
}
snprintf(str_buf, 2, "\n\0"); // dont forget the NULL byte
সুতরাং এখন str_bufহেক্স স্ট্রিং থাকবে।
জিঙ্কএক্সের সমাধানটি কোলন ডিলিটারগুলি অন্তর্ভুক্ত করার জন্য অভিযোজিত:
char buf[] = {0,1,10,11};
int i, size = sizeof(buf) / sizeof(char);
char *buf_str = (char*) malloc(3 * size), *buf_ptr = buf_str;
if (buf_str) {
for (i = 0; i < size; i++)
buf_ptr += sprintf(buf_ptr, i < size - 1 ? "%02X:" : "%02X\0", buf[i]);
printf("%s\n", buf_str);
free(buf_str);
}
যারা আগ্রহী তাদের জন্য আমি এখানে সি ++ সংস্করণ যুক্ত করব ।
#include <iostream>
#include <iomanip>
inline void print_bytes(char const * buffer, std::size_t count, std::size_t bytes_per_line, std::ostream & out) {
std::ios::fmtflags flags(out.flags()); // Save flags before manipulation.
out << std::hex << std::setfill('0');
out.setf(std::ios::uppercase);
for (std::size_t i = 0; i != count; ++i) {
auto current_byte_number = static_cast<unsigned int>(static_cast<unsigned char>(buffer[i]));
out << std::setw(2) << current_byte_number;
bool is_end_of_line = (bytes_per_line != 0) && ((i + 1 == count) || ((i + 1) % bytes_per_line == 0));
out << (is_end_of_line ? '\n' : ' ');
}
out.flush();
out.flags(flags); // Restore original flags.
}
এটা hexdump প্রিন্ট হবে bufferদৈর্ঘ্যের countথেকে std::ostream out(আপনি এটি ডিফল্ট বানাতে পারেন std::cout)। প্রতিটি লাইনে bytes_per_lineবাইট থাকবে, প্রতিটি বাইট বড় হাতের দুটি অঙ্কের হেক্স ব্যবহার করে উপস্থাপন করা হবে। বাইটের মধ্যে একটি স্থান থাকবে। এবং লাইনের শেষে বা বাফার শেষে এটি একটি নতুন লাইন প্রিন্ট করবে। যদি bytes_per_line0 তে সেট করা থাকে তবে এটি নতুন_লাইন প্রিন্ট করবে না। নিজের জন্য চেষ্টা করুন।
সাধারণ ব্যবহারের জন্য আমি একটি ফাংশন তৈরি করেছি যা ইনপুট স্ট্রিংকে বাইনারি করে (বাইনারি ডেটা):
/* Encodes string to hexadecimal string reprsentation
Allocates a new memory for supplied lpszOut that needs to be deleted after use
Fills the supplied lpszOut with hexadecimal representation of the input
*/
void StringToHex(unsigned char *szInput, size_t size_szInput, char **lpszOut)
{
unsigned char *pin = szInput;
const char *hex = "0123456789ABCDEF";
size_t outSize = size_szInput * 2 + 2;
*lpszOut = new char[outSize];
char *pout = *lpszOut;
for (; pin < szInput + size_szInput; pout += 2, pin++)
{
pout[0] = hex[(*pin >> 4) & 0xF];
pout[1] = hex[*pin & 0xF];
}
pout[0] = 0;
}
ব্যবহার:
unsigned char input[] = "This is a very long string that I want to encode";
char *szHexEncoded = NULL;
StringToHex(input, strlen((const char *)input), &szHexEncoded);
printf(szHexEncoded);
// The allocated memory needs to be deleted after usage
delete[] szHexEncoded;
ইয়ানুথের উত্তরের ভিত্তিতে কিন্তু সরলীকৃত।
এখানে দৈর্ঘ্যের dest[]দ্বিগুণ হতে থাকে lenএবং এর বরাদ্দ কলার দ্বারা পরিচালিত হয়।
void create_hex_string_implied(const unsigned char *src, size_t len, unsigned char *dest)
{
static const unsigned char table[] = "0123456789abcdef";
for (; len > 0; --len)
{
unsigned char c = *src++;
*dest++ = table[c >> 4];
*dest++ = table[c & 0x0f];
}
}
আমি জানি এই প্রশ্নের ইতিমধ্যে একটি উত্তর রয়েছে তবে আমি মনে করি আমার সমাধানটি কারও পক্ষে সহায়তা করতে পারে।
সুতরাং, আমার ক্ষেত্রে কীটি উপস্থাপন করে আমার কাছে একটি বাইট অ্যারে ছিল এবং এটি একটি লাইনে মুদ্রণের জন্য আমার এই বাইট অ্যারেটিকে হেক্সাডেসিমাল মানগুলির চর অ্যারে রূপান্তর করতে হবে। আমি এই জাতীয় কোনও কার্যে আমার কোডটি বের করেছি:
char const * keyToStr(uint8_t const *key)
{
uint8_t offset = 0;
static char keyStr[2 * KEY_SIZE + 1];
for (size_t i = 0; i < KEY_SIZE; i++)
{
offset += sprintf(keyStr + offset, "%02X", key[i]);
}
sprintf(keyStr + offset, "%c", '\0');
return keyStr;
}
এখন, আমি এইভাবে আমার ফাংশনটি ব্যবহার করতে পারি:
Serial.print("Public key: ");
Serial.println(keyToStr(m_publicKey));
Serial বস্তুটি আরডুইনো গ্রন্থাগারের অংশ এবং m_publicKey নিম্নলিখিত ঘোষণার সাথে আমার শ্রেণীর সদস্য uint8_t m_publicKey[32]।
আপনি স্নিপ্রিন্টফ এবং ম্যালোক দিয়ে সমাধান করতে পারেন।
char c_buff[50];
u8_number_val[] = { 0xbb, 0xcc, 0xdd, 0x0f, 0xef, 0x0f, 0x0e, 0x0d, 0x0c };
char *s_temp = malloc(u8_size * 2 + 1);
for (uint8_t i = 0; i < u8_size; i++)
{
snprintf(s_temp + i * 2, 3, "%02x", u8_number_val[i]);
}
snprintf(c_buff, strlen(s_temp)+1, "%s", s_temp );
printf("%s\n",c_buff);
free(s);
আউট: bbccdd0fef0f0e0d0c
কী জটিল সমাধান!
মলোক এবং স্প্রিন্ট এবং ক্যাসেট ওহ আমার। (ওজেডের উদ্ধৃতি)
এবং কোথাও একক রেম নয়। গোশ
কেমন আছে এরকম কিছু?
main()
{
// the value
int value = 16;
// create a string array with a '\0' ending ie. 0,0,0
char hex[]= {0,0,'\0'};
char *hex_p=hex;
//a working variable
int TEMP_int=0;
// get me how many 16s are in this code
TEMP_int=value/16;
// load the first character up with
// 48+0 gives you ascii 0, 55+10 gives you ascii A
if (TEMP_int<10) {*hex_p=48+TEMP_int;}
else {*hex_p=55+TEMP_int;}
// move that pointer to the next (less significant byte)<BR>
hex_p++;
// get me the remainder after I have divied by 16
TEMP_int=value%16;
// 48+0 gives you ascii 0, 55+10 gives you ascii A
if (TEMP_int<10) {*hex_p=48+TEMP_int;}
else {*hex_p=55+TEMP_int;}
// print the result
printf("%i , 0x%s",value,hex);
}
buf[i]অবশ্যইunsigned charbuf[i] > 127buf_ptr += sprintf(buf_ptr, "%02X", (unsigned char)buf[i]);