Kompilatorfel C2956

Funktionen "function" för vanlig frigöring skulle väljas som placeringsfrigöringsfunktion.

Anmärkningar

Frigöringsfunktionen som hittades för det nya placeringsuttrycket matchar en av de vanliga frigöringsfunktionerna. Antingen en implicit kompilatorgenererad deallokering eller en explicit delete (eller delete[]) skulle använda fel deallokeringsfunktion.

Fel C2956 anger att du använde ett nytt placeringsuttryck (ett new uttryck som tar parametrar) på ett sätt som kan orsaka en minnesläcka eller körningskrasch. Det innebär vanligtvis att det resulterande värdet inte kan tas bort på ett typiskt sätt. Antingen ett explicit delete (eller delete[]) uttryck i din kod, eller den implicita frigörelsen när en konstruktor kastar ett undantag, kan anropa fel operator delete eller förse det med fel parametrar.

C++-standarden specificerar vanliga frigöringsfunktioner som överbelastningar av operator delete eller operator delete[] som tar extra parametrar av typen std::size_t (C++14 eller senare), std::align_val_t (C++17 eller senare) och std::destroying_delete_t (C++20 eller senare). När du använder ett nytt placeringsuttryck letar kompilatorn efter en matchande operator delete funktion som tar samma parametrar (efter den första). Om en hittas och dess signatur matchar en vanlig frigöringsfunktion rapporterar kompilatorn felet C2956.

Hur du löser problemet beror delvis på din avsikt. I C++11 kan du till exempel definiera en operator new överlagring som tar en extra size_t parameter i klassen för att skicka ett värde till allokeraren. I C++14 orsakar samma kod nu ett fel:

#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

Om avsikten är att ange överjusterat minne för ett objekt kan du i stället ange justeringen direkt på typen genom att använda alignas. Mer information om alignasfinns i Justering.

Om avsikten är att specificera överallokerat minne för en heapallokerad inbyggd typ eller en matris, omslut den i en struct eller class som har alignas-specifikatorn. Sedan kan normala new- och delete-uttryck allokera och frigöra instanser med önskad justering.

Example

I det här exemplet använder placeringssyntaxen new-expression med ett argument av typen std::align_val_t. Men eftersom typ T inte anger något krav på justering kommer inte en delete-expression på en T* att anropa en matchande funktion för överjusterad avallokering. I stället skulle kompilatorn anropa den vanliga frigöringsfunktionen void operator delete(void* ptr) noexcept, som inte hanterar en överalignerad allokering. I stället för att orsaka en krasch eller en minnesläcka rapporterar kompilatorn ett fel för den här användningen av placering new:

#include <new>
struct T {};

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

Lös problemet genom att tillämpa en alignas specificerare på 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)
}