Erro do compilador C2956

a função de desalocação usual «função» seria escolhida como função de desalocação por posicionamento

Observações

A função de desalocação encontrada para a nova expressão de posicionamento corresponde a uma das funções de desalocação usuais. Uma desalocação implícita gerada pelo compilador ou uma explícita delete (ou delete[]) usaria a função de desalocação errada.

O erro C2956 indica que você usou uma nova expressão de posicionamento (uma new expressão que usa parâmetros) de uma forma que pode causar um vazamento de memória ou falha de tempo de execução. Isso geralmente significa que o valor resultante não pode ser excluído de uma maneira típica. Ou seja, uma expressão explícita delete (ou delete[]) no seu código, ou a desalocação implícita quando um construtor lança uma exceção, pode invocar o operator delete errado ou fornecer-lhe parâmetros errados.

O padrão C++ especifica funções usuais de desalocação como sobrecargas de operator delete ou operator delete[] que usam parâmetros extras do tipo std::size_t (C++14 ou posterior), std::align_val_t (C++17 ou posterior) e std::destroying_delete_t (C++20 ou posterior). Quando você usa uma nova expressão de posicionamento, o compilador procura uma função correspondente operator delete que usa os mesmos parâmetros (após a primeira). Se um for encontrado e a sua assinatura corresponder a uma função usual de desalocação, o compilador relata o erro C2956.

A maneira de resolver o problema depende em parte da sua intenção. Por exemplo, em C++11, você pode definir uma operator new sobrecarga que usa um parâmetro extra size_t em sua classe para passar um valor para o alocador. No C++14, o mesmo código agora causa um erro:

#include <new>
struct T {
    void* operator new(std::size_t, std::size_t); // Placement allocation function
    void operator delete(void*, std::size_t); // now considered a usual deallocation function
};

T* p = new (0) T;   // error: usual deallocation function would be chosen as placement deallocation function

Se sua intenção for especificar memória sobrealinhada para um objeto, você poderá especificar o alinhamento diretamente no tipo usando alignas. Para obter mais informações sobre alignaso, consulte Alinhamento.

Se a sua intenção for especificar memória superalinhada para um tipo nativo alocado no heap ou uma matriz, envolva-a em um struct ou class que tenha o especificador alignas. Em seguida, as expressões normais new e delete podem alocar e desalocar instâncias que têm o alinhamento pretendido.

Example

Neste exemplo, o new-expression usa sintaxe de posicionamento com um argumento do tipo std::align_val_t. No entanto, como o tipo T não especifica um requisito de alinhamento, um delete-expression em um T* não invocará uma função de desalocação sobrealinhada correspondente. Em vez disso, o compilador invocaria a função void operator delete(void* ptr) noexcept de desalocação usual, que não lida com uma alocação superalinhada. Em vez de causar uma falha ou um vazamento de memória, o compilador relata um erro para este uso de posicionamento new:

#include <new>
struct T {};

int main()
{
    T* p = new (std::align_val_t{64}) T; // C2956
    delete p; // ordinary, not over-aligned delete
}

Para resolver esse problema, aplique um alignas especificador a T:

#include <new>
struct alignas(64) T {};

int main()
{
    T* p = new T; // invokes ::operator new(std::size_t, std::align_val_t)
    delete p; // now invokes ::operator delete(void*, std::align_val_t)
}