C2956-os fordítási hiba

A szokásos "függvény" felszabadítási függvény helyfoglalási felszabadítási függvényként lenne választva.

Megjegyzések

Az elhelyezett új kifejezéshez talált felszabadítási függvény megegyezik a szokásos felszabadítási függvények valamelyikével. Egy implicit fordító által generált felszabadítás vagy egy explicit delete (vagy delete[]) nem megfelelő felszabadítási függvényt használna.

A C2956 hiba azt jelzi, hogy egy elhelyezési új kifejezést (egy new olyan kifejezést) használt, amely paramétereket használ, és memóriavesztést vagy futásidejű összeomlást okozhat. Ez általában azt jelenti, hogy az eredményül kapott érték általában nem törölhető. Ez azt jelentheti, hogy a kód explicit delete (vagy delete[]) kifejezése vagy az implicit felszabadítás, amikor egy konstruktor kivételt dob, rosszul hívhatja meg a operator delete-t, vagy helytelen paraméterekkel adhatja meg.

** A C++ szabvány meghatározza a szokásos felszabadítási függvényeket mint a operator delete vagy operator delete[] túlterheléseit, amelyek további paramétereket vesznek igénybe a std::size_t típusú (C++14 vagy újabb), a std::align_val_t (C++17 vagy újabb) és a std::destroying_delete_t (C++20 vagy újabb) esetén. Új elhelyezési kifejezés használata esetén a fordító olyan egyező operator delete függvényt keres, amely ugyanazokat a paramétereket használja (az első után). Ha talál egyet, és a szignatúrája megegyezik egy szokásos memóriadeallokáló függvénnyel, a fordító a C2956-os hibát jelenti.

A probléma megoldásának módja részben a szándékától függ. A C++11-ben például definiálhat egy túlterhelést operator new , amely egy extra size_t paramétert vesz igénybe az osztályban, hogy értéket adjon át az osztónak. A C++14-ben ugyanez a kód most hibát okoz:

#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

Ha az a szándéka, hogy egy objektum számára túl igazított memória követelményeit állítsa be, az igazítást közvetlenül a típusnál adhatja meg a használatával alignas. További információ: alignasIgazítás.

Ha a szándéka, hogy megadja a verem által lefoglalt natív típus vagy tömb túláltalánosított memóriáját, csomagolja be egy struct vagy class jelzővel ellátott objektumba, amely a alignas specifikálóval rendelkezik. Ezután a normál new és delete kifejezések lefoglalhatják és felszabadíthatják az Ön által kívánt memóriaigazítással rendelkező példányokat.

Example

Ebben a példában az new-expression elhelyezési szintaxist használja egy típus std::align_val_targumentummal. Mivel azonban a T típus nem ad meg igazítási követelményt, a T*-on lévő delete-expression nem fog meghívni egy illeszkedő túl igazított felszabadítási függvényt. Ehelyett a fordító meghívná a szokásos felszabadítási függvényt void operator delete(void* ptr) noexcept, amely nem tudja kezelni a túl igazított memóriafoglalást. Ahelyett, hogy összeomlást vagy memóriavesztést okozna, a fordító hibajelentést tesz közzé az elhelyezés newilyen használata esetén:

#include <new>
struct T {};

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

A probléma megoldásához alkalmazzon egy kijelölőt alignas a következőre 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)
}