如何正确调用 aligned new/delete？

Question

如何调用带对齐的 new 运算符？

auto foo = new(std::align_val_t(32)) Foo; //?

然后，如何正确删除它？

delete(std::align_val_t(32), foo); //?

如果这是使用这些重载的正确形式，为什么 valgring 抱怨不匹配的 free()/delete/delete[]？

Answer 1

存在非常基本的原则 - 内存释放例程总是必须匹配分配例程。如果我们使用不匹配的分配和释放 - 运行时间行为可以是任何：都可以是随机的，或者在运行时间崩溃，或者内存泄漏，或者堆损坏。

如果我们使用 operator new 的对齐版本分配内存

void* operator new  ( std::size_t count, std::align_val_t al);

我们必须使用相应的对齐版本的operator delete

void operator delete  ( void* ptr, std::align_val_t al );

在这里调用void operator delete ( void* ptr );总是会导致运行-时间错误。简单测试一下

    std::align_val_t al = (std::align_val_t)256;
    if (void* pv = operator new(8, al))
    {
        operator delete(pv, al);
        //operator delete(pv); this line crash, or silently corrupt heap
    }

为什么 operator delete 的对齐和不对齐版本总是不兼容？让我们想想 - 怎么可能在一些值内存上分配 align ？我们最初总是分配一些内存块。对于要使用的 return align 指针 - 我们需要将分配的内存指针调整为多重对齐。行。这可以通过分配比请求更多的内存并调整指针来实现。但现在问题 - 这个街区有多自由？一般来说，用户得到的指针不指向分配内存的开头——如何从这个用户指针跳回到分配块的开头？没有其他信息，这是不可能的。我们需要在用户 returned 指针之前存储指向实际分配内存的指针。可能这在对齐 new 和 delete 使用 _aligned_malloc and _aligned_free

的代码典型实现中会更加明显

void* operator new(size_t size, std::align_val_t al)
{
    return _aligned_malloc(size, static_cast<size_t>(al));
}

void operator delete  (void * p, std::align_val_t al)
{
    _aligned_free(p);
}

未对齐时 new 和 delete 使用 malloc 和 free

void* operator new(size_t size)
{
    return malloc(size);
}

void operator delete  (void * p)
{
    free(p);
}

现在让我们寻找 _aligned_malloc and _aligned_free

的内部实现

void* __cdecl _aligned_malloc(size_t size, size_t alignment)
{
    if (!alignment || ((alignment - 1) & alignment))
    {
        // alignment is not a power of 2 or is zero
        return 0;
    }

    union {
        void* pv;
        void** ppv;
        uintptr_t up;
    };

    if (void* buf = malloc(size + sizeof(void*) + --alignment))
    {
        pv = buf;
        up = (up + sizeof(void*) + alignment) & ~alignment;
        ppv[-1] = buf;

        return pv;
    }

    return 0;
}

void __cdecl _aligned_free(void * pv)
{
    if (pv)
    {
        free(((void**)pv)[-1]);
    }
}

一般来说 _aligned_malloc 分配 size + sizeof(void*) + alignment - 1 而不是调用者 size 请求。调整分配的指针以适应对齐方式，并且 store 最初分配的内存是在指针 returned 之前分配给调用者的。

和 _aligned_free(pv) 调用的不是 free(pv) 而是 free(((void**)pv)[-1]); - 因为 总是另一个 指针。因为 _aligned_free(pv) 的这种效果总是另一个比较 free(pv)。并且 operator delete(pv, al); 始终与 operator delete(pv); 不兼容，如果说 delete [] 通常与 delete 具有相同的效果，但对齐与不对齐总是运行时间不同。

Answer 2

下面的语法是唯一对我有用的创建和销毁过度对齐数组的语法，使用 clang-cl 13 on Windows 10 x64:

int* arr = new (std::align_val_t(64)) int[555];
::operator delete[] (arr, std::align_val_t(64));

对于相同的新操作，下面的删除表达式将无法编译（“无法删除 'std::align_val_t' 类型的表达式）：

delete[] (arr, std::align_val_t(64));

下面的删除表达式将编译，但会抛出运行时错误（“ 检测到严重错误 c0000374"):

delete[](std::align_val_t(64), blocks);

如何正确调用 aligned new/delete？

How to invoke aligned new/delete properly?

c++

new-operator

delete-operator

c++17