> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Alignof The `alignof` operator is a compile-time unary operator that returns the alignment requirement of a specified type in bytes. It evaluates to a constant expression of type `std::size_t`, representing the number of bytes between successive memory addresses at which objects of the queried type can be allocated. ```cpp theme={"dark"} alignof(type-id) ``` ## Evaluation Rules and Mechanics The behavior of `alignof` depends strictly on the category of the `type-id` provided as its operand: * **Fundamental Types:** Returns the architecture-specific alignment boundary required by the hardware (e.g., typically `4` for `int` and `8` for `double` on 64-bit systems). * **Class/Struct Types:** Returns the strictest (largest) alignment requirement among all its base classes and non-static data members. The alignment requirements of these subobjects dictate where the compiler must insert padding, but padding itself consists of empty space and does not factor into the `alignof` evaluation. The alignment value can also be explicitly overridden using the `alignas` specifier. * **Array Types:** Returns the alignment requirement of the underlying element type, not the alignment or size of the entire array block. * **Reference Types:** Returns the alignment requirement of the referenced type. The reference itself does not have a distinct alignment queried by this operator. ## Type Constraints The `type-id` passed to `alignof` must be a **complete type**, an array type, or a reference type. Applying `alignof` to an incomplete type, a function type, or the `void` type is a constraint violation. This renders the program ill-formed and results in a standard compilation error, as the compiler cannot determine the alignment for these types. ## Syntax Visualization ```cpp theme={"dark"} #include #include struct Base { double d; // alignof(double) == 8 }; struct Derived : Base { char c; // alignof(char) == 1 int i; // alignof(int) == 4 }; struct alignas(32) OveralignedStruct { int i; }; int main() { // Evaluates to the architecture's default alignment for int constexpr std::size_t int_align = alignof(int); // Evaluates to 8, driven by the strictest requirement from the Base class constexpr std::size_t struct_align = alignof(Derived); // Evaluates to 32, driven by the alignas specifier constexpr std::size_t custom_align = alignof(OveralignedStruct); // Evaluates to alignof(int), ignoring the array bounds constexpr std::size_t array_align = alignof(int[100]); // Evaluates to alignof(double), ignoring the reference semantics constexpr std::size_t ref_align = alignof(double&); return 0; } ``` Because `alignof` resolves entirely during compilation, its result is guaranteed to be a core constant expression.

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More