Avertissement du compilateur (niveau 2, désactivé) C4412

'function' : la signature de fonction contient le type 'type' ; Les objets C++ ne sont pas sécurisés pour passer entre du code pur et du code mixte ou natif.

Notes

L’option /clr:pure du compilateur est déconseillée dans Visual Studio 2015 et non prise en charge à partir de Visual Studio 2017. Si vous avez du code qui doit être pur CLR, nous vous recommandons de le porter vers C#.

Le compilateur a détecté une situation potentiellement dangereuse qui pourrait entraîner une erreur d’exécution : un appel est effectué à partir du code compilé avec /clr:pure une fonction importée via dllimport, et la signature de la fonction contient un type non sécurisé. Un type est dangereux s’il contient une fonction membre ou a un membre de données qui est un type non sécurisé ou un indirection à un type non sécurisé.

Ce modèle est dangereux en raison de la différence entre les conventions d’appel par défaut entre le code pur et natif (ou le code natif mixte et géré). Lors de l’importation d’une fonction via dllimport dans le code compilé avec /clr:pure, assurez-vous que les déclarations de chaque type dans la signature soient identiques à celles de la signature dans le compiland qui exporte la fonction, en étant particulièrement attentif aux différences dans les conventions d’appel implicites.

Une fonction membre virtuelle est particulièrement sujette à des résultats inattendus. Toutefois, même une fonction non virtuelle doit être testée pour vous assurer que vous obtenez les résultats corrects. Cet avertissement peut être ignoré une fois que vous vérifiez que le résultat est correct.

C4412 est désactivé par défaut. Pour plus d’informations, consultez Avertissements du compilateur désactivés par défaut et dllexport, dllimport.

Pour résoudre cet avertissement, supprimez toutes les fonctions du type.

Exemples

L’exemple suivant génère l’erreur C4412 :

// 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
}

L’exemple suivant est un fichier d’en-tête qui déclare deux types. Le Unsafe type est dangereux, car il a une fonction membre :

// 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;
};

Cet exemple exporte des fonctions avec les types définis dans le fichier d’en-tête :

// 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; }

La convention d’appel par défaut dans une /clr:pure compilation est différente d’une compilation native. Lorsque C4412.h est inclus, la valeur par défaut de Test est __clrcall.

L’exemple suivant génère l’erreur C4412 et lève une exception au moment de l’exécution :

// 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
}