Avertissement C6280
'variable-name' est alloué avec 'function-name-1', mais supprimé avec 'function-name-2'
Cet avertissement indique que la fonction appelante a alloué de manière incohérente de la mémoire à l’aide d’une fonction d’une famille et l’a libérée à l’aide d’une fonction d’une autre.
L’analyseur vérifie cette condition uniquement lorsque l’annotation _Analysis_mode_(_Analysis_local_leak_checks_)
SAL est spécifiée. Par défaut, cette annotation est spécifiée pour le code du mode noyau Windows (pilote). Pour plus d’informations sur les annotations SAL, consultez Utilisation des annotations SAL pour réduire les défauts de code C/C++.
Par exemple, cet avertissement est généré si la mémoire est allouée à l’aide malloc
, mais libérée à l’aide GlobalFree
ou delete
. Dans les cas spécifiques d’incompatibilités entre tableau new[]
et scalaire delete
, des avertissements plus précis sont signalés au lieu de celui-ci.
Nom de l’analyse du code : MEMORY_ALLOCATION_MISMATCH
L’exemple de code suivant génère cet avertissement. pInt
est alloué à l’aide calloc
, mais libéré à l’aide de la fonction delete
incompatible :
// C6280a_warning.cpp
// cl.exe /analyze /c /EHsc /nologo /W4
#include <sal.h>
#include <stdlib.h>
_Analysis_mode_(_Analysis_local_leak_checks_)
void f(int arraySize)
{
int *pInt = (int *)calloc(arraySize, sizeof (int));
// code ...
delete pInt;
}
Le code suivant évite cet avertissement en utilisant la fonction free
de désallocation, la correspondance à calloc
:
// C6280a_no_warning.cpp
// cl.exe /analyze /c /EHsc /nologo /W4
#include <sal.h>
#include <stdlib.h>
_Analysis_mode_(_Analysis_local_leak_checks_)
void f(int arraySize)
{
int *pInt = (int *)calloc(arraySize, sizeof (int));
// code ...
free(pInt);
}
Différentes définitions d’API peuvent utiliser différents segments de mémoire. Par exemple, GlobalAlloc
utilise le tas système et free
utilise le tas de processus. Ce problème est susceptible d’entraîner des altérations et des blocages de mémoire.
Ces incohérences s’appliquent aux mécanismes d’allocation de mémoire et malloc
free
/de mémoire.new
/delete
Pour éviter ces types d’incohérences potentielles, utilisez les mécanismes fournis par la bibliothèque standard C++ (STL). Ceux-ci incluent shared_ptr
, unique_ptr
et des conteneurs tels que vector
. Pour plus d’informations, consultez Les pointeurs intelligents et la bibliothèque standard C++.
Le code suivant évite entièrement ce problème à l’aide de unique_ptr
:
// C6280b_no_warning.cpp
// cl.exe /analyze /c /EHsc /nologo /W4
#include <sal.h>
#include <vector>
#include <memory>
using namespace std;
_Analysis_mode_(_Analysis_local_leak_checks_)
void f(int arraySize)
{
// use unique_ptr instead of calloc/malloc/new
unique_ptr<int[]> pInt(new int[arraySize]);
// code ...
// No need for free because unique_ptr
// cleans up when out of scope.
}
calloc
malloc
free
operator new
delete
(opérateur)
shared_ptr
unique_ptr
Pointeurs intelligents