Avertissement du compilateur (niveau 3) C4996
'fonction' a été déclaré déconseillé aussi 'std::<nom de fonction>' : appel de fonction avec des paramètres qui peuvent être non sécurisés - Cet appel s'appuie sur l'appelant pour vérifier que les valeurs passées sont correctes.Pour désactiver cet avertissement, utilisez -D_SCL_SECURE_NO_WARNINGS.Consultez la documentation relative à l'utilisation des « itérateurs vérifiés » Visual C++
Cet avertissement/cette erreur possède plusieurs significations possibles.
C4996 peut se produire, car le compilateur a rencontré une fonction qui était marquée avec deprecated. La fonction ne sera peut-être plus prise en charge dans une future version. Vous pouvez désactiver cet avertissement avec le pragma warning (exemple ci-dessous).
Certaines fonctions CRT et de la bibliothèque C++ standard ont été déconseillées en faveur de nouvelles fonctions, plus sécurisées. Pour plus d'informations sur la fonction à utiliser à la place, consultez la documentation relative à la fonction déconseillée dans le message d'erreur. Pour désactiver les avertissements relatifs aux fonctions CRT déconseillées, définissez _CRT_SECURE_NO_WARNINGS. Pour plus d'informations sur les fonctions déconseillées, consultez Fonctionnalités de sécurité dans le CRT et Bibliothèques sécurisées : bibliothèque standard C++.
Vous obtiendrez l'avertissement C4996 si vous utilisez des membres des fichiers d'en-tête <hash_map> et <hash_set> dans l'espace de noms std. Pour plus d'informations, consultez The stdext Namespace.
L'erreur C4996 peut également se produire si vous utilisez des fonctions MFC ou ATL qui ont été déconseillées pour des raisons de sécurité. Pour supprimer ces avertissements, consultez _AFX_SECURE_NO_WARNINGS et _ATL_SECURE_NO_WARNINGS.
L'erreur C4996 peut également se produire lorsque vous utilisez la bibliothèque de marshaling. Dans ce cas, C4996 est une erreur, plutôt qu'un avertissement. Elle intervient si vous utilisez marshal_as pour effectuer une conversion entre deux types de données qui requièrent une classe de marshal_context. Vous recevez également cette erreur lorsque la bibliothèque de marshaling ne prend pas de conversion en charge. Pour plus d'informations sur la bibliothèque de marshaling, consultez Présentation du marshaling en C++.
Dans le premier exemple, C4996 est généré pour la ligne dans laquelle la fonction est déclarée et pour la ligne dans laquelle la fonction est utilisée.
Exemple
L'exemple suivant génère le message C4996.
// C4996.cpp
// compile with: /W3
// C4996 warning expected
#include <stdio.h>
// #pragma warning(disable : 4996)
void func1(void) {
printf_s("\nIn func1");
}
__declspec(deprecated) void func1(int) {
printf_s("\nIn func2");
}
int main() {
func1();
func1(1);
}
Le message C4996 peut également s'afficher si vous n'utilisez pas d'itérateur vérifié lors de la compilation quand _ITERATOR_DEBUG_LEVEL est défini (défini à 1 par défaut pour les builds en mode débogage). Pour plus d'informations, consultez Itérateurs vérifiés.
L'exemple de code STL suivant génère le message C4996.
// C4996_b.cpp
// compile with: /EHsc /W3 /c
#define _ITERATOR_DEBUG_LEVEL 1
#include <algorithm>
#include <iterator>
using namespace std;
using namespace stdext;
int main() {
int a[] = { 1, 2, 3 };
int b[] = { 10, 11, 12 };
copy(a, a + 3, b + 1); // C4996
// try the following line instead
// copy(a, a + 3, b);
copy(a, a + 3, checked_array_iterator<int *>(b, 3)); // OK
}
L'exemple de code STL suivant génère le message C4996 sous forme d'avertissement. Les commentaires sont inline.
#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
template <typename C> void print(const string& s, const C& c) {
cout << s;
for (const auto& e : c) {
cout << e << " ";
}
cout << endl;
}
int main()
{
vector<int> v(16);
iota(v.begin(), v.end(), 0);
print("v: ", v);
// OK: vector::iterator is checked in debug mode
// (i.e. an overrun will trigger a debug assertion)
vector<int> v2(16);
transform(v.begin(), v.end(), v2.begin(), [](int n) { return n * 2; });
print("v2: ", v2);
// OK: back_insert_iterator is marked as checked in debug mode
// (i.e. an overrun is impossible)
vector<int> v3;
transform(v.begin(), v.end(), back_inserter(v3), [](int n) { return n * 3; });
print("v3: ", v3);
// OK: array::iterator is checked in debug mode
// (i.e. an overrun will trigger a debug assertion)
array<int, 16> a4;
transform(v.begin(), v.end(), a4.begin(), [](int n) { return n * 4; });
print("a4: ", a4);
// OK: Raw arrays are checked in debug mode
// (i.e. an overrun will trigger a debug assertion)
// NOTE: This applies only when raw arrays are given to STL algorithms!
int a5[16];
transform(v.begin(), v.end(), a5, [](int n) { return n * 5; });
print("a5: ", a5);
// WARNING C4996: Pointers cannot be checked in debug mode
// (i.e. an overrun will trigger undefined behavior)
int a6[16];
int * p6 = a6;
transform(v.begin(), v.end(), p6, [](int n) { return n * 6; });
print("a6: ", a6);
// OK: stdext::checked_array_iterator is checked in debug mode
// (i.e. an overrun will trigger a debug assertion)
int a7[16];
int * p7 = a7;
transform(v.begin(), v.end(), stdext::make_checked_array_iterator(p7, 16), [](int n) { return n * 7; });
print("a7: ", a7);
// WARNING SILENCED: stdext::unchecked_array_iterator is marked as checked in debug mode
// (i.e. it performs no checking, so an overrun will trigger undefined behavior)
int a8[16];
int * p8 = a8;
transform(v.begin(), v.end(), stdext::make_unchecked_array_iterator(p8), [](int n) { return n * 8; });
print("a8: ", a8);
}
L'exemple suivant génère le message C4996, car la bibliothèque de marshaling a besoin d'un contexte pour effectuer une conversion de System::String en const char *.
// C4996_Marshal.cpp
// compile with: /clr
// C4996 expected
#include <stdlib.h>
#include <string.h>
#include <msclr\marshal.h>
using namespace System;
using namespace msclr::interop;
int main() {
String^ message = gcnew String("Test String to Marshal");
const char* result;
result = marshal_as<const char*>( message );
return 0;
}