Fordító figyelmeztetés (2. szint, kikapcsolva) C4412

"függvény": a függvény aláírása típust tartalmaz; A C++ objektumok nem biztonságosak a tiszta kód és a vegyes vagy natív kódok között.

Megjegyzések

A /clr:pure fordító beállítás elavult a Visual Studio 2015-ben, és a Visual Studio 2017-től kezdve nem támogatott. Ha rendelkezik olyan kóddal, amelyet tiszta CLR-nek kell lennie, javasoljuk, hogy a C#-ba portozza.

A fordító olyan potenciálisan nem biztonságos helyzetet észlelt, amely futásidejű hibát okozhat: a hívás egy /clr:pure-val lefordított kódból történik egy dllimport-en keresztül importált függvényre, és a függvény szignatúrája nem biztonságos típust tartalmaz. A típus nem biztonságos, ha tagfüggvényt tartalmaz, vagy olyan adattagot tartalmaz, amely nem biztonságos típus, vagy egy nem biztonságos típus közvetett eleme.

Ez a minta nem biztonságos a tiszta és natív kód (vagy vegyes natív és felügyelt) alapértelmezett hívási konvenciók közötti különbség miatt. Ha egy függvényt dllimport a következő kóddal /clr:pureösszeállított kódba importál, győződjön meg arról, hogy az aláírás minden egyes típusának deklarációja megegyezik a függvényt exportáló compilandban lévő aláírással (különösen ügyelve az implicit hívási konvenciók közötti különbségekre).

A virtuális tagfüggvény különösen hajlamos váratlan eredményekre. Azonban még egy nemvirtual függvényt is tesztelni kell, hogy a megfelelő eredményeket kapja. Ezt a figyelmeztetést figyelmen kívül hagyhatja, ha meggyőződött arról, hogy az eredmény helyes.

A C4412 alapértelmezés szerint ki van kapcsolva. További információért lásd: Az alapértelmezés szerint kikapcsolt fordítói figyelmeztetések és dllexport, dllimport.

A figyelmeztetés feloldásához távolítsa el az összes függvényt a típusból.

Példák

Az alábbi példa C4412-t hoz létre:

// compile with: /c /W2 /clr:pure
#pragma warning (default : 4412)

struct Unsafe {
   virtual void __cdecl Test();
};

struct Safe {
   int i;
};

__declspec(dllimport) Unsafe * __cdecl func();
__declspec(dllimport) Safe * __cdecl func2();

int main() {
   Unsafe *pUnsafe = func();   // C4412
   // pUnsafe->Test();

   Safe *pSafe = func2();   // OK
}

Az alábbi példa egy fejlécfájl, amely két típust deklarál. A Unsafe típus nem biztonságos, mert tagfüggvénye van:

// C4412.h
struct Unsafe {
   // will be __clrcall if #included in pure compilation
   // defaults to __cdecl in native or mixed mode compilation
   virtual void Test(int * pi);

   // try the following line instead
   // virtual void __cdecl Test(int * pi);
};

struct Safe {
   int i;
};

Ez a példa a fejlécfájlban definiált típusokkal exportálja a függvényeket:

// C4412_2.cpp
// compile with: /LD
#include "C4412.h"

void Unsafe::Test(int * pi) {
   *pi++;
}

__declspec(dllexport) Unsafe * __cdecl func() { return new Unsafe; }
__declspec(dllexport) Safe * __cdecl func2() { return new Safe; }

A fordítási folyamat alapértelmezett /clr:pure hívási konvenciója eltér a natív fordítástól. Ha C4412.h szerepel, Test alapértelmezés szerint __clrcall-ra áll be.

Az alábbi példa c4412-t hoz létre, és futásidőben kivételt okoz:

// C4412_3.cpp
// compile with: /W2 /clr:pure /c /link C4412_2.lib
#pragma warning (default : 4412)
#include "C4412.h"

__declspec(dllimport) Unsafe * __cdecl func();
__declspec(dllimport) Safe * __cdecl func2();

int main() {
   int n = 7;
   Unsafe *pUnsafe = func();   // C4412
   pUnsafe->Test(&n);

   Safe *pSafe = func2();   // OK
}