C++ alignas Keyword

The alignas keyword in C++ is used to specify the alignment requirements for a type or variable.

The alignas keyword was introduced in C++11. It allows you to control the memory alignment of data, ensuring compatibility with hardware or optimizing performance for certain use cases.

By default, C++ aligns variables based on their type, but alignas can override these defaults, ensuring a specific alignment value, such as aligning data on a cache-friendly boundary.

Syntax

</>
Copy
alignas(alignment_value) type variable_name;
alignas
The keyword used to specify alignment.
alignment_value
The alignment requirement in bytes. It must be a power of 2 and at least the default alignment for the type.
type
The data type of the variable.
variable_name
The name of the variable being declared.

Examples

Example 1: Specifying Alignment for a Variable

This example demonstrates how to use alignas to specify alignment for a variable.

</>
Copy
#include <iostream>
#include <type_traits>
using namespace std;

int main() {
    alignas(16) int alignedVar; // Aligned to 16 bytes

    cout << "Alignment of alignedVar: " << alignof(alignedVar) << " bytes" << endl;
    cout << "Address of alignedVar: " << &alignedVar << endl;
    return 0;
}

Output:

Alignment of alignedVar: 16 bytes
Address of alignedVar: 0x7ffd389118f0

The Address of alignedVar in the output may change from run to run.

Explanation:

  1. The alignas(16) specifier ensures that alignedVar is aligned to a 16-byte boundary.
  2. alignof is used to verify the alignment of the variable.
  3. The variable’s memory address will be divisible by 16, ensuring proper alignment.

Example 2: Using alignas with Structures

This example demonstrates how to apply alignas to structures to control their alignment.

</>
Copy
#include <iostream>
using namespace std;

struct alignas(32) AlignedStruct {
    int x;
    float y;
};

int main() {
    AlignedStruct obj;

    cout << "Size of AlignedStruct: " << sizeof(AlignedStruct) << " bytes" << endl;
    cout << "Alignment of AlignedStruct: " << alignof(AlignedStruct) << " bytes" << endl;

    return 0;
}

Output:

Size of AlignedStruct: 32 bytes
Alignment of AlignedStruct: 32 bytes

Explanation:

  1. The alignas(32) specifier ensures that instances of AlignedStruct are aligned to a 32-byte boundary.
  2. The sizeof function reflects the size of the structure, which may include padding to meet the alignment requirement.
  3. The alignment requirement is verified using alignof.

Example 3: Applying alignas to Arrays

This example demonstrates how to use alignas to align arrays to a specific boundary.

</>
Copy
#include <iostream>
using namespace std;

int main() {
    alignas(64) int largeArray[16]; // Align the array to a 64-byte boundary

    cout << "Alignment of largeArray: " << alignof(decltype(largeArray)) << " bytes" << endl;
    cout << "Address of largeArray: " << &largeArray << endl;

    return 0;
}

Output:

Alignment of largeArray: 4 bytes
Address of largeArray: 0x7ffe00acacc0

Explanation:

  1. The alignas(64) specifier ensures that largeArray is aligned to a 64-byte boundary.
  2. This alignment is particularly useful for optimizing performance in applications like SIMD (Single Instruction, Multiple Data) processing.
  3. The alignment of the array is verified using alignof, and its memory address confirms the alignment requirement.

Key Points about alignas Keyword

  1. The alignas keyword allows you to specify memory alignment requirements for variables, structures, and arrays.
  2. The alignment value must be a power of 2 and at least the default alignment of the type.
  3. Using alignas can improve performance for applications requiring specific memory alignments, such as SIMD operations or hardware-level programming.
  4. It is important to ensure that the alignment value is compatible with the target hardware to avoid undefined behavior.