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 deleteincompatible :

// 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 freede 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 mallocfree/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_ptret 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