Преобразование массива unsigned char в шестнадцатеричный

Question

Я хочу преобразовать unsigned char в hex (используя unsigned int). Это мой код до сих пор. У меня есть program1, который создает массив unsigned char, а другой program2 принимает только hex (используя unsigned int), поэтому я хочу получить вход беззнакового массива char и преобразовать этот массив в hex.

(например, program1 выходы "1234567812345678", program2 должен вывести "31323334353637383132333435363738")

К сожалению, если этот вопрос кажется немой. Посмотрел на ответы здесь, но, похоже, это не то, что я хотел.

uint64_t phex (unsigned char[16], long); 



int main (void) { 

int i; 
unsigned char key[16] = "1234567812345678"; 


uint64_t* keyHex = phex(key,16); //store into an array here 

for(i = 0; i < 16; i++) 
printf("%.2x ", keyHex[i]); 

free(keyHex); 

return 0; 

} 


uint64_t phex(unsigned char* string, long len) 
{ 

int i; 
//allocate memory for your array 
uint64_t* hex = (uint64_t*)malloc(sizeof(uint64_t) * len); 

for(i = 0; i < len; ++i) { 
    //do char to int conversion on every element of char array 
    hex[i] = string[i] - '0'; 
} 

//return integer array 
return hex; 

} 

Answer 1

Я вижу сигнатуру функции, как

uint64_t phex (unsigned char[16], long); 

, так что я думаю, вам не нужно массив uint64_t для преобразования одной строки, представляющей одно число (возможно, я не прав, и вы хотите, чтобы преобразовать каждый один символ из его char-представления в int и показывать как шестнадцатеричное число).

Во-первых, давайте рассмотрим следующий код для преобразования в десятичной системе счисления (на самом деле, номер в вашем примере - 1234567812345678 - выглядит как десятичное число):

uint64_t phex(unsigned char* string, long len) 
{ 

    int i; 
    //you do not need to allocate memory for array 
    uint64_t hex = 0; // just one variable 

    for (i = 0; i < len; ++i) { 
     hex *= 10; // shift 
     hex += string[i] - '0'; // add to the smallest rank 
    } 

    //return integer Value 
    return hex; 

} 

Затем шестнадцатеричной программа будет:

#include <stdio.h> 
#include <stdint.h> 
#include <string.h> 
uint64_t phex(unsigned char[16], long); 

int main(void) { 

    int i; 
    unsigned char key[16] = "A123B00CF1"; 


    uint64_t keyHex = phex(key, strlen(key)); 

    printf("%lld(dec) = %llx(hex)", keyHex, keyHex); 

    return 0; 
} 


uint64_t phex(unsigned char* string, long len) 
{ 
    int i; 
    uint64_t hex = 0; 
    for (i = 0; i < len; ++i) { 
     hex *= 0x10; // shift for one hexadecimal digit 
     // -'0' for digits 0..9 and -('A'-10) for digits `A`..`F` 
     hex += toupper(string[i]) - ((string[i] >= 'A') ? ('A' - 10) : '0'); 
     // TODO: Consider making check for characters that are not hexadecimal 
     // e.g. use isxdigit(string[i]) in some if statement 
    } 
    return hex; 
} 

Примечание: В вашем примере кода есть ошибка - uint64_t* keyHex принять значение из функции, которая возвращает uint64_t (не указатель `` uint64_t * `), но если вы Примите мою идею, вам не нужен указатель.

Answer 2

Если все, что вам нужно сделать, это распечатать значения, вам не нужно делать никаких преобразований. Просто используйте printf%.2x на исходном массиве.

int main (void) { 
    int i; 
    unsigned char key[16] = "1234567812345678"; 
    for(i = 0; i < 16; i++) 
     printf("%.2x", key[i]); 
    return 0; 
} 

Даже если вы хотите использовать массив в какой-либо другой функции, фактические байты, хранящиеся в key являются символы ASCII, то есть 0x310x32 и т.д. Вы можете, как правило, непосредственно использовать массив key

Edit: Чтобы сохранить вывод в массиве символов, вы можете использовать функцию sprintf.

char hex[33]; 
for(i = 0; i < 16; i++) 
    sprintf(hex+2*i, "%.2x", key[i]); 

Также обратите внимание, что исходный массив key должен быть 17 байт для учета \0 в конце.

Answer 3

Если задача состоит в том, чтобы преобразовать символы ('1', '2' и т. Д.) В их шестнадцатеричное представление (31 для '1', 32 для '2' и т. Д.), Трудно понять, почему вы требуется uint64_t.

Но ваш код задачи может быть следующим (без uint64_t):

#include <stdio.h> 
#include <string.h> 

unsigned int * phex(unsigned char[16], long); 

int main(void) { 
    int i; 
    unsigned char key[16] = "1234567812345678"; 
    unsigned* keyHex = phex(key, strlen(key)); // strlen(key) to determine number of characters 
    for (i = 0; i < 16; i++) 
     printf("%.2x", keyHex[i]); // you do need space as I see from your example 
    free(keyHex); 
    return 0; 

} 


unsigned int * phex(unsigned char* string, long len) 
{ 
    int i; 
    //allocate memory for array 
    unsigned int * hex = (unsigned int *)malloc(sizeof(unsigned int) * len); 
    for (i = 0; i < len; ++i) { 
     //no special conversion needed 
     hex[i] = string[i]; 
    } 
    //return array with hexadecimal representation for each character in string 
    return hex; 
} 

Answer 4

Вот мой взгляд на него - функция phex() преобразует любые данные в памяти во вновь выделенной строке, содержащей шестнадцатеричное представление.

Функция main() показывает пример использования. Выходной сигнал «31323334353637383930» для примера data.

#include <stdlib.h> /* malloc() */ 
#include <stdio.h> /* sprintf() */ 
#include <string.h> /* strlen(), in the example main() */ 

/* 
* Return a hex string representing the data pointed to by `p`, 
* converting `n` bytes. 
* 
* The string should be deallocated using `free()` by the caller. 
*/ 
char *phex(const void *p, size_t n) 
{ 
    const unsigned char *cp = p;    /* Access as bytes. */ 
    char *s = malloc(2*n + 1);  /* 2*n hex digits, plus NUL. */ 
    size_t k; 

    /* 
    * Just in case - if allocation failed. 
    */ 
    if (s == NULL) 
     return s; 

    for (k = 0; k < n; ++k) { 
     /* 
     * Convert one byte of data into two hex-digit characters. 
     */ 
     sprintf(s + 2*k, "%02X", cp[k]); 
    } 

    /* 
    * Terminate the string with a NUL character. 
    */ 
    s[2*n] = '\0'; 

    return s; 
} 

/* 
* Sample use of `phex()`. 
*/ 
int main(void) 
{ 
    const char *data = "1234567890";    /* Sample data */ 
    char *h = phex(data, strlen(data)); /* Convert to hex string */ 

    if (h != NULL) 
     puts(h);         /* Print result */ 

    free(h);        /* Deallocate hex string */ 
    return 0; 
}