Embed multiple ints in byte array - c++

Question

I am using this code:
int number; //=smth
unsigned char sendBuffer[255];
sendBuffer[0] = number & 0xFF;
sendBuffer[1] = (number >> 8) & 0xFF;
sendBuffer[2] = (number >> 16) & 0xFF;
sendBuffer[3] = (number >> 24) & 0xFF;
to put number in byte array sendBuffer.
My question is:
Say I want to embed now two numbers in the byte array, shall I proceed like this?
sendBuffer[0] = number & 0xFF;
sendBuffer[1] = (number >> 8) & 0xFF;
sendBuffer[2] = (number >> 16) & 0xFF;
sendBuffer[3] = (number >> 24) & 0xFF;
sendBuffer[4] = number2 & 0xFF;
sendBuffer[5] = (number2 >> 8) & 0xFF;
sendBuffer[6] = (number2 >> 16) & 0xFF;
sendBuffer[7] = (number2 >> 24) & 0xFF;
Will this work even if number is of size say 8 or 6 bytes?
(I am saying this because on some platforms the int maybe 4 bytes or 6 right?
So I was thinking if the above code also works when number is 6 bytes?
Further thing to note is that even if it is 6 bytes, but I only
store 4 byte integer inside it, will above code work?).
This buffer I usually store on some memory of a card and I don't have problems reading it back (e.g., endiannes etc. issues, the byte array when reading seems to come in the order I saved).
Finally, how to reconstruct the integer from the byte array sendBuffer?

Answer 1

1) Yes, proceed like that. No, it only works for 4 bytes.
There is a easier, better way to do this, although it can cause endianness issues if the buffer is sent from one computer to another which uses a different architecture. Assuming you know the type of number, overlay another array on top of sendBuffer.
unsigned char sendBuffer[255];
number_type *sendBufferNum = (number_type*) sendBuffer;
sendBufferNum[0] = number;
sendBufferNum[1] = number2;
Reading a number can be done the same way.
unsigned char receiveBuffer[255];
//read values into receiveBuffer
number_type *receiverBufferNum = (number_type*) receiveBuffer;
number_type number = recieveBuffer[0];
number_type number2 = receiveBuffer[1];

Answer 2

This only works for 32bit (4 bytes) integer. You have to write a 64bit (8 bytes) version if you are going to support large int.
You can reverse the process using bitwise OR.
#define BigEndianGetUInt32(ptr) ( ((uint32)((uint8*)(ptr))[0]) << 24 | \
((uint32)((uint8*)(ptr))[1]) << 16 | \
((uint32)((uint8*)(ptr))[2]) << 8 | \
(uint32)((uint8*)(ptr))[3]) )
number = BigEndianGetUInt32(sendBuffer);
number1 = BigEndianGetUInt32(sendBuffer+4);
As a side note, if you're serializing data just for the same device, you could have memcpy'ed number to sendBuffer.
memcpy(sendBuffer, &number, sizeof(number));
memcpy(sendBuffer+sizeof(number), &number1, sizeof(number1));

Answer 3

Will this work even if number is of size say 8 or 6 bytes?
It works but obviously you need to add more lines to save all the bytes in the value. That's a lot of manual work which is not very extensible. Use a programmatic approach instead
auto num = number;
for (size_t i = 0; i < sizeof(number); i++, num >>= CHAR_BIT)
sendBuffer[i] = number & 0xFF;
But why do that when you already have memcpy()? This way you need only 1 line, and even better, it can be extended to multiple values easily
memcpy(&sendBuffer[0], number1, sizeof number1);
memcpy(&sendBuffer[sizeof(number1)], number2, sizeof number2);
Finally, how to reconstruct the integer from the byte array sendBuffer?
Easy. Just shift the bytes back
number = (sendBuffer[3] << 24) | (sendBuffer[2] << 16) | (sendBuffer[1] << 8) | sendBuffer[0];
number2 = (sendBuffer[7] << 24) | (sendBuffer[6] << 16) | (sendBuffer[5] << 8) | sendBuffer[4];
Again, avoid tedious work like that and use a for loop
number = 0;
for (size_t i = 0; i < sizeof(number); i++)
number = (number << 8) | sendBuffer[i];
But memcpy also works and is highly recommended
memcpy(&number, &sendBuffer[numberIndex], sizeof number);