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
_Alignof, whose syntax parallels that of
_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,
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
You can explicitly specify an alignment requirement for a particular
variable or structure field by adding
(alignment) to the declaration, where alignment is a
power of 2 or a type name. For instance:
char _Alignas (8) x;
char _Alignas (double) x;
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));