C6211C6211

avertissement C6211 : une fuite de mémoire <pointeur > en raison d’une exception.warning C6211: Leaking memory <pointer> due to an exception. Envisagez d’utiliser un bloc catch local pour nettoyer la mémoireConsider using a local catch block to clean up memory

Cet avertissement indique que la mémoire allouée n'est pas libérée lorsqu’une exception est levée.This warning indicates that allocated memory is not being freed when an exception is thrown. L’instruction à la fin du chemin pouvait lever une exception.The statement at the end of the path could throw an exception. L’analyseur vérifie cette condition uniquement lorsque le _Analysis_mode_(_Analysis_local_leak_checks_) annotation SAL est spécifiée.The analyzer checks for this condition only when the _Analysis_mode_(_Analysis_local_leak_checks_) SAL annotation is specified. Par défaut, cette annotation est spécifiée pour le code de (pilote) en mode noyau de Windows.By default, this annotation is specified for Windows kernel mode (driver) code. Pour plus d’informations sur les annotations SAL, consultez à l’aide d’Annotations SAL pour réduire les défauts du Code C/C++.For more information about SAL annotations, see Using SAL Annotations to Reduce C/C++ Code Defects.

ExempleExample

Le code suivant cela génère l’avertissement, car une exception peut être levée pendant l’allocation de deuxième et ainsi d’allocation de fuite de la première, ou une exception peut être levée quelque part dans le code qui est représenté par la «code ...» commentaire et consomme donc une fuite de ces deux allocations.The following code generates this warning because an exception could be thrown during the second allocation and thereby leak the first allocation, or an exception could be thrown somewhere in the code that's represented by the "code ..." comment and thereby leak both allocations.

// cl.exe /analyze /c /EHsc /nologo /W4 
#include <sal.h>

_Analysis_mode_(_Analysis_local_leak_checks_) 
void f( )
{
    char *p1 = new char[10];
    char *p2 = new char[10];

    // code ...

    delete[] p2;
    delete[] p1;
}

Pour utiliser les mêmes fonctions d’allocation et de corriger ce problème, ajoutez un gestionnaire d’exceptions :To use the same allocation functions and correct this problem, add an exception handler:

// cl.exe /analyze /c /EHsc /nologo /W4
#include <sal.h>
#include <new>
#include <iostream>
using namespace std;

_Analysis_mode_(_Analysis_local_leak_checks_) 

void f()
{
    char *p1 = nullptr; 
    char *p2 = nullptr;

    try
    {
        p1 = new char[10];
        p2 = new char[10];

        // code ...

        delete [] p2;
        delete [] p1;
    }
    catch (const bad_alloc& ba)
    {
        cout << ba.what() << endl;
        delete [] p2;
        delete [] p1;
    }
    // code ...
}

Pour éviter ces types de fuites potentiels, utilisez les mécanismes fournis par le C++ bibliothèque STL (Standard Template).To avoid these kinds of potential leaks altogether, use the mechanisms that are provided by the C++ Standard Template Library (STL). Ceux-ci incluent shared_ptr, unique_ptr, et vecteur.These include shared_ptr, unique_ptr, and vector. Pour plus d’informations, consultez pointeurs intelligents et bibliothèque Standard C++.For more information, see Smart Pointers and C++ Standard Library.

// 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( )
{
    // use 10-element vectors in place of char[10]
    vector<char> v1;
    vector<char> v2;

    for (int i=0; i<10; ++i) {
        v1.push_back('a');
        v2.push_back('b');
    }
    // code ...

    // use unique_ptr if you still want char[10]
    unique_ptr<char[]> a1(new char[10]);
    unique_ptr<char[]> a2(new char[10]);

    // code ...

    // No need for delete; vector and unique_ptr 
    // clean up when out of scope.
}

Voir aussiSee Also

Gestion d’exceptions C++C++ Exception Handling