Comment trouver des fuites de mémoire en C++ en utilisant Valgrind ou AddressSanitizer ?

Pour trouver les fuites de mémoire en C++, vous pouvez profiter de Valgrind et AddressSanitizer. Valgrind détecte dynamiquement les fuites, affichant l'adresse, la taille et la pile d'appels. AddressSanitizer est un plugin de compilateur Clang qui détecte les erreurs et les fuites de mémoire. Pour activer la vérification des fuites ASan, utilisez l'option --leak-check=full lors de la compilation, qui signalera les fuites après l'exécution du programme.

Comment trouver des fuites de mémoire en C++ à l'aide de Valgrind ou AddressSanitizer

Introduction
Les fuites de mémoire sont un problème courant dans des langages comme C++. Pour détecter et résoudre ces fuites, des outils comme Valgrind et AddressSanitizer peuvent être utilisés.

Trouver des fuites de mémoire avec Valgrind
Valgrind est un outil de débogage de mémoire dynamique qui peut détecter les fuites de mémoire. Pour utiliser Valgrind :

valgrind ./my_program

Valgrind exécutera le programme et signalera toute fuite de mémoire détectée. La sortie affichera l’adresse, la taille et la pile d’appels divulguées.

Exemple
L'exemple de code C++ suivant montre comment Valgrind détecte une fuite de mémoire :

int* ptr = new int[10];
// ...
// 忘记释放 ptr

L'exécution de ce code et l'utilisation de Valgrind produisent la sortie suivante :

==8445== LeakSanitizer: detected memory leaks
==8445== Direct leak of 40 bytes in 1 object(s) allocated from:
    #0 0x49f2c0 in default_new_allocator_000000157013e0000000 ::operator() () (_libunwind.dylib:0x103d8e000)
    #1 0x41626f in create_array () in /tmp/a.out:10
    #2 0x415b2d in main () in /tmp/a.out:15

SUMMARY:
==8445== LEAK SUMMARY:
==8445==    definitely lost: 40 bytes in 1 object(s)

La sortie montre que 40 octets ont été divulgués et se trouvent à l'adresse 0x49f2c0 distribuer.

Trouver des fuites de mémoire avec AddressSanitizer
AddressSanitizer (ASan) est un plugin de compilateur Clang qui peut détecter les erreurs de mémoire, y compris les fuites de mémoire. Pour utiliser ASan :

clang++ -fsanitize=address ...

ASan détectera les erreurs d'accès à la mémoire et générera un rapport de crash lorsqu'une erreur se produit. Pour vérifier les fuites de mémoire, exécutez le programme deux fois :

./my_program # 第一次运行
./my_program --leak-check=full # 第二次运行，启用泄漏检查

La deuxième exécution signalera toutes les fuites de mémoire détectées.

Exemple
L'exemple de code C++ suivant montre comment AddressSanitizer détecte les fuites de mémoire :

int* ptr = new int[10];
// ...
// 忘记释放 ptr

La compilation et l'exécution de ce code, avec ASan activé, produiront le résultat suivant :

==28847== ERROR: AddressSanitizer: detected memory leaks
    SUMMARY:
    ==28847== LeakSanitizer: 40 byte(s) leaked in 1 allocation(s).
    ==28847==
    0x7fdd1b000010  40 bytes in 1 block
      ==28847== LeakSanitizer:
      ==28847==  Direct leak of 40 bytes in 1 object(s) allocated from:
      ==28847==    #0 0x7fdd17a346c0 in __sanitizer::Allocator<std::__detail::__shared_count>::allocate(unsigned long) (_sanitizer.h:1195)
      ==28847==    #1 0x7fdd184d0f90 in void* std::__detail::__shared_count<unsigned int>::allocate() (_shared_count.h:128)
      ==28847==    #2 0x7fdd182de485 in void* std::__shared_ptr<int>::__clone() (_shared_ptr.h:256)
      ==28847==    #3 0x48b935 in create_array() (/tmp/a.out:10)
      ==28847==    #4 0x48b884 in main (/tmp/a.out:15)

La sortie montre que 40 octets ont été divulgués et à l'adresse Attribué à 0x7fdd1b000010.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!