How to convert unsigned char* to unsigned long long int?

Question

Does anyone know of a library that provides a function that performs this logic or perhaps a method to perform this logic?

I'm trying to convert:

unsigned char test[] = "\x00\x00\x56\x4b\x7c\x8a\xc5\xde";

to:

94882212005342 / 0x0000564b7c8ac5de

I'm aware I could loop over each individual byte in test and utilize sprintf to convert each byte to string and concatenate them into a buffer with strcat and convert the buffer string to unsigned long long via strtoull. However I'm looking for something more comprehensive and simple. Is there such a way?

Welcome to SO. It is not clear what you want. From the question I quess you want to get a unsigned long long from the byte array. But the part about `sprintf` does not fit at all. — Gerhardh, Mar 12 '21 at 13:13
As your array is not a valid string, I would suggest, not to use string notation. Instead you might use `unsigned char test[8] = {000, 0x00, 0x56, 0x4b, 0x7c, 0x8a, 0xc5, 0xde}` — Gerhardh, Mar 12 '21 at 13:17
Why is your 64 bit memory address a string to begin with? Why not an unsigned long? It already has the required bytes, presumably in the right order, and isn't even a valid string... — Mad Physicist, Mar 12 '21 at 13:17

KamilCuk · Accepted Answer · 2021-03-12T13:28:56.250

2

It's just maths.

unsigned char test[] = "\x00\x00\x56\x4b\x7c\x8a\xc5\xde";
unsigned long long num = 
     (unsigned long long)test[0] << 56 |
     (unsigned long long)test[1] << 48 |
     (unsigned long long)test[2] << 40 |
     (unsigned long long)test[3] << 32 |
     (unsigned long long)test[4] << 24 |
     (unsigned long long)test[5] << 16 |
     (unsigned long long)test[6] <<  8 |
     (unsigned long long)test[7] <<  0;

Remember to cast to type wide enough before shifting.

You have 8 values:

 { 0x00, 0x00, 0x56, 0x4b, 0x7c, 0x8a, 0xc5, 0xde }

which in the decimal is:

 0 0 86 75 124 138 197 222

and you want to have:

 94882212005342

which is:

  94882212005342 = 0*2^56 + 0*2^48 + 86*2^40 + 75*2^32 + 124*2^24 + 138*2^16 + 197*2^8 +  222*2^0

It's a mathematical operation. You could write ex test[0] * 72057594037927936ull but that's less readable then test[0] << 56.

edited Mar 12 '21 at 13:28

answered Mar 12 '21 at 13:16

KamilCuk

120,984
8
59
111

Could you give a bit of explanation as to what is happening here? – mehmed_ali343 Mar 12 '21 at 13:18
Take the first byte from `test`. But it at the 56 bit the output number. Take the second byte from `test`. But it at the 48 bit position in the output number. etc. – KamilCuk Mar 12 '21 at 13:18
Is it possible to condense this with a loop perhaps? – mehmed_ali343 Mar 12 '21 at 13:28
See https://github.com/biiont/gpsd/blob/master/bits.h#L45 – KamilCuk Mar 12 '21 at 13:32
@KamilCuk line 64, surely? `num = getbeu64(test, 0);`. – Ian Abbott Mar 12 '21 at 13:53
The link is not meant to be to a specific line - rather to the whole library. – KamilCuk Mar 12 '21 at 13:55
How would it be possible to do this with a 7-byte `unsigned char` array (6 + null-byte). – mehmed_ali343 Mar 13 '21 at 06:47

score 1 · Answer 2 · answered Mar 12 '21 at 13:20

1

I have done something very similar with the use of memmove or memcpy functions https://www.tutorialspoint.com/c_standard_library/c_function_memmove.htm

    long long int var = 0; 
    memmove( &var, test, sizeof(var) );

Make sure to use the correct byte order of your system.

answered Mar 12 '21 at 13:20

Luke

49
4

This will fail on little-endian systems. (or big endian, I always mix them). – KamilCuk Mar 12 '21 at 13:22
Aren't 90% of systems little-endian? Interesting point, it is very elegant though. – mehmed_ali343 Mar 12 '21 at 13:24
Sure, if you are looking for a general solution I totally agree.with @KamilCuk – Luke Mar 12 '21 at 13:30
@KamilCuk, it may be exactly what OP was asking for. OP may have been given implementation-defined `char[]` represetation of `ull` on OP's platfrom. This solution may be the correct one. – tstanisl Mar 12 '21 at 13:31
@tstanisl That violates the strict aliasing rule – klutt Mar 12 '21 at 13:46
Is there a similar method to do this in reverse-order `unsigned long long int` to `unsigned char*`? – mehmed_ali343 Mar 13 '21 at 03:51

score 0 · Answer 3 · answered Mar 12 '21 at 15:41

0

Just for the record, you can just simply do this:

#include <stdio.h>
#include <inttypes.h>

int main(int argc, char *argv[])
{
    unsigned char test[] = "\x00\x00\x56\x4b\x7c\x8a\xc5\xde";
    uint64_t val=0;
    for(size_t i=0; i<8; i++)
      val |= (uint64_t)test[i] << (7-i)*8;
    printf("%" PRIu64 " %" PRIX64, val, val);
}

answered Mar 12 '21 at 15:41

Lundin

195,001
40
254
396

And optionally: `#include _Static_assert(CHAR_BITS==8, "Get a useful computer instead of that crap.");` in case you need to ward off language lawyers, DSP programmers from the 1980s or other such creatures. – Lundin Mar 12 '21 at 15:43

klutt · Answer 4 · 2021-03-12T14:49:05.623

A fun BUT NOT RECOMMENDED way of doing this. If you want a proper solution, look at KamilCuk's answer

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

// Reverse an 8-byte array  
void rev(unsigned char *s) {
    unsigned char *end = s + 7; // Evil hard coded value

    while(s<end) {
        unsigned char tmp = *s;
        *s = *end;
        *end = tmp;
        s++;
        end--;
    }
}

int main(void) {
    unsigned char test[] = "\x00\x00\x56\x4b\x7c\x8a\xc5\xde";
    rev(test);                // Reverse the array
    long l;
    memcpy(&l, test, sizeof test);
    printf("%zx\n", l);
}

Note that the standard does not dictate the byte order. This is what works on MY machine. It will be the same on most machines, but if portability to other architectures is important to you. Don't even consider this.

However, since you're saying that the value is an address, I'd recommend using uintptr_t instead of long.

How to convert unsigned char* to unsigned long long int?

4 Answers4

Linked