Avviso del compilatore (livello 3) C4996
'funzione': è stato dichiarato deprecato inoltre 'std::<nome funzione>': chiamata di funzione con parametri che potrebbero non essere sicuri. Questa chiamata dipende dal chiamante per verificare la correttezza dei valori.Per disabilitare questo avviso, utilizzare -D_SCL_SECURE_NO_WARNINGS.Vedere la documentazione relativa all'utilizzo degli "iteratori verificati" di Visual C++
Questo avviso/errore ha diversi possibili significati.
C4996 potrebbe verificarsi perché il compilatore ha rilevato una funzione contrassegnata come deprecata. È possibile che tale funzione non sia più supportata in una versione futura. Disattivare l'avviso con il pragma warning, come illustrato nell'esempio seguente.
Alcune funzioni CRT e della libreria C++ standard sono state deprecate in favore di nuove funzioni più sicure. Per ulteriori informazioni sulla funzione alternativa da utilizzare, vedere la documentazione relativa alla funzione deprecata nel messaggio di errore. Per disabilitare gli avvisi di deprecazione di CRT, definire _CRT_SECURE_NO_WARNINGS. Per ulteriori informazioni sulle funzioni deprecate, vedere Funzionalità di sicurezza in CRT e Librerie protette: libreria standard C++.
Verrà visualizzato C4996 se si utilizzano membri dei file di intestazione <hash_map> e <hash_set> nello spazio dei nomi std. Per ulteriori informazioni, vedere lo spazio dei nomi stdext.
L'avviso C4996 può verificarsi anche se si utilizzano le funzioni MFC o ATL considerate deprecate per motivi di sicurezza. Per eliminare questi avvisi, vedere _AFX_SECURE_NO_WARNINGS e _ATL_SECURE_NO_WARNINGS.
L'avviso C4996 può verificarsi anche quando si utilizza la libreria di marshalling. In questo caso C4996 rappresenta un errore e non un avviso. Si verificherà questo errore quando si utilizza marshal_as per convertire tra due tipi di dati che richiedono un Classe marshal_context. Si riceverà anche questo errore quando la libreria del marshalling non supporta una conversione. Per ulteriori informazioni sulla libreria del marshalling, vedere Panoramica del marshaling in C++.
Nel primo esempio l'avviso C4996 viene generato per la riga su cui è dichiarata la funzione e per la riga su cui è utilizzata.
Esempio
Nell'esempio seguente viene generato l'avviso 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);
}
L'avviso C4996 può verificarsi anche se non si utilizza un iteratore verificato quando si esegue la compilazione con _ITERATOR_DEBUG_LEVEL definito (impostato su 1 per impostazione predefinita per le compilazioni in modalità di debug). Per ulteriori informazioni, vedere Iteratori verificati.
Nell'esempio di codice STL seguente viene generato l'avviso 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
}
Nell'esempio di codice STL seguente viene generato l'avviso C4996 come avviso. I commenti sono 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);
}
Nell'esempio seguente viene generato l'avviso C4996 perché la libreria di marshalling richiede un contesto per eseguire la conversione da System::String a 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;
}