alignas与GCC aligned属性是否等价？内置类型对齐别名的标准实现

Great question! Let’s break down why your alignas attempt didn’t work, how it differs from GCC’s extension, and the standard-compliant way to get aligned built-in type aliases.

Why GCC’s __attribute__((aligned)) works for typedefs, but alignas doesn’t #

GCC’s __attribute__((aligned(N))) is a compiler extension that lets you attach alignment requirements directly to a typedef. When you write:

typedef int more_aligned_int __attribute__ ((aligned (8)));

this alias actually carries the 8-byte alignment requirement with it. That’s why declaring an array of this type (more_aligned_int ar[3];) throws an error: the element’s alignment requirement (8 bytes) is larger than the element’s size (4 bytes for a typical int), and contiguous array storage can’t satisfy that per-element alignment.

On the C++ side, alignas is a standard feature, but it has strict rules about where it can be applied. When you write:

using aligned_int = int alignas(8);

the compiler warns because alignas can’t modify the inherent alignment of a built-in type like int. The attribute gets ignored entirely, so aligned_int is just a plain int—which is why the array declaration doesn’t throw an error (but also doesn’t give you the alignment you wanted).

Core differences between aligned and alignas #

• Valid targets:
  • GCC’s aligned is flexible: it can attach to typedefs, variables, types, and even override a type’s inherent alignment (even if that means setting alignment larger than the type’s size).
  • alignas (standard C++) is restricted: it works for variable declarations, class/struct/enum definitions, and non-static class members. It cannot modify the alignment of built-in types, nor can it be used to "wrap" a built-in type in an alias with custom alignment.
• Array behavior:
  • When aligned is applied via typedef, the compiler enforces the alignment requirement for array elements—leading to an error if alignment > element size.
  • Misapplied alignas (like in your example) does nothing, so array declarations behave as if you were using the original built-in type.
• Portability:
  • __attribute__((aligned)) is a GCC/Clang extension—works in those compilers but isn’t standard C/C++.
  • alignas is part of C++11 and later, so it’s portable across all compliant compilers, but constrained by its usage rules.

Standard-compliant way to create aligned built-in type aliases #

You can’t modify the alignment of built-in types directly in standard C++, but you can wrap them in a struct that carries the alignment requirement:

// Simple wrapper for int with 8-byte alignment
struct alignas(8) AlignedInt {
    int value;
};

Or make it reusable with a template:

template<typename T, size_t Alignment>
struct AlignedWrapper {
    alignas(Alignment) T value;
};

// Use it for int with 8-byte alignment
using AlignedInt = AlignedWrapper<int, 8>;

This works because the struct’s size will be padded to meet the alignment requirement (so for a 4-byte int, the struct becomes 8 bytes). When you declare an array of AlignedInt, each element is 8 bytes, so contiguous storage can satisfy the 8-byte alignment requirement without issues.

If you want to use AlignedInt like a regular int (for assignments, operations, etc.), add implicit conversion operators:

struct alignas(8) AlignedInt {
    int value;
    // Allow implicit conversion to/from int
    operator int&() { return value; }
    operator const int&() const { return value; }
};

Now you can use AlignedInt just like you would a normal int, while getting the 8-byte alignment you need.

内容的提问来源于stack exchange，提问作者Lorah Attkins