对齐堆栈上的数据 (C++)

Question

这个问题是特定于 MSVC 编译器（特别是 2008 年），但我也对非编译器特定的答案感兴趣。

我正在尝试根据某些任意类型的对齐方式来确定如何对齐堆栈上的字符缓冲区。理想情况下，代码如下：

__declspec( align( __alignof(MyType) ) ) char buffer[16*sizeof(MyType)];

不幸的是，这不起作用

错误 C2059：语法错误： '__builtin_alignof'

编译器只是不喜欢嵌套语句。

我唯一的另一个想法是这样做：

char buffer[16*sizeof(MyType)+__alignof(MyType)-1];
char * alignedBuffer = (char*)((((unsigned long)buffer) + __alignof(MyType)-1)&~(__alignof(MyType)-1));

有人知道更好的方法吗？似乎 declspec 的东西应该可以工作，我只是语法错误还是什么？

感谢阅读:)

Answer 1

你确定MyType 是一个有效的整数幂吗？

__declspec( align( # ) ) declarator

# 是对齐值。有效条目是 2 的整数幂 1 到 8192（字节），例如 2、4、8、 16、32 或 64. declarator 是数据 您声明为对齐。

-align (C++)

Answer 2

如果您想在堆栈上声明对齐数据，则无需执行任何额外的“修改”。编译器会处理这个问题。

如果之后你希望它是一个 char 数组，只需将其转换为 char*

试试下面的测试例子来确认：

#include <stdio.h>

struct UnalignedX {
    int x;
};

__declspec(align(128)) struct AlignedX {
    int x;
};

int main() {
    UnalignedX arr[5];
    AlignedX aarr[5];
    printf("UnalignedX: %x %x\n",arr,arr+1);
    printf("AlignedX: %x %x\n",aarr,aarr+1);
    char *final=(char*)aarr; //this becomes the char array that you asked for
    return 0;
};

在我的电脑上我得到了输出：

UnalignedX: 14fe68 14fe6c
AlignedX: 14fb80 14fc00

在堆上分配数据时必须小心对齐（通过malloc 或new）

__declspec( align( N )) 期望 N 是 文字。它必须是数字，而不是函数调用。

Answer 3

更新

查看罗伯特·奈特的答案！使用 C++11 但比这更干净...

---

原答案

这个讨厌的黑客怎么样：

namespace priv {

#define PRIVATE_STATICMEM(_A_) \
    template <size_t size> \
    struct StaticMem<size,_A_> { \
      __declspec(align(_A_)) char data[size]; \
      void *operator new(size_t parSize) { \
        return _aligned_malloc(parSize,_A_); \
      } \
      void operator delete(void *ptr) { \
        return _aligned_free(ptr); \
      } \
    };

    template <size_t size, size_t align> struct StaticMem {};
    template <size_t size> struct StaticMem<size,1> {char data[size];};

    PRIVATE_STATICMEM(2)
    PRIVATE_STATICMEM(4)
    PRIVATE_STATICMEM(8)
    PRIVATE_STATICMEM(16)
    PRIVATE_STATICMEM(32)
    PRIVATE_STATICMEM(64)
    PRIVATE_STATICMEM(128)
    PRIVATE_STATICMEM(256)
    PRIVATE_STATICMEM(512)
    PRIVATE_STATICMEM(1024)
    PRIVATE_STATICMEM(2048)
    PRIVATE_STATICMEM(4096)
    PRIVATE_STATICMEM(8192)

}

template <typename T, size_t size> struct StaticMem : public priv::StaticMem<sizeof(T)*size,__alignof(T)> {
    T *unhack() {return (T*)this;}
    T &unhack(size_t idx) {return *(T*)(data+idx*sizeof(T));}
    const T &unhack() const {return *(const T*)this;}
    const T &unhack(size_t idx) const {return *(const T*)(data+idx*sizeof(T));}
    StaticMem() {}
    StaticMem(const T &init) {unhack()=init;}
};

看起来很吓人，但你只需要一次（最好在一些隐藏良好的头文件中:)）。然后你可以通过以下方式使用它：

StaticMem<T,N> array; //allocate an uninitialized array of size N for type T
array.data //this is a raw char array
array.unhack() //this is a reference to first T object in the array
array.unhack(5) //reference to 5th T object in the array

StaticMem<T,N> array; 可以出现在代码中，但也可以作为某个更大类的成员（这就是我使用此 hack 的方式），并且在堆上分配时也应该正确运行。

错误修复：

示例的第 6 行：char data[_A_] 更正为 char data[size]

Answer 4

alloca() 怎么样？ （或者，更具体地说，对于 MSVC2008，_malloca()）？

在堆栈上分配内存。这是 _alloca 的一个版本，具有 CRT 中的安全增强中所述的安全增强。

对齐行为在编译器之间没有标准化，但是对于这个......

_malloca 例程返回一个指向已分配空间的 void 指针，该指针保证为存储任何类型的对象而适当对齐。

Answer 5

遇到了同样的问题。 您可以混合一个宏（oh恐怖），以安全的方式结合align 和__alignof：

// `align` und `__alignof` cannot be combined - hence this workaround where you also have to specify the alignment manually (but checked)
#define ALIGN_FOR_TYPE( TypeName, TypeAlignment )                           \
    const size_t ALIGN_FOR_TYPE_alignOf##TypeName = __alignof(TypeName);    \
    BOOST_STATIC_ASSERT(ALIGN_FOR_TYPE_alignOf##TypeName == TypeAlignment); \
    __declspec( align( TypeAlignment ) )                                    \
/**/

ALIGN_FOR_TYPE(MyStructType, 4) char StructBuffer[sizeof(MyStructType)];

Answer 6

您可以同时使用std::aligned_storage 和std::alignment_of 作为替代方案。

#include <type_traits>

template <class T, int N>
struct AlignedStorage
{
    typename std::aligned_storage<sizeof(T) * N, std::alignment_of<T>::value>::type data;
};

AlignedStorage<int, 16> myValue;

MSVC 2008 及更高版本支持此功能。如果您需要移植到其他非 C++11 编译器，可以使用 std::tr1::aligned_storage 和 std::tr1::alignment_of 以及 <tr1/type_traits> 标头。

在上面的代码中，AlignedStorage<T>::data 将是一个 POD 类型（MSVC 和 GCC 中的一个 char[] 数组），适合 T 和大小 T*N 对齐。