Are structs guaranteed to be aligned to sizeof(size_t) in C?

Question

I have the following struct:

struct data {
        char buffer[12];
        bool flag;
}

When testing the size of the data structure, I realized it was 16 bytes because of the boolean flag which added 3 bytes in padding. So I decided to do the following while using the last byte of the buffer as the flag:

struct data {
        char buffer[16];
}

This way my buffer is 3 bytes larger for free as it would have been lost in padding anyway.

However, I want this structure to be platform independent, so I looked on cppreference and found the following (emphasis mine):

Every complete object type has a property called alignment requirement, which is an integer value of type size_t representing the number of bytes between successive addresses at which objects of this type can be allocated.

Based off this, I wrote the following:

struct data {
        char buffer[12 + sizeof(size_t)];
}

It works on my device, but I am just wondering if this is guaranteed to properly align on all platforms and not waste any bytes?

Edit: I am aware that sizeof(size_t) may be 8 bytes, making my structure 20 bytes. However, if the alignment is by 8 bytes, then my structure would be 20 bytes regardless. This is why I wish to know how the structure is aligned.

Answer 1

Are structs guaranteed to be aligned to sizeof(size_t) in C?

No.

---

I suspect the following will meet OP's goal of getting access to the padding. Member order is important. Put smallest members last. char is always smallest.

struct data_ref {
  bool flag;
  char buffer[12];
};

#define PAD (sizeof(struct data_ref) - sizeof(char)*12 - sizeof(bool))

struct data {
  bool flag;
  char buffer[12 + PAD];
};

Answer 2

Are structs guaranteed to be aligned to sizeof(size_t) in C?

No. Why would they be?

Answer 3

The C standard does not dictate the alignment of fields within a struct. Section 6.7.2.1 p14 of the C standard states:

Each non-bit-field member of a structure or union object is aligned in an implementation-defined manner appropriate to its type.

So there's no guarantee that a given struct will be laid out the same way on two different compilations of the same source code, whether that be different compilers or the same compiler with different optimizations settings.

As a counterexample, given the following struct:

struct test1 {
    char s[13];
};

On my machine, sizeof(struct test1) evaluated to 13 and _Alignof(struct test1) evaluates to 1. In fact, I get the same result with your first definition of struct data, indicating that there's no padding.

So there is no guarantee that structs are aligned on a sizeof(size_t) boundary.

Regarding the quote you gave:

Every complete object type has a property called alignment requirement, which is an integer value of type size_t representing the number of bytes between successive addresses at which objects of this type can be allocated.

This states that all types have an alignment requirement, and that that value has a type of size_t, not that a type has to have an alignment of that sizeof(size_t).

That being said, there is a way that structs tend to be laid out, and you can typically reduce the size of the struct if you follow these conventions.

Generally speaking, the alignment requirement of a struct ends up being the largest alignment requirement of its fields, and the alignment requirement of an array is the same as that of its containing type. Also, a primitive type n bytes in size typically needs to be aligned on an n byte boundary. So when you have fields within a struct with different alignment requirements, padding will typically be inserted to ensure each field's alignment requirement is satisfied.

In the case of your structure, you have a char array whose element size is 1 and a bool whose size (on my machine at least) is also 1, so the struct as a whole has an alignment requirement of 1 and no padding is needed.

Making use of these properties, you can usually reduce the size of your structs. The Lost Art of Struct Packing goes into this in much more detail.

To reiterate however, the way fields in a struct are laid out is implementation defined according to the standard. So while you might be able to lay out your struct to minimize padding, there is still no guarantee that it will always be the same in all environments.

Answer 4

Are structs guaranteed to be aligned to sizeof(size_t) in C?

No.

You've misunderstood the use of size_t in the quoted paragraph. The alignment of a type is a value of type size_t. For example, the alignment of type char is (size_t)1, and a structure containing only a single char member might itself have an alignment of (size_t)1. (Or it might have a larger alignment.)

size_t is just the type used to represent an alignment value. The size or alignment of the type size_t has nothing to do with the size or alignment of a structure -- unless the structure happens to have a member of type size_t.

Answer 5

struct's required alignment is measured by the biggest alignment of any of it's members.

i.e., a struct with only char types will be aligned on a char alignment (single byte for the most part).

a struct that contains an int (and sometimes bool is implemented using an int) will be aligned on an int alignment as well as include any required padding for the int in the struct to be aligned.

The logic behind this alignment scheme is for struct arrays.

i.e.:

/* assuming int requires a 4 byte boundary alignment */
struct example_s {
  char bytes[2];
  /* char padding[2]; //  2 byte padding so `int` is aligned */
  int i;
};

struct example_s example_array[10];

This will promise that the example_array[2].i is properly aligned.