如何将四个16位uint编码为一个64位uint，然后再次对其进行解码？

Question

I wrote this function with the help of this page on bit twiddling :

uint16_t *decode(uint64_t instr) {
  // decode instr (this is new to me lol)
  uint16_t icode = (instr >> 48) & ((1 << 16) - 1);
  uint16_t p1    = (instr >> 32) & ((1 << 16) - 1);
  uint16_t p2    = (instr >> 16) & ((1 << 16) - 1);
  uint16_t p3    = (instr >> 00) & ((1 << 16) - 1);

  return (uint16_t[]){icode, p1, p2, p3};
}

I have this to test it:

uint16_t *arr = decode(number);
for(int i = 0; i < 4; i++) {
  printf("%d\n", arr[i]);
}

However, this prints 0 four times whatever number is. I also haven't solved the first part of the question, how to encode the four uint16_t's in the first place.

Answer 1

how to encode the four uint16_t's in the first place

This isn't hard. All you have to do is to load each uint16_t to a uint64_t one-by-one, and then return that uint64_t :

uint64_t encode(uint16_t uints[]) {
    uint64_t master = 0;
    for (uint8_t index = 0; index <= 3; ++index) {
        master <<= 16; // Shift master left by 16 bits to create space for the next uint16
        master |= uints[index]; // Load uints[index] to the lower 16 bits of master
    } // Do this four times
    return master;
}

To load the uint16_t s in reverse order, simply replace uint8_t index = 0; index <= 3; ++index uint8_t index = 0; index <= 3; ++index uint8_t index = 0; index <= 3; ++index with uint8_t index = 3; index >= 0; --index uint8_t index = 3; index >= 0; --index uint8_t index = 3; index >= 0; --index .

Answer 2

Your best bet is actually to use memcpy . Most modern compilers will optimize this into the necessary bit shifts and such for you.

uint64_t pack(const uint16_t arr[static 4]) {
    uint64_t res;
    memcpy(&res, arr, 8);
    return res;
}

void unpack(uint64_t v, uint16_t arr[static 4]) {
    memcpy(arr, &v, 8);
}

Note that the result is endian-dependent, appropriate for packing and unpacking on the same machine. Note too that I'm using the static array specifier to check that the caller passes at least 4 elements (when such checking is possible); if that gives your compiler grief, just remove the static specifier.

Answer 3

First, you can't pass an array back from a function the way you currently have it (which is why you're getting 0's), you'll need to pass it via pointer or static reference.

However, since you're dealing with 2 known bit-widths, you can use a mask and shift off that:

out[0] = val & 0x000000000000FFFF; // 1st word
out[1] = (val & 0x00000000FFFF0000) >> 16; // 2nd word
out[2] = (val & 0x0000FFFF00000000) >> 32; // 3rd word
out[3] = (val & 0xFFFF000000000000) >> 48; // 4th word

You could put this in a function or macro:

#define MACRO_DECODE(val, arr) arr[0]= val & 0x000000000000FFFF; \
                      arr[1] = (val & 0x00000000FFFF0000) >> 16; \
                      arr[2] = (val & 0x0000FFFF00000000) >> 32; \
                      arr[3] = (val & 0xFFFF000000000000) >> 48;

void decode(uint64_t val, uint16_t *out)
{
    out[0] = val & 0x000000000000FFFF;
    out[1] = (val & 0x00000000FFFF0000) >> 16;
    out[2] = (val & 0x0000FFFF00000000) >> 32;
    out[3] = (val & 0xFFFF000000000000) >> 48;
}


int main(int argc, char** argv)
{
    int i;
    uint16_t arr[] = { 0, 0, 0, 0} ;
    for (i = 0; i < 4; ++i) {
        printf("%#06x = %d\n", arr[i], arr[i]);
    }

    // as a function
    decode(0xAAAABBBBCCCCDDDD, arr);

    for (i = 0; i < 4; ++i) {
        printf("%#06x = %d\n", arr[i], arr[i]);
    }

    // as a macro
    MACRO_DECODE(0xDDDDCCCCBBBBAAAA, arr);
    for (i = 0; i < 4; ++i) {
        printf("%#06x = %d\n", arr[i], arr[i]);
    }
    return 0;
}

Additionally, you could use memcpy :

int main(int argc, char** argv)
{
    int i;
    uint16_t arr[] = { 0, 0, 0, 0} ;
    uint64_t src = 0xAAAABBBBCCCCDDDD;
    for (i = 0; i < 4; ++i) {
        printf("%#06x = %d\n", arr[i], arr[i]);
    }

    // memcpy
    memcpy(arr, &src, sizeof(arr));

    for (i = 0; i < 4; ++i) {
        printf("%#06x = %d\n", arr[i], arr[i]);
    }
    return 0;
}

Hope that can help.