Question

I am using a library that has a function that takes an array of structs. That struct and function has the following layout:

struct TwoInt32s
{
  int32_t a;
  int32_t b;
};

void write(struct TwoInt32s *buffer, int len);

My initial tests suggest that an array of such structs has the same memory layout as an array of int32_t so I can do something like this:

int32_t *buffer = malloc(2 * len * sizeof(int32_t));
/* fill in the buffer */
write((struct TwoInt32s*)buffer, len);

However I’m wondering if this is universally true or not. Using an array of int32_t greatly simplifies my code.

EDIT: I forgot the sizeof

From what I read, C guarantees a few things about struct padding:

1. members will NOT be reordered
2. padding will only be added between members with different alignments or at the end of the struct
3. a pointer to a struct points to the same memory location as a pointer to its first member
4. each member is aligned in a manner appropriate for its type
5. there may be unnamed holes in the struct as necessary to achieve alignment

From this I can extrapolate that a and b have no padding between them. However it’s possible that the struct will have padding at the end. I doubt this since it’s word-aligned on both 32 and 64 bit systems. Does anyone have additional information on this?

Answer 1

The implementation is free to pad structs – there may be unused bytes in between a and b. It is guaranteed that the first member isn’t offset from the beginning of the struct though.

Typically you manage such layout with a compiler-specific pragma, e.g:

#pragma pack(push)
#pragma pack(1)
struct TwoInt32s
{
  int32_t a;
  int32_t b;
};
#pragma pack(pop)