cstdalign

---

1. Aligning a Structure to a Specific Boundary

struct MyStruct {
    char c;
    int i;
};

alignas(32) MyStruct myStruct;  // Aligns MyStruct to a 32-byte boundary

2. Ensuring Proper Alignment for Multi-Threaded Access

struct SharedData {
    int count;
    std::mutex mtx;
};

__attribute__((aligned(64))) SharedData sharedData;  // Aligns SharedData to a 64-byte boundary for efficient multi-threaded access

3. Aligning Arrays for Vectorization

int data[16] __attribute__((aligned(16)));  // Aligns the array to a 16-byte boundary for vectorization optimizations

4. Optimizing Cache Performance

struct CacheLineAligned {
    char pad[64];  // Adds 64 bytes of padding to align the following data to a cache line boundary
    int data;
};

5. Aligning Pointers to Structures

struct MyStruct {
    int i;
    char c;
};

MyStruct* ptr = (MyStruct*)__aligned_alloc(32, sizeof(MyStruct));  // Aligns the pointer to a 32-byte boundary

6. Aligning Memory Allocated with malloc()

void* mem = aligned_alloc(64, 256);  // Allocates 256 bytes of memory aligned to a 64-byte boundary

7. Aligning Memory Allocated with new()

class MyClass {
    int i;
    char c;
};

MyClass* obj = new(__attribute__((aligned(32)))) MyClass();  // Aligns the new object to a 32-byte boundary

8. Aligning Return Values

struct MyStruct {
    int i;
    char c;
};

__attribute__((aligned(32))) MyStruct myFunction() {  // Ensures the return value is aligned to a 32-byte boundary
    return {1, 'a'};
}

9. Aligning Class Data Members

class MyClass {
    __attribute__((aligned(32))) int i;  // Aligns the class member i to a 32-byte boundary
    char c;
};

10. Aligning Union Members

union MyUnion {
    int i __attribute__((aligned(16)));  // Aligns the i member to a 16-byte boundary
    char c;
};

11. Aligning Arrays of Structures

struct MyStruct {
    int i;
    char c;
};

MyStruct data[10] __attribute__((aligned(16)));  // Aligns the array of MyStruct to a 16-byte boundary

12. Aligning Pointers to Functions

typedef void (*MyFuncPtrType)() __attribute__((aligned(64)));  // Aligns the function pointer to a 64-byte boundary

13. Aligning Structures in a Union

union MyUnion {
    struct {
        int i __attribute__((aligned(32)));  // Aligns the i member to a 32-byte boundary
        char c;
    };
    double d;
};

14. Aligning Base Class Subobjects

class BaseClass {
    int i;
};

class DerivedClass : public BaseClass {
    __attribute__((aligned(16))) int j;  // Aligns the j member to a 16-byte boundary in the derived class
};

15. Aligning Virtual Base Class Subobjects

class BaseClass {
    virtual int i;
};

class DerivedClass : public virtual BaseClass {
    __attribute__((aligned(32))) int j;  // Aligns the j member to a 32-byte boundary in the derived class
};

16. Aligning Non-POD Structures

struct MyStruct {
    int i;
    MyStruct* next __attribute__((aligned(16)));  // Aligns the next member to a 16-byte boundary
};

17. Aligning Bitfields

struct MyStruct {
    int i : 3;
    char c __attribute__((aligned(4)));  // Aligns the c member to a 4-byte boundary
    int j : 5;
};

18. Aligning Nested Structures

struct NestedStruct {
    int i;
};

struct MyStruct {
    NestedStruct nested __attribute__((aligned(16)));  // Aligns the nested structure to a 16-byte boundary
};

19. Aligning Structures with Explicit Layout

struct MyStruct {
    char c __attribute__((aligned(1)));
    short s __attribute__((aligned(2)));
    int i __attribute__((aligned(4)));
};

20. Aligning Anonymous Structures

struct {
    int i __attribute__((aligned(8)));
} data;  // Aligns the anonymous structure to an 8-byte boundary

21. Aligning Variadic Argument Lists

void myFunction(int n, ...) {
    va_list ap;
    va_start(ap, n);

    // Align each variadic argument to a 8-byte boundary
    int* arg = va_arg(ap, int*), arg2;
    __aligned(8) int arg3 = va_arg(ap, int);
    arg2 = va_arg(ap, int);

    va_end(ap);
}

22. Aligning Structures in C++11

struct __attribute__((aligned(16))) MyStruct {
    int i;
    char c;
};

23. Aligning Arrays in C++11

int data[16] __attribute__((aligned(16)));

24. Aligning Pointers in C++11

MyStruct* ptr __attribute__((aligned(32)));

25. Aligning Structures in C++17

struct alignas(32) MyStruct {
    int i;
    char c;
};

26. Aligning Arrays in C++17

int data[16] alignas(16);

27. Aligning Pointers in C++17

MyStruct* ptr alignas(32);

28. Using the std::align() Function

MyStruct* ptr = (MyStruct*)std::align(64, sizeof(MyStruct));  // Aligns the pointer to a 64-byte boundary

29. Using the std::aligned_storage Class

std::aligned_storage<sizeof(MyStruct), 64>::type storage;  // Creates 64 bytes of aligned storage for a MyStruct

30. Aligning Homogeneous Aggregates

int arr[10] __attribute__((aligned(16)));  // Aligns an array of ints to a 16-byte boundary

31. Aligning Heterogeneous Aggregates

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(16)));  // Aligns a heterogeneous aggregate to a 16-byte boundary

32. Aligning Structures with Virtual Functions

struct BaseClass {
    virtual void f();
};

struct DerivedClass : public BaseClass {
    int i __attribute__((aligned(32)));  // Aligns the i member to a 32-byte boundary in the derived class
};

33. Aligning Structures with Multiple Inheritance

struct BaseClass1 {
    int i;
};

struct BaseClass2 {
    int j;
};

struct DerivedClass : public BaseClass1, BaseClass2 {
    int k __attribute__((aligned(16)));  // Aligns the k member to a 16-byte boundary in the derived class
};

34. Aligning Structures with Diamond Inheritance

struct BaseClass {
    int i;
};

struct DerivedClass1 : public BaseClass {
    int j __attribute__((aligned(32)));  // Aligns the j member to a 32-byte boundary in the derived class
};

struct DerivedClass2 : public BaseClass {
    int k __attribute__((aligned(16)));  // Aligns the k member to a 16-byte boundary in the derived class
};

struct DiamondClass : public DerivedClass1, public DerivedClass2 {
    int l;
};

35. Aligning Unions with Heterogeneous Members

union MyUnion {
    int i __attribute__((aligned(32)));  // Aligns the i member to a 32-byte boundary
    double d;
};

36. Aligning Uninitialized Structures

struct MyStruct {
    int i;
    char c;
};

alignas(16) MyStruct uninitializedData;  // Declares an uninitialized MyStruct aligned to a 16-byte boundary

37. Aligning Dynamically Allocated Structures

MyStruct* ptr = (MyStruct*)aligned_alloc(32, sizeof(MyStruct));  // Allocates a MyStruct aligned to a 32-byte boundary

38. Aligning Structures in Shared Memory

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(32)));  // Aligns MyStruct to a 32-byte boundary for shared memory access

39. Aligning Structures in Embedded Systems

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(16)));  // Aligns MyStruct to a 16-byte boundary for efficient hardware access

40. Aligning Structures for Real-Time Systems

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(64)));  // Aligns MyStruct to a 64-byte boundary for real-time performance

41. Aligning Structures for Data Parallelism

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(32)));  // Aligns MyStruct to a 32-byte boundary for vectorization and multi-threading

42. Aligning Structures for Performance Optimization

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(16)));  // Aligns MyStruct to a 16-byte boundary for improved cache performance

43. Aligning Structures for Interoperability

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(32)));  // Aligns MyStruct to a 32-byte boundary for compatibility with other platforms

44. Aligning Structures for Cross-Compilation

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(16)));  // Aligns MyStruct to a 16-byte boundary for cross-compilation to different target architectures

45. Aligning Structures for Code Portability

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(32)));  // Aligns MyStruct to a 32-byte boundary for code portability to different platforms

46. Aligning Structures for Optimization

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(16)));  // Aligns MyStruct to a 16-byte boundary for optimal performance

47. Aligning Structures for Efficiency

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(32)));  // Aligns MyStruct to a 32-byte boundary for efficiency

48. Aligning Structures for Contiguity

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(16)));  // Aligns MyStruct to a 16-byte boundary for contiguity

49. Aligning Structures for Coherency

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(32)));  // Aligns MyStruct to a 32-byte boundary for coherency

50. Aligning Structures for Data Reuse

struct MyStruct {
    int i;
    char c;
} __attribute__((aligned(16)));  // Aligns MyStruct to a 16-byte boundary for data reuse