Valgrind relata fuga de memória quando atribuir um valor a uma string
-
19-09-2019 - |
Pergunta
Valgrind relata um vazamento de memória ao atribuir um valor a uma string.
Eu usei o seguinte código simples para testar um vazamento de memória relatado pelo Valgrind.
/******************************************
* FILE: t3.c
* Compiled using : g++ -g t3.c -o t3
*
* $ g++ -v
* Reading specs from /usr/lib/gcc/i686-pc-linux-gnu/3.4.6/specs
* Configured with: ./configure --prefix=/usr --infodir=/share/info --mandir=/share/man
* --enable-languages=c,c++ --with-system-zlib --program-suffix=-3.4 --enable-threads=posix
* Thread model: posix
* gcc version 3.4.6
******************************************/
#include <iostream>
#include <string>
using namespace std;
/**************************************************************
**************************************************************/
int main(int argc, char *argv[])
{
string test = "XXXXXXXXX";
cout << "this is a test " << test << endl;
exit(0);
}
eu compilar usando este comando:
$ g++ -g t3.c -o t3
E quando eu executar Valgrind ele relata um vazamento de memória quando eu tentar atribuir um valor a uma string. Estou usando este teste simples para investigar algum vazamento de memória no programa real, e parece que usando a corda pode causar algum tipo de problema.
Por 0x8048A6F: main (t3.c: 23) é a linha: test string = "XXXXXXXXX"; Alguém pode dar alguma dica sobre tal comportamento estranho?
[enzo@P0101222 C]$ valgrind --leak-check=full ./t3
==3910== Memcheck, a memory error detector.
==3910== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al.
==3910== Using LibVEX rev 1732, a library for dynamic binary translation.
==3910== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP.
==3910== Using valgrind-3.2.3, a dynamic binary instrumentation framework.
==3910== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al.
==3910== For more details, rerun with: -v
==3910==
this is a test XXXXXXXXX
==3910==
==3910== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 25 from 1)
==3910== malloc/free: in use at exit: 102 bytes in 3 blocks.
==3910== malloc/free: 4 allocs, 1 frees, 126 bytes allocated.
==3910== For counts of detected errors, rerun with: -v
==3910== searching for pointers to 3 not-freed blocks.
==3910== checked 194,136 bytes.
==3910==
==3910== 16 bytes in 1 blocks are definitely lost in loss record 1 of 3
==3910== at 0x4017846: malloc (m_replacemalloc/vg_replace_malloc.c:149)
==3910== by 0x4018E05: realloc (m_replacemalloc/vg_replace_malloc.c:306)
==3910== by 0x41B441A: argz_append (in /lib/libc-2.2.5.so)
==3910== by 0x41593B9: __newlocale (in /lib/libc-2.2.5.so)
==3910== by 0x40E010B: std::locale::facet::_S_create_c_locale(__locale_struct*&, char const*, __locale_struct*) (c++locale.cc:99)
==3910== by 0x407EF6F: std::locale::facet::_S_initialize_once() (../../.././libstdc++-v3/src/locale.cc:172)
==3910== by 0x407EFB4: std::locale::facet::_S_get_c_locale() (../../.././libstdc++-v3/src/locale.cc:185)
==3910== by 0x407A422: std::ctype<char>::ctype(unsigned short const*, bool, unsigned) (/usr3/BUILD/gcc/gcc-3.4.6/i686-pc-linux-gnu/libstdc++-v3/include/i686-pc-linux-gnu/bits/ctype_noninline.h:104)
==3910== by 0x40801D5: std::locale::_Impl::_Impl(unsigned) (/usr3/BUILD/gcc/gcc-3.4.6/libstdc++-v3/libsupc++/new:92)
==3910== by 0x4080EED: std::locale::_S_initialize_once() (/usr3/BUILD/gcc/gcc-3.4.6/libstdc++-v3/libsupc++/new:92)
==3910== by 0x4080F84: std::locale::_S_initialize() (../../.././libstdc++-v3/src/locale_init.cc:155)
==3910== by 0x4080FE7: std::locale::locale() (../../.././libstdc++-v3/src/locale_init.cc:102)
==3910==
==3910==
==3910== 22 bytes in 1 blocks are possibly lost in loss record 2 of 3
==3910== at 0x4017C38: operator new(unsigned) (m_replacemalloc/vg_replace_malloc.c:163)
==3910== by 0x40BF2C4: std::string::_Rep::_S_create(unsigned, unsigned, std::allocator<char> const&) (/usr3/BUILD/gcc/gcc-3.4.6/i686-pc-linux-gnu/libstdc++-v3/include/ext/new_allocator.h:81)
==3910== by 0x40C1CE4: char* std::string::_S_construct<char const*>(char const*, char const*, std::allocator<char> const&, std::forward_iterator_tag) (/usr3/BUILD/gcc/gcc-3.4.6/i686-pc-linux-gnu/libstdc++-v3/include/bits/basic_string.tcc:150)
==3910== by 0x40C1E15: std::string::string(char const*, std::allocator<char> const&) (/usr3/BUILD/gcc/gcc-3.4.6/i686-pc-linux-gnu/libstdc++-v3/include/bits/basic_string.h:1386)
==3910== **by 0x8048A6F: main (t3.c:23)**
==3910==
==3910== LEAK SUMMARY:
==3910== definitely lost: 16 bytes in 1 blocks.
==3910== **possibly lost: 22 bytes in 1 blocks.**
==3910== still reachable: 64 bytes in 1 blocks.
==3910== suppressed: 0 bytes in 0 blocks.
==3910== Reachable blocks (those to which a pointer was found) are not shown.
==3910== To see them, rerun with: --leak-check=full --show-reachable=yes
[enzo@P0101222 C]$
Solução
Porque você chama exit(0)
, de modo que o processo de destruição corda nunca é invocado. Basta usar return 0
.
Para elaborar, o construtor da memória std::string
aloca heap para armazenar a cadeia, contando com o destruidor para desalocar a memória. Se você declarar um objeto string na pilha, o destruidor será chamado automaticamente quando o objeto string sai do escopo, libertando assim a memória. Mas exit
é realmente um mecanismo C; -lo imediatamente sai do programa sem a realização de pilha-desenrolando o que significa que destruidores C ++ para objetos pilha locais não será chamado.
Outras dicas
Se você alocar cinco cordas, você recebe cinco vezes o vazamento de memória, ou ainda é a mesma quantidade? Se for a mesma quantidade, então você provavelmente não tem um vazamento em tudo. Algumas bibliotecas alocar memória para interna contabilidade / eficiência / et cetera que não são liberados até depois valgrind pára de olhar. Estes são apanhados como vazamentos de memória, porque o seu programa causou a alocação mas nunca causou desalocação. Se é cinco vezes o valor, então a sua implementação de corda podem estar em falta. Concordo com Charles Salvia embora ... tente novamente com return 0;
vez de exit(0);
e ver se isso muda alguma coisa.
Em uma das minhas aulas de ciência da computação nos foi dito que Valgrind saídas informações sobre cadeias que não devemos preocupar. Aqui está o arquivo de supressão que eles nos deram para cordas: https://sites.google.com/site/complingfiles/files/string. supp
Apesar de não ter exit(0)
no final do programa que eu tinha problema semelhante com falsos positivos com std::string
. Eu estava estaticamente ligação com libstdc++
. Alternando opção ligando para compartilhada e compilando com GLIBCXX_FORCE_NEW
suprimiu os avisos.