三维数组中的 C/C++ DWORD 到 BYTE 和 BYTE 到 DWORD 转换

Question

I am struggling to understand if I am doing this the correct way and if this is the (only) best solution.

The project I am working on is using a Three-Dimensional Array to hold and use lots of data. One part of the "data" is DWORD type and I must have a safe conversion from/to DWORD/BYTE.

The BYTE (c style) array looks like this:

BYTE array_data[150][5][255] = 
{
    {
        { // bytes },
        { 0x74,0x21,0x54,0x00 }, // This is converted from DWORD like: 0x00542174
        { // bytes },
        { // bytes },
        { // bytes },
    },
};

The (only) way to convert from DWORD to BYTE (s) I found:

DWORD dword_data;
char byte_array[4];

*(DWORD*)byte_array = dword_data; // byte_array becomes {0x74, 0x21, 0x54, 0x00}

wchar_t temp[256];

wsprintfW(temp, L"{0x%02x,0x%02x,0x%02x,0x%02x}, // This is converted from DWORD like: 0x%.8X\n", (BYTE)byte_array[0], (BYTE)byte_array[1], (BYTE)byte_array[2], (BYTE)byte_array[3], (DWORD)dword_data);

From I understand DWORD is 4 BYTE so that's why the char max length is 4. (correct me if I`m wrong?)

Then to convert back to DWORD from BYTE (s):

//Convert an array of four bytes into a 32-bit integer.
DWORD getDwordFromBytes(BYTE* b)
{
    return (b[0]) | (b[1] << 8) | (b[2] << 16) | (b[3] << 24);
};

printf("dword_data: 0x%.8X\n", getDwordFromBytes(array_data[0][1]));

Which prints out fine: 0x00542174 .

So my question is, is all this correct and safe? Because I will have lots of data in the array and the DWORD/BYTE conversion for me is imperative, it must be accurate.

Please advise and correct me where I`m doing things wrong, I would very much appreciate it!

Answer 1

This code

DWORD dword_data;
char byte_array[4];
*(DWORD*)byte_array = dword_data;

is undefined behavior according to the C++ standard. Some compilers may allow it as an extension, but unless you want to be surprised when you change a compiler or command line options, don't use it.

The correct way is:

DWORD dword_data;
BYTE byte_array[sizeof(DWORD)];
memcpy(byte_array, &dword_data, sizeof(DWORD));

Don't worry about efficiency: this memcpy will be optimized out by any decent compiler.

In C++20 you'll be able to be more eloquent :

auto byte_array = std::bit_cast<std::array<BYTE, sizeof(DWORD)>>(dword_data);

The backwards conversion should also be done using memcpy to be endianness-independent: your getDwordFromBytes will fail to produce the original dword_data on a big-endian machine.

Answer 2

DWORD is 32-bit unsigned integer.

typedef unsigned long DWORD, *PDWORD, *LPDWORD;

32-bit means 4 bytes, because each byte is 8 bit. And 4*8=32

https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-dtyp/262627d8-3418-4627-9218-4ffe110850b2

The problem will happen when you send your byte array to some code that expects to see those bytes in reversed order (different endianness). You would then need to reverse it.

DWORD is windows specific typedef, and all windows are little-endian, so I think it's safe to use this code as is, if you process data on the same machine.