C++ casting a struct to std::vector<char> memory alignment

Question

I'm trying to cast a struct into a char vector. I wanna send my struct casted in std::vector throw a UDP socket and cast it back on the other side. Here is my struct whith the PACK attribute.

#define PACK( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop) )
PACK(struct Inputs
{
    uint8_t structureHeader;
    int16_t x;
    int16_t y;
    Key inputs[8];
});

Here is test code:

auto const ptr = reinterpret_cast<char*>(&in);
std::vector<char> buffer(ptr, ptr + sizeof in);
//send and receive via udp
Inputs* my_struct = reinterpret_cast<Inputs*>(&buffer[0]);

The issue is: All works fine except my uint8_t or int8_t. I don't know why but whenever and wherever I put a 1Bytes value in the struct, when I cast it back the value is not readable (but the others are) I tried to put only 16bits values and it works just fine even with the maximum values so all bits are ok.

I think this is something with the alignment of the bytes in the memory but i can't figure out how to make it work.

Thank you.

Answer 1

I'm trying to cast a struct into a char vector.

You cannot cast an arbitrary object to a vector. You can cast your object to an array of char and then copy that array into a vector (which is actually what your code is doing).

auto const ptr = reinterpret_cast<char*>(&in);
std::vector<char> buffer(ptr, ptr + sizeof in);

That second line defines a new vector and initializes it by copying the bytes that represent your object into it. This is reasonable, but it's distinct from what you said you were trying to do.

I think this is something with the alignment of the bytes in the memory

This is good intuition. If you hadn't told the compiler to pack the struct, it would have inserted padding bytes to ensure each field starts at its natural alignment. The fact that the operation isn't reversible suggests that somehow the receiving end isn't packed exactly the same way. Are you sure the receiving program has exactly the same packing directive and struct layout?

On x86, you can get by with unaligned data, but you may pay a large performance cost whenever you access an unaligned member variable. With the packing set to one, and the first field being odd-sized, you've guaranteed that the next fields will be unaligned. I'd urge you to reconsider this. Design the struct so that all the fields fall at their natural alignment boundaries and that you don't need to adjust the packing. This may make your struct a little bigger, but it will avoid all the alignment and performance problems.

If you want to omit the padding bytes in your wire format, you'll have to copy the relevant fields byte by byte into the wire format and then copy them back out on the receiving end.

An aside regarding:

#define PACK( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop) )

Identifiers that begin with underscore and a capital letter or with two underscores are reserved for "the implementation," so you probably shouldn't use __Declaration__ as the macro's parameter name. ("The implementation" refers to the compiler, the standard library, and any other runtime bits the compiler requires.)

Answer 2

1

vector class has dynamically allocated memory and uses pointers inside. So you can't send the vector (but you can send the underlying array)

2

SFML has a great class for doing this called sf::packet. It's free, open source, and cross-platform.

I was recently working on a personal cross platform socket library for use in other personal projects and I eventually quit it for SFML. There's just TOO much to test, I was spending all my time testing to make sure stuff worked and not getting any work done on the actual projects I wanted to do.

3

memcpy is your best friend. It is designed to be portable, and you can use that to your advantage.

You can use it to debug. memcpy the thing you want to see into a char array and check that it matches what you expect.

4

To save yourself from having to do tons of robustness testing, limit yourself to only chars, 32-bit integers, and 64-bit doubles. You're using different compilers? struct packing is compiler and architecture dependent. If you have to use a packed struct, you need to guarantee that the packing is working as expected on all platforms you will be using, and that all platforms have the same endianness. Obviously, that's what you're having trouble with and I'm sorry I can't help you more with that. I would I would recommend regular serializing and would definitely avoid struct packing if I was trying to make portable sockets.

If you can make those guarantees that I mentioned, sending is really easy on LINUX.

// POSIX
void send(int fd, Inputs& input)
{
    int error = sendto(fd, &input, sizeof(input), ..., ..., ...);
    ...
}

winsock2 uses a char* instead of a void* :(

void send(int fd, Inputs& input)
{
    char buf[sizeof(input)];
    memcpy(buf, &input, sizeof(input));
    int error = sendto(fd, buf, sizeof(input), ..., ..., ...);
    ...
}