Compilerfout C2956

de gewoonlijke deallocatie-functie 'functie' zou worden gekozen als plaatsingsfunctie voor deallocatie

Opmerkingen

De deallocatiefunctie die is gevonden voor de nieuwe plaatsingsexpressie komt overeen met een van de gebruikelijke deallocatiefuncties. Een impliciete door compiler gegenereerde deallocatie of een expliciete delete (of delete[]) gebruikt de verkeerde deallocatiefunctie.

Fout C2956 geeft aan dat u een nieuwe plaatsingsexpressie (een new expressie die parameters gebruikt) hebt gebruikt op een manier die een geheugenlek of runtimecrash kan veroorzaken. Dit betekent meestal dat de resulterende waarde niet op een typische manier kan worden verwijderd. Dat wil zeggen dat een expliciete delete (of delete[]) expressie in uw code, of de impliciete deallocatie wanneer een constructor een uitzondering genereert, het verkeerde operator delete kan aanroepen of deze met de verkeerde parameters kan leveren.

De C++-standaard specificeert gebruikelijke deallocatiefuncties als overbelastingen van operator delete of operator delete[] die extra parameters van het type std::size_t (C++14 of hoger), std::align_val_t (C++17 of hoger) en std::destroying_delete_t (C++20 of hoger) gebruiken. Wanneer u een nieuwe expressie voor plaatsing gebruikt, zoekt de compiler naar een overeenkomende operator delete functie die dezelfde parameters gebruikt (na de eerste). Als er een wordt gevonden en de handtekening overeenkomt met een gebruikelijke deallocatiefunctie, rapporteert de compiler fout C2956.

De manier om het probleem op te lossen, is deels afhankelijk van uw intentie. In C++11 kunt u bijvoorbeeld een operator new overbelasting definiëren die een extra size_t parameter in uw klasse nodig heeft om een waarde door te geven aan de allocator. In C++14 veroorzaakt dezelfde code nu een fout:

#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

Als uw bedoeling is om overgelijnd geheugen voor een object op te geven, kunt u in plaats daarvan de uitlijning rechtstreeks op het type opgeven met behulp van alignas. Zie alignas voor meer informatie.

Als uw bedoeling is om overgelijnd geheugen op te geven voor een systeemeigen heap-type of een matrix, verpakt u het in een struct of class met de alignas aanduiding. Vervolgens kunnen normale new expressies en delete instanties die de beoogde uitlijning hebben, worden toegewezen en vrijgegeven.

Example

In dit voorbeeld wordt de new-expression plaatsingssyntaxis gebruikt met een argument van het type std::align_val_t. Omdat het type T echter geen uitlijningseis opgeeft, zal een delete-expression op een T* geen overeenkomende over-uitgelijnde deallocatiefunctie aanroepen. In plaats daarvan roept de compiler de gebruikelijke deallocation-functie void operator delete(void* ptr) noexceptaan, die geen overgelijnde toewijzing afhandelt. In plaats van een crash of geheugenlek te veroorzaken, meldt de compiler een fout voor dit gebruik van plaatsing new:

#include <new>
struct T {};

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

U kunt dit probleem oplossen door een alignas aanduiding toe te passen op 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)
}