到目前为止，我对这个问题得到的答案有两种完全相反的答案：“它是安全的”和“它是未定义的行为”。我决定完全重写这个问题，以便为我和任何可能通过谷歌到达这里的人获得一些更好的澄清答案。

另外，我删除了C标签，现在这个问题是 C++ 特定的

我正在制作一个 8 字节对齐的内存堆，将在我的虚拟机中使用。我能想到的最明显的方法是分配一个数组std::uint64_t.

std::unique_ptr<std::uint64_t[]> block(new std::uint64_t[100]);

我们假设sizeof(float) == 4 and sizeof(double) == 8。我想存储一个浮点数和一个双精度数block并打印该值。

float* pf = reinterpret_cast<float*>(&block[0]);
double* pd = reinterpret_cast<double*>(&block[1]);
*pf = 1.1;
*pd = 2.2;
std::cout << *pf << std::endl;
std::cout << *pd << std::endl;

我还想存储一个表示“hello”的 C 字符串。

char* pc = reinterpret_cast<char*>(&block[2]);
std::strcpy(pc, "hello\n");
std::cout << pc;

现在我想存储“Hello, world!”它超过 8 个字节，但我仍然可以使用 2 个连续的单元格。

char* pc2 = reinterpret_cast<char*>(&block[3]);
std::strcpy(pc2, "Hello, world\n");
std::cout << pc2;

对于整数，我不需要reinterpret_cast.

block[5] = 1;
std::cout << block[5] << std::endl;

我正在分配block作为一个数组std::uint64_t仅用于内存对齐的目的。我也不期望任何大于 8 字节的内容存储在其中。如果保证起始地址是 8 字节对齐，则块的类型可以是任何类型。

有些人已经回答说我所做的事情是完全安全的，但另一些人则说我肯定会调用未定义的行为。

我是否编写了正确的代码来实现我的意图？如果不是，合适的方法是什么？

全局分配函数

要分配任意（无类型）内存块，可以使用全局分配函数（第 3.7.4/2 节）；

void* operator new(std::size_t);
void* operator new[](std::size_t);

可用于执行此操作 (§3.7.4.1/2)。

§3.7.4.1/2

分配函数尝试分配请求的存储量。如果成功，它将返回存储块的起始地址，该存储块的长度（以字节为单位）应至少与请求的大小一样大。从分配函数返回时，分配的存储空间的内容没有任何限制。通过连续调用分配函数分配的存储的顺序、连续性和初始值是未指定的。返回的指针应适当对齐，以便它可以转换为具有基本对齐要求（3.11）的任何完整对象类型的指针，然后用于访问分配的存储中的对象或数组（直到存储被显式释放）调用相应的释放函数）。

3.11 是这样说的基本对齐要求;

§3.11/2

基本对齐由小于或等于所有上下文中实现支持的最大对齐的对齐表示，该对齐等于alignof(std::max_align_t).

只是为了确保分配函数的行为必须像这样；

§3.7.4/3

C++ 程序中定义的任何分配和/或释放函数（包括库中的默认版本）应符合 3.7.4.1 和 3.7.4.2 中指定的语义。

引述自C++ WD n4527 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4527.pdf.

假设 8 字节对齐小于平台的基本对齐（看起来确实如此，但这可以在目标平台上验证）static_assert(alignof(std::max_align_t) >= 8)) - 您可以使用全局::operator new来分配所需的内存。分配后，可以根据您的大小和对齐要求对内存进行分段和使用。

这里的另一种选择是 the std::aligned_storage http://en.cppreference.com/w/cpp/types/aligned_storage它能够为您提供符合任何要求的内存。

typename std::aligned_storage<sizeof(T), alignof(T)>::type buffer[100];

从问题中，我假设这里的大小和对齐方式T将会是8。

最终内存块的示例如下（包括基本 RAII）；

struct DataBlock {
    const std::size_t element_count;
    static constexpr std::size_t element_size = 8;
    void * data = nullptr;
    explicit DataBlock(size_t elements) : element_count(elements)
    {
        data = ::operator new(elements * element_size);
    }
    ~DataBlock()
    {
        ::operator delete(data);
    }
    DataBlock(DataBlock&) = delete; // no copy
    DataBlock& operator=(DataBlock&) = delete; // no assign
    // probably shouldn't move either
    DataBlock(DataBlock&&) = delete;
    DataBlock& operator=(DataBlock&&) = delete;

    template <class T>
    T* get_location(std::size_t index)
    {
        // https://stackoverflow.com/a/6449951/3747990
        // C++ WD n4527 3.9.2/4
        void* t = reinterpret_cast<void*>(reinterpret_cast<unsigned char*>(data) + index*element_size);
        // 5.2.9/13
        return static_cast<T*>(t);

        // C++ WD n4527 5.2.10/7 would allow this to be condensed
        //T* t = reinterpret_cast<T*>(reinterpret_cast<unsigned char*>(data) + index*element_size);
        //return t;
    }
};
// ....
DataBlock block(100);

我构建了更详细的示例DataBlock有合适的模板construct and get功能等，现场演示在这里 http://coliru.stacked-crooked.com/a/37af4796160ecd8c and 这里进行进一步的错误检查等。 http://coliru.stacked-crooked.com/a/8b7251effad9b667.

关于别名的注释

看起来原始代码中确实存在一些别名问题（严格来说）；您分配一种类型的内存并将其转换为另一种类型。

它可能会在您的目标平台上按您的预期工作，但您不能依赖它。我对此见过的最实际的评论是；

“未定义的行为会产生令人讨厌的结果，通常会做你认为应该做的事情，直到它不做为止” - hvd https://stackoverflow.com/questions/31204824/why-give-a-c-compiler-warning-when-returning-an-rvalue-reference#comment50412114_31204824.

您拥有的代码可能会起作用。我认为最好使用适当的全局分配函数，并确保在分配和使用所需内存时不存在未定义的行为。

别名仍然适用；一旦分配了内存，别名就适用于它的使用方式。一旦分配了任意内存块（如上面的全局分配函数）并且对象的生命周期开始（§3.8/1） - 别名规则适用。

关于什么std::allocator?

虽然std::allocator http://en.cppreference.com/w/cpp/memory/allocator适用于同质数据容器，您正在寻找的内容类似于异构分配，标准库中的实现（给定分配器概念 http://en.cppreference.com/w/cpp/concept/Allocator）提供了有关原始内存分配和所需对象的相应构造的一些指导。