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.
Notes
L’analyseur case activée pour 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
Exemple
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.
}
Voir aussi
calloc
malloc
free
operator new
delete
(opérateur)
shared_ptr
unique_ptr
Pointeurs intelligents
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour