for example i have uint64_t value = 42 and i would like to split it into 8 uint8_t (8 bits), little endian. But I am unsure how to do the bit shifting. Help would be much appreciated.

CodePudding user response：

If you want the individual bytes of a 64-bit value in little endian, then you can do the following:

In order to get the 1^st byte, you simply apply the AND-bitmask 0xFF. This will mask out all bits except for the 8 least-significant bits.

In order to get the 2^nd byte, you shift right by 8 bits before applying the bit-mask.
In order to get the 3^rd byte, you shift right by 16 bits before applying the bit-mask.
In order to get the 4^th byte, you shift right by 24 bits before applying the bit-mask.
(...)
In order to get the 8^th byte, you shift right by 56 bits before applying the bit-mask.

Here is the code for the value 42 (which is the example in the question):

#include <stdio.h>
#include <stdint.h>

int main( void )
{
    uint64_t value = 42;
    uint8_t bytes[8];

    //extract the individual bytes
    for ( int i = 0; i < 8; i   )
    {
        bytes[i] = value >> (8 * i) & 0xFF;
    }

    //print the individual bytes
    for ( int i = 0; i < 8; i   )
    {
        printf( "- ", bytes[i] );
    }

    printf( "\n" );
}

Output:

42  0  0  0  0  0  0  0 

If you replace the value 42 with the value 74579834759 in the program above, then you get the following output:

135 247 77 93 17  0  0  0 

CodePudding user response：

The following code works on both little-endian and big-endian platforms. On both types of platforms, it will produce the bytes in little-endian byte order.

uint64_t input = 42;
uint8_t values[8];
values[0] = input >> 0 & 0xFF;
values[1] = input >> 8 & 0xFF;
values[2] = input >> 16 & 0xFF;
values[3] = input >> 24 & 0xFF;
values[4] = input >> 32 & 0xFF;
values[5] = input >> 40 & 0xFF;
values[6] = input >> 48 & 0xFF;
values[7] = input >> 56 & 0xFF;

Note that the & 0xFF is redundant here, but it makes the code more clear and it's useful if you want to do anything with the value other than immediately assign it to a uint8_t variable.

CodePudding user response：

Macro extracts bth byte form the u integer

#define EXTRACT(u,b) ((u) >> (8 * (b)))

int foo(uint64_t x)
{
    uint8_t b[8] = {
        EXTRACT(x,0),
        EXTRACT(x,1),
        EXTRACT(x,2),
        EXTRACT(x,3),
        EXTRACT(x,4),
        EXTRACT(x,5),
        EXTRACT(x,6),
        EXTRACT(x,7),
        };
}

If the platform is little endian you can also use memcpy

void foo(uint64_t x)
{
    uint8_t b[8];
    memcpy(b, &x, sizeof(b));
}