Alignas in C++ 11

The alignas specifier was introduced in C++11 to provide custom memory alignment for variables and user-defined types such as classes and structures. Proper alignment can improve memory access efficiency and help optimize performance on modern hardware architectures.

• Can be applied to variables, classes, structs, unions, and enum declarations
• Helps optimize memory layout and CPU access performance

Syntax

alignas( alignment_value )

where, alignment_value is an integral constant expression that specifies the desired alignment in bytes.

Applicability of alignas

The alignas specifier can be applied to:

• Declarations or definitions of a class, struct, union, or enum
• Non-bit-field data members of a class or struct
• Variable declarations (except function parameters and exception parameters in catch blocks)

Note: The examples below use the alignof operator to determine the alignment requirement of a type. Familiarity with alignof will help in understanding the output.

#include <iostream>
using namespace std;

// struct is aligned to 16 bytes in memory.
struct alignas(16) Demo
{

    int var1l; // 4 bytes
    int var2; // 4 bytes
    short s; // 2 bytes
    // char aligned to 4 bytes in memory.
    alignas(4) char arr[5];
};

// driver code
int main()
{
    cout << alignof(Demo) << endl; // output: 16
    return 0;
}

16

Explanation

• The Demo structure is declared with alignas(16), so its objects are aligned on 16-byte boundaries.
• The array arr uses alignas(4), giving it a 4-byte alignment requirement.
• The compiler chooses the largest alignment requirement among the structure and its members.
• Therefore, alignof(Demo) returns 16.

Practice: Try to use sizeof(Demo) and compare it with alignof(Demo) and check the difference if any.

Real-Time Use Cases of alignas

The alignas specifier is commonly used in performance-critical applications where memory alignment affects efficiency.

• To reduce cache-line contention in multi-threaded programs
• To improve memory access performance and CPU efficiency
• To implement custom memory layouts for low-level systems programming