Question

I’m coding a network layer protocol and it is required to find a size of packed a structure defined in C. Since compilers may add extra padding bytes which makes sizeof function useless in my case. I looked up Google and find that we could use ___attribute(packed)___ something like this to prevent compiler from adding extra padding bytes. But I believe this is not portable approach, my code needs to support both windows and linux environment.

Currently, I’ve defined a macro to map packed sizes of every structure defined in my code. Consider code below:

typedef struct {
...
} a_t;

typedef struct {
...
} b_t;

#define SIZE_a_t 8;
#define SIZE_b_t 10;

#define SIZEOF(XX) SIZE_##XX;

and then in main function, I can use above macro definition as below:-

int size = SIZEOF(a_t);

This approach does work, but I believe it may not be best approach. Any suggestions or ideas on how to efficiently solve this problem in C?

Example

Consider the C structure below:-

typedef struct {
   uint8_t  a;
   uint16_t b;
} e_t;

Under Linux, sizeof function return 4 bytes instead of 3 bytes. To prevent this I’m currently doing this:-

typedef struct {
   uint8_t  a;
   uint16_t b;
} e_t;

#define SIZE_e_t 3
#define SIZEOF(XX) SIZE_##e_t

Now, when I call SIZEOF(e_t) in my functin, it should return 3 not 4.

Answer 1

sizeof is the portable way to find the size of a struct, or of any other C data type.

The problem you’re facing is how to ensure that your struct has the size and layout that you need.

#pragma pack or __attribute__((packed)) may well do the job for you. It’s not 100% portable (there’s no mention of packing in the C standard), but it may be portable enough for your current purposes, but consider whether your code might need to be ported to some other platform in the future. It’s also potentially unsafe; see this question and this answer.

The only 100% portable approach is to use arrays of unsigned char and keep track of which fields occupy which ranges of bytes. This is a lot more cumbersome, of course.