How to get the size the trailing padding of a struct or class?

Question

sizeof can be used to get the size of a struct or class. offsetof can be used to get the byte offset of a field within a struct or class.

Similarly, is there a way to get the size of the trailing padding of a struct or class? I'm looking for a way that doesn't depend on the layout of the struct, e.g. requiring the last field to have a certain name.

For the background, I'm writing out a struct to disk but I don't want to write out the trailing padding, so the number of bytes I need to write is the sizeof minus the size of the trailing padding.

CLARIFICATION: The motivation for not writing the trailing padding is to save output bytes. I'm not trying to save the internal padding as I'm not sure about the performance impact of non-aligned access and I want the writing code to be low-maintenance such that it doesn't need to change if the struct definition changes.

Answer 1

The way a compiler can pad fields in a structure is not strictly defined in the standard, so it's a kind of free choice and implementation dependent. If a data aggregate have to be interchanged the only solution is to avoid any padding.
This is normally accomplished using a #pragma pack(1). This pragma instructs the compiler to pack all fields together on a 1 byte boundary. It will slow the access on some processors, but will make the structure compact and well defined on any system, and, of course, without any padding.

Answer 2

pragma pack or equivalent is the canonical way to do that. Apart from that I can only think of a macro, if the number of members is fixed or the maximum number is low, like

$ cat struct-macro.c && echo
#include<stdio.h>

using namespace std;

#define ASSEMBLE_STRUCT3(Sname, at, a, bt, b, ct, c) struct Sname {at a; bt b; ct c; }; \
       int Sname##_trailingbytes() { return sizeof(struct Sname) - offsetof(Sname, c) - sizeof(ct); }

ASSEMBLE_STRUCT3(S, int, i1, int, i2, char, c)

int main()
{
        printf("%d\n", S_trailingbytes());
}
$ g++ -Wall -o struct-macro struct-macro.c && ./struct-macro
3
$

I wonder if something fancy can be done with a variadic template class with in C++. But I can't quite see how the class/structure can be defined and the offset function/constant be provided without a macro again -- which would defeat the purpose.

Answer 3

This is a possiblity:

#define BYTES_AFTER(st, last) (sizeof (st) - offsetof(st, last) - sizeof ((st*)0)->last)

As is this (C99) approach:

#define BYTES_AFTER(st, last) (sizeof (st) - offsetof(st, last) - sizeof (st){0}.last)

Another way is just declaring your structs packed via some non-standard #pragma or similar. This would also take care of padding in the middle.

Neither of those two are pretty though. Sharing between different systems might not work because different alignment requirements. And using non-standard extensions is, well, non-standard.

Just do the serialization yourself. Maybe something like that:

unsigned char buf[64];
mempcpy(mempcpy(mempcpy(buf,
   &st.member_1, sizeof st.member_1),
   &st.member_2, sizeof st.member_2),
   &st.member_3, sizeof st.member_3);

mempcpy is a GNU extension, if it's not available, just define it yourself:

static inline void * mempcpy (void *dest, const void *src, size_t len) {
   return (char*)memcpy(dest, src, len) + len;
}

IMO, it makes code like that easier to read.

Answer 4

The padding could be anywhere inside the struct, except at the very beginning. There is no standard way to disable padding, although some flavour of #pragma pack is a common non-standard extension.

What you actually should do if you want a robust, portable solution, is to write a serialization/de-serialization routine for your struct.

Something like this:

typedef
{
  int x;
  int y;
  ...
} mytype_t;

void mytype_serialize (uint8_t* restrict dest, const mytype_t* restrict src)
{
  memcpy(dest, &src->x, sizeof(src->x)); dest += sizeof(src->x);
  memcpy(dest, &src->y, sizeof(src->y)); dest += sizeof(src->y);
  ...
}

And similarly for the other way around.

Please note that padding is there for a reason. If you get rid of it, you sacrifice execution speed in favour of memory size.

EDIT

The weird way to do it, just by skipping trailing padding:

size_t mytype_serialize (uint8_t* restrict dest, const mytype_t* restrict src)
{
  size_t size = offsetof(my_type_t, y); // assuming y is last object
  memcpy(dest, src, size); 
  memcpy(dest+size, &src->y, sizeof(src->y));
  size += sizeof(src->y);
  return size;
}

You need to know the size and do something meaningful with it, because otherwise you can't know the size of the stored data when you need to read it back.