Konvertieren von unsigned Char-Array zu Hexadezimal

Question

Ich möchte vorzeichenlosen Zeichen in Hex konvertieren (using unsigned int). Das ist bisher mein Code. Ich habe ein Programm1, das ein vorzeichenloses char-Array erzeugt, und das andere Programm2 nimmt nur hex auf (mit unsigned int), also möchte ich eine Eingabe eines unsignierten char-Arrays bekommen und dieses Array in hex konvertieren.

(Z. B. program1 Ausgänge "1234567812345678", program2 ausgeben sollte "31323334353637383132333435363738")

Sorry, wenn diese Frage dumm scheint. Ich suchte hier nach Antworten, aber es schien nicht das zu sein, was ich wollte.

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

Ich sehe die Funktion Signatur als

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

so glaube ich, brauchen Sie nicht Array von uint64_t einer Zeichenfolge zu verwandeln, was eine Zahl (vielleicht bin ich falsch, und Sie wollen, dass jeder zu transformieren einzelnes Zeichen von seiner Zeichendarstellung zu int und zeigt als hexadezimale Zahl an).

Lassen Sie uns zunächst den folgenden Code Transformation in dezimal betrachten (eigentlich Nummer in Ihrem Beispiel - 1234567812345678 - sieht aus wie Dezimalzahl):

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; 

} 

Dann für hexadezimal wird das Programm sein:

#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; 
} 

Hinweis: Es ist ein Fehler in Ihrem Beispiel-Code - uint64_t* keyHex den Wert von Funktion übernehmen, die uint64_t (nicht Zeiger `` uint64_t * `) gibt, aber wenn yo Du akzeptierst meine Idee, du brauchst überhaupt keinen Zeiger.

Answer 2

Wenn Sie nur die Werte drucken müssen, müssen Sie keine Konvertierung durchführen. Verwenden Sie einfach printf%.2x auf dem ursprünglichen Array.

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

Auch wenn Sie das Array in einer anderen Funktion, die tatsächlichen Bytes gespeichert in key sind die ASCII-Zeichen, dh 0x310x32 etc. Sie können in der Regel direkt verwenden, um den Array key

Bearbeiten verwenden möchten: Um die Ausgabe in einem Zeichen-Array zu speichern, können Sie die Funktion sprintf verwenden.

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

Beachten Sie auch, dass das ursprüngliche Array key 17 Bytes sein sollte für die \0 am Ende zu berücksichtigen.

Answer 3

Wenn die Aufgabe darin besteht, Zeichen ('1', '2' usw.) in ihre hexadezimale Darstellung zu transformieren (31 für '1', 32 für '2' usw.), ist es schwer zu verstehen, warum brauche uint64_t.

Aber für Ihren Code Aufgabe kann (ohne uint64_t) folgt sein:

#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

Hier mein nehmen auf sie - die phex() Funktion wandelt jede Daten im Speicher in einem neu zugewiesenen String der umschließende Hexadezimale Darstellung

Die Funktion main() zeigt eine Beispielverwendung. Die Ausgabe ist "31323334353637383930" für das Beispiel 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; 
}