Cでバイト配列を16進文字列に変換するにはどうすればよいですか？
私は持っています：
uint8 buf[] = {0, 1, 10, 11};
Printfを使用して文字列を印刷できるように、バイト配列を文字列に変換します。
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");
文字列に連結するには、いくつかの方法があります。おそらく、文字列の末尾へのポインタを保持し、sprintfを使用します。また、配列のサイズを追跡して、割り当てられたスペースより大きくならないようにする必要があります。
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");
完全に、重いライブラリ関数を呼び出さなくても簡単に実行できます（snprintf、strcat、memcpyでさえも）。 libcが利用できないマイクロコントローラーまたはOSカーネルをプログラミングしている場合などに便利です。
あなたがそれをグーグルで検索した場合、あなたが周りに同様のコードを見つけることができる本当に空想はありません。実際、snprintfを呼び出すよりもはるかに複雑ではなく、はるかに高速です。
#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);
}
もう少し短いバージョンがあります。中間インデックス変数iとラストケースコードの重複を避けるだけです（ただし、終端文字は2回書き込まれます）。
#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);
}
以下に、はるかに高速な方法を示します。
#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
}
同様の回答が既に上記に存在します。次のコード行が正確に機能する方法を説明するために、これを追加しました。
ptr += sprintf (ptr, "%02X", buf[i])
それは静かでトリッキーで、理解するのは簡単ではありません。以下のコメントに説明を入れます。
uint8 buf[] = {0, 1, 10, 11};
/* Allocate twice the number of the 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 to 2 chars hex string and a null byte, for example
* 10 => "0A\0".
*
* These three chars would be added to the output array starting from
* the ptr location, for example if ptr is pointing at 0 index then the hex chars
* "0A\0" would be written as output[0] = '0', output[1] = 'A' and output[2] = '\0'.
*
* sprintf returns the number of chars written execluding the null byte, in our case
* this would be 2. Then we move the ptr location two steps ahead so that the next
* hex char would be written just after this one and overriding this one's null byte.
*
* We don't need to add a terminating null byte because it's already added from
* the last hex string. */
ptr += sprintf (ptr, "%02X", buf[i]);
}
printf ("%s\n", output);
少しトピック（標準Cではない）であっても、以下を追加したかったのですが、頻繁に検索し、最初の検索ヒットでこの質問につまずいたことがわかりました。 Linuxカーネルの印刷関数printkには、単一の書式指定子を使用して配列/メモリの内容を「直接」出力するための書式指定子もあります。
https://www.kernel.org/doc/Documentation/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をn 16進数の未終了文字列*xpに変換します。
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 。
この関数は、ユーザー/呼び出し側が16進文字列を文字配列/バッファに入れたい場合に適しています。文字バッファーの16進文字列を使用すると、ユーザー/呼び出し元は独自のマクロ/関数を使用して、任意の場所（ファイルなど）に表示または記録できます。また、この関数を使用すると、呼び出し元は各行に入れる（16進数）バイト数を制御できます。
/**
* @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
これは、変換を実行する1つの方法です。
#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);
}
わずかに変更されたYannithバージョン。戻り値として持っているのが好きです
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;
}コロン区切り文字を含めるように適合されたZincXのソリューション：
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);
}
興味のある人のためにC++バージョンをここに追加します。
#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.
}
長さbufferからstd::ostreamcountへのoutの16進ダンプを出力します（デフォルトはstd::coutにできます）。各行にはbytes_per_lineバイトが含まれ、各バイトは大文字の2桁の16進数を使用して表されます。バイト間にスペースがあります。そして、行末またはバッファの終わりに改行を出力します。 bytes_per_lineが0に設定されている場合、new_lineは出力されません。自分で試してみてください。
16進値を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には16進数の文字列が含まれます。
これにはCにはプリミティブはありません。おそらく十分な長さのバッファーをmalloc（またはおそらくalloca）し、入力をループするでしょう。また、C++のostringstreamに似たセマンティクス（ただし、構文ではありません！）を使用した動的な文字列ライブラリで行われたことも確認しました。 。
簡単に使用するために、入力文字列（バイナリデータ）をエンコードする関数を作成しました。
/* 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;
Yannuthの answer に基づいていますが、簡略化されています。
ここで、dest[]の長さはlenの2倍であることが暗示されており、その割り当ては呼び出し元によって管理されます。
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];
}
}
この質問にはすでに答えがありますが、私の解決策は誰かを助けることができると思います。
したがって、私の場合、キーを表すバイト配列があり、このバイト配列を16進数値のchar配列に変換して1行で出力する必要がありました。次のような関数にコードを抽出しました。
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オブジェクトはArduinoライブラリの一部であり、m_publicKeyは次の宣言uint8_t m_publicKey[32]を持つクラスのメンバーです。