Avviso C6014
Perdita di memoria 'pointer-name'.
Questo avviso indica che il puntatore specificato punta alla memoria allocata o a un'altra risorsa allocata che non è stata liberata.
Osservazioni:
L'analizzatore verifica questa condizione solo quando viene specificata l'annotazione _Analysis_mode_(_Analysis_local_leak_checks_) SAL. Per impostazione predefinita, questa annotazione viene specificata per il codice della modalità kernel di Windows (driver). Per altre informazioni sulle annotazioni SAL, vedere Uso delle annotazioni SAL per ridurre i difetti del codice C/C++.
Questo avviso viene segnalato sia per le perdite di memoria che per le perdite di risorse quando la risorsa viene in genere aliasata in un'altra posizione. La memoria viene aliasata quando un puntatore alla memoria esegue l'escape della funzione usando un'annotazione _Out_ di parametro, una variabile globale o un valore restituito. Questo avviso può essere segnalato all'uscita della funzione se l'argomento è annotato che è previsto il rilascio.
L'analisi del codice non riconoscerà l'implementazione effettiva di un allocatore di memoria (che include l'aritmetica degli indirizzi) e non riconoscerà che la memoria viene allocata (anche se verranno riconosciuti molti wrapper). In questo caso, l'analizzatore non riconosce che la memoria è stata allocata e genera questo avviso. Per eliminare il falso positivo, usare una #pragma warning(disable: 6014) direttiva sulla riga che precede la parentesi graffa { di apertura del corpo della funzione.
Nome dell'analisi del codice: MEMORY_LEAK
Esempi
Il codice seguente genera l'avviso C6014:
// cl.exe /analyze /EHsc /nologo /W4
#include <sal.h>
#include <stdlib.h>
#include <string.h>
_Analysis_mode_(_Analysis_local_leak_checks_)
#define ARRAYSIZE 10
const int TEST_DATA [ARRAYSIZE] = {10,20,30,40,50,60,70,80,90,100};
void f( )
{
int *p = (int *)malloc(sizeof(int)*ARRAYSIZE);
if (p) {
memcpy(p, TEST_DATA, sizeof(int)*ARRAYSIZE);
// code ...
}
}
int main( )
{
f();
}
Il codice seguente corregge l'avviso rilasciando la memoria:
// cl.exe /analyze /EHsc /nologo /W4
#include <sal.h>
#include <stdlib.h>
#include <string.h>
_Analysis_mode_(_Analysis_local_leak_checks_)
#define ARRAYSIZE 10
const int TEST_DATA [ARRAYSIZE] = {10,20,30,40,50,60,70,80,90,100};
void f( )
{
int *p = (int *)malloc(sizeof(int)*ARRAYSIZE);
if (p) {
memcpy(p, TEST_DATA, sizeof(int)*ARRAYSIZE);
// code ...
free(p);
}
}
int main( )
{
f();
}
Per evitare completamente questi tipi di potenziali perdite, usare i meccanismi forniti dalla libreria standard C++ (STL). Sono inclusi shared_ptri contenitori , e , unique_ptrad esempio vector. Per altre informazioni, vedere Puntatori intelligenti e libreria standard C++.
// cl.exe /analyze /EHsc /nologo /W4
#include <sal.h>
#include <memory>
using namespace std;
_Analysis_mode_(_Analysis_local_leak_checks_)
const int ARRAYSIZE = 10;
const int TEST_DATA [ARRAYSIZE] = {10,20,30,40,50,60,70,80,90,100};
void f( )
{
unique_ptr<int[]> p(new int[ARRAYSIZE]);
std::copy(begin(TEST_DATA), end(TEST_DATA), p.get());
// code ...
// No need for free/delete; unique_ptr
// cleans up when out of scope.
}
int main( )
{
f();
}