Trouver les fuites de mémoire dans une application C++ avec Visual Studio

Question

Sous Linux, j'ai utilisé valgrind pour vérifier s'il y a des fuites de mémoire dans une application. Quel est l'équivalent sous Windows ? Peut-on le faire avec Visual Studio 2010 ?

Answer 1

Visual Studio 2019 dispose d'un outil d'analyse de la mémoire décent, il peut être utilisé de manière interactive lors du débogage ou par programmation (sans débogage), je montre un exemple minimal dans les deux cas dans ce qui suit.

L'idée principale est de prendre un instantané du tas au début et à la fin du processus, puis de comparer les états de la mémoire pour détecter d'éventuelles fuites de mémoire.

De manière interactive

Créez les éléments suivants main.cpp (dans une nouvelle application console) :

#include <string.h>
int main()
{
 int a = 1;
 char* s = new char[17];
 strcpy_s(s,17,"stackoverflow_pb");
 char* ss = new char[14];
 strcpy_s(ss, 14,"stackoverflow");
 delete[] ss;
 return 0;
}

Ensuite :

1. Mettez un point d'arrêt sur la première ligne "int a..."
2. Cliquez sur Debug > Windows > Show Diagnostic Tools ; et choisissez l'utilisation de la mémoire.
3. Ensuite, déboguez le code ( F5 ), lorsque le point d'arrêt est atteint, cliquez sur Take snapshot dans la barre d'outils du résumé de l'utilisation de la mémoire.
4. Allez à la dernière ligne "return 0..". ( step over ( F10 ) plusieurs fois) et prenez un autre cliché.
5. Cliquez sur la flèche rouge dans le deuxième instantané (dans l'onglet utilisation de la mémoire).
6. cela ouvrira un nouvel onglet "snapshot" qui vous permettra de comparer ce snapshot avec le premier (ou un autre) et de détecter les fuites de mémoire. Dans cet exemple, il y a une fuite de mémoire pour la variable s (stackoverflow_pb). Vous pouvez le trouver en double cliquant sur l'objet "char[]".

Les étapes clés de la procédure ci-dessus sont présentées dans l'image suivante :

Par programmation

Remplacez le code par le suivant :

#include <iostream>

#include "windows.h"
#define _CRTDBG_MAP_ALLOC //to get more details
#include <stdlib.h>  
#include <crtdbg.h>   //for malloc and free
int main()
{
    _CrtMemState sOld;
    _CrtMemState sNew;
    _CrtMemState sDiff;
    _CrtMemCheckpoint(&sOld); //take a snapchot
    char* s = new char[17];
    strcpy_s(s, 17, "stackoverflow_pb");
    char* ss = new char[14];
    strcpy_s(ss, 14, "stackoverflow");
    delete[] ss;
    _CrtMemCheckpoint(&sNew); //take a snapchot 
    if (_CrtMemDifference(&sDiff, &sOld, &sNew)) // if there is a difference
    {
        OutputDebugString(L"-----------_CrtMemDumpStatistics ---------");
        _CrtMemDumpStatistics(&sDiff);
        OutputDebugString(L"-----------_CrtMemDumpAllObjectsSince ---------");
        _CrtMemDumpAllObjectsSince(&sOld);
        OutputDebugString(L"-----------_CrtDumpMemoryLeaks ---------");
        _CrtDumpMemoryLeaks();
    }
    return 0;
}

Il fait la même chose mais par code, donc vous pouvez l'intégrer dans un système de construction automatique, les fonctions _CrtMemCheckpoint prendre les clichés et _CrtMemDifference compare les états de mémoire de l'instantané et renvoie vrai s'ils sont différents.

Puisque c'est le cas, il entre dans le bloc conditionnel et imprime les détails sur les fuites via plusieurs fonctions (voir _CrtMemDumpStatistics , _CrtMemDumpAllObjectsSince y _CrtDumpMemoryLeaks - ce dernier ne nécessite pas d'instantanés).

Pour voir la sortie, mettez un point d'arrêt dans la dernière ligne "return 0", tapez F5 et regardez la console de débogage. Voici la sortie :

---

Pour obtenir plus d'informations, consultez les liens suivants :

• Analyse interactive : Mesurer l'utilisation de la mémoire dans Visual Studio
• via la programmation : Trouver les fuites de mémoire avec la bibliothèque CRT y Débogage CRT Fichiers Heap (pour la corruption du tas également)

Answer 2

Et si Détecteur visuel de fuites ? Ce n'est pas inbuild, mais je pense que c'est le plus populaire.

Answer 3

Dr. Memory est un outil de surveillance de la mémoire capable d'identifier les erreurs de programmation liées à la mémoire, telles que les accès à la mémoire non initialisée, les accès à la mémoire non adressable (y compris en dehors des unités de tas allouées et les débordements et débordements de tas), les accès à la mémoire libérée, les doubles libérations, les fuites de mémoire et (sous Windows) les fuites de traitement, les erreurs d'utilisation de l'API GDI et les accès aux emplacements de stockage locaux non réservés des threads.

Dr. Memory fonctionne sur des binaires d'application non modifiés fonctionnant sous Windows, Linux, Mac ou Android sur du matériel IA-32, AMD64 et ARM de base.

Dr. Memory est construit sur le DynamoRIO plate-forme d'outils d'instrumentation dynamique.

Answer 4

Validateur de mémoire C++ trouve les fuites de mémoire et de traitement dans les programmes Windows natifs construits avec Visual Studio, Delphi et d'autres compilateurs. Rapide et capable de gérer de grandes charges de travail (certains utilisateurs suivent plusieurs milliards d'allocations et de désallocations en une seule exécution).

Divulgation : Je suis le concepteur de C++ Memory Validator. Nous l'avons construit parce que les autres outils ne pouvaient pas gérer la charge de travail lorsque nous travaillions avec SolidWorks R&D Ltd.

Answer 5

Visual Studio 2015 et les versions ultérieures disposent d'un outil de diagnostic des fuites de mémoire natif, consultez cette page pour plus de détails : https://dzone.com/articles/native-memory-leak-diagnostics .