## Appendix A Type Alignment ¶

Code for device drivers and other communication with low-level hardware sometimes needs to be concerned with the alignment of data objects in memory.

Each data type has a required alignment, always a power of 2, that says at which memory addresses an object of that type can validly start. A valid address for the type must be a multiple of its alignment. If a type’s alignment is 1, that means it can validly start at any address. If a type’s alignment is 2, that means it can only start at an even address. If a type’s alignment is 4, that means it can only start at an address that is a multiple of 4.

The alignment of a type (except `char`) can vary depending on the kind of computer in use. To refer to the alignment of a type in a C program, use `_Alignof`, whose syntax parallels that of `sizeof`. Like `sizeof`, `_Alignof` is a compile-time operation, and it doesn’t compute the value of the expression used as its argument.

Nominally, each integer and floating-point type has an alignment equal to the largest power of 2 that divides its size. Thus, `int` with size 4 has a nominal alignment of 4, and `long long int` with size 8 has a nominal alignment of 8.

However, each kind of computer generally has a maximum alignment, and no type needs more alignment than that. If the computer’s maximum alignment is 4 (which is common), then no type’s alignment is more than 4.

The size of any type is always a multiple of its alignment; that way, in an array whose elements have that type, all the elements are properly aligned if the first one is.

These rules apply to all real computers today, but some embedded controllers have odd exceptions. We don’t have references to cite for them.

Ordinary C code guarantees that every object of a given type is in fact aligned as that type requires.

If the operand of `_Alignof` is a structure field, the value is the alignment it requires. It may have a greater alignment by coincidence, due to the other fields, but `_Alignof` is not concerned about that. See Structures.

Older versions of GNU C used the keyword `__alignof__` for this, but now that the feature has been standardized, it is better to use the standard keyword `_Alignof`.

You can explicitly specify an alignment requirement for a particular variable or structure field by adding `_Alignas (alignment)` to the declaration, where alignment is a power of 2 or a type name. For instance:

    char _Alignas (8) x;

or

    char _Alignas (double) x;

specifies that `x` must start on an address that is a multiple of 8. However, if alignment exceeds the maximum alignment for the machine, that maximum is how much alignment `x` will get.

The older GNU C syntax for this feature looked like `__attribute__ ((__aligned__ (alignment)))` to the declaration, and was added after the variable. For instance:

    char x __attribute__ ((__aligned__ 8));

See Attributes in Declarations.