Efficient binary to hexadecimal string conversion

A LUT (lookup table) C ++ variant. I haven't tested the resulting machine code, but I believe that any modern C ++ compiler can catch the idea and compile it well.

static const char nibble2hexChar[] { "0123456789ABCDEF" };
     // 17B in total, because I'm lazy to init it per char

void byteToHex(std::ostream & out, const uint8_t value) {
    out << nibble2hexChar[value>>4] << nibble2hexChar[value&0xF];
}

// this one is actually written more toward short+simple source, than performance
void dwordToHex(std::ostream & out, uint32_t value) {
    int i = 8;
    while (i--) {
        out << nibble2hexChar[value>>28];
        value <<= 4;
    }
}

      

        
        
        
      

    

EDIT: For C code, you just need to switch from std::ostream

to some other inference means, unfortunately your question does not go into any detail on what you are actually trying to achieve and why you are not using the built- printf

in C family of functions.

For example, C like this could write to some output buffer char*

, converting an arbitrary number of bytes:

/**
 * Writes hexadecimally formatted "n" bytes array "values" into "outputBuffer".
 * Make sure there enough space in output buffer allocated, and add zero
 * terminator yourself, if you plan to use it as C-string.
 * 
 * @Returns: pointer after the last character written.
 */
char* dataToHex(char* outputBuffer, const size_t n, const unsigned char* values) {
    for (size_t i = 0; i < n; ++i) {
        *outputBuffer++ = nibble2hexChar[values[i]>>4];
        *outputBuffer++ = nibble2hexChar[values[i]&0xF];
    }
    return outputBuffer;
}

      

        
        
        
      

    

And finally, I really helped someone in reviewing the code as it had a performance bottleneck with hexadecimal formatting, but I did a code conversion there without LUTs, and the whole process and another dimension of the answer + might be a tutorial for you as you can see that the fastest solution does not just blindly convert the result, but actually mixes with the main operation to achieve the best overall performance. So why I'm wondering what you are trying to solve, as the whole problem can often allow for a better solution if you just ask about conversion printf("%x",..)

- a safe bet.

Here's another approach to "hex" conversion: C ++ Swift XOR Function

Slightly more worthy integer to string conversion any base from 2 to digit length

char *reverse(char *);

const char digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char *convert(long long number, char *buff, int base)
{
    char *result = (buff == NULL || base > strlen(digits) || base < 2) ? NULL : buff;
    char sign = 0;

    if (number < 0)
    {
         sign = '-';
        number = -number;
    }
    if (result != NULL)
    {
        do
        {
            *buff++ = digits[number % base];
            number /= base;
        } while (number);
        if(sign) *buff++ = sign;
        *buff = 0;
        reverse(result);
    }
    return result;
}


char *reverse(char *str)
{
    char tmp;
    int len;

    if (str != NULL)
    {
        len = strlen(str);
        for (int i = 0; i < len / 2; i++)
        {
            tmp = *(str + i);
            *(str + i) = *(str + len - i - 1);
            *(str + len - i - 1) = tmp;

        }
    }
    return str;
}

      

        
        
        
      

    

example - counting from -50 to 50 decimal places in base 23

-24     -23     -22     -21     -20     -1M     -1L     -1K     -1J     -1I     -1H     -1G     -1F     -1E     -1D
-1C     -1B     -1A     -19     -18     -17     -16     -15     -14     -13     -12     -11     -10     -M      -L
-K      -J      -I      -H      -G      -F      -E      -D      -C      -B      -A      -9      -8      -7      -6
-5      -4      -3      -2      -1      0       1       2       3       4       5       6       7       8       9
A       B       C       D       E       F       G       H       I       J       K       L       M       10      11
12      13      14      15      16      17      18      19      1A      1B      1C      1D      1E      1F      1G
1H      1I      1J      1K      1L      1M      20      21      22      23      24

      

        
        
        
      

    

• Decimal -> Hex
  
  

Just repeat the string string and each character is converted to int

, then you can do

printf("%02x", c);

      

        
        
        
      

    

or use sprintf

to store in another variable

2. Hex -> Decimal
   
   

code

printf("%c",16 * hexToInt('F') + hexToInt('0'));


int hexToInt(char c)
{
    if(c >= 'a' && c <= 'z')
        c = c - ('a' - 'A');

    int sum;

    sum = c / 16 - 3;
    sum *= 10;
    sum += c % 16;

    return (sum > 9) ? sum - 1 : sum;
}