perguntas c malloc (mem corrupção)

Question

Ao usar malloc, se produz uma descarga de memória com o erro:

malloc(): memory corruption: ....... ***

Isso significa que malloc tentou alocar memória que não era livre para alocar? Se assim for, quais são as causas desta?

Answer 1

Ele depende completamente da sua implementação malloc, mas geralmente o que é isto significa é que, em algum momento antes que malloc algo escreveu mais dados para um buffer malloced do que seu tamanho.

Um monte de implementações de malloc armazenar um pouco de sua linha de dados com a sua memória, em outras palavras:

+--------------------------------+
|14 bytes -> Padding             | 
+--------------------------------+
|2 bytes -> Internal malloc info |
+--------------------------------+
|6 bytes -> Your data            |
+--------------------------------+
|8 bytes -> Padding              |
+--------------------------------+
|2 bytes -> Internal malloc info |
+--------------------------------+

Então, se algum código de vocês ou uma biblioteca escreveu 16 bytes para que 6 byte tampão seria substituir o estofamento e os 2 bytes de informações malloc interno. A próxima vez que você chamar malloc ele vai tentar caminhar por suas dados para encontrar espaço, bateu o espaço substituído, e será sem sentido desde que você substituiu-o, corrompendo o heap.

Dependendo da implementação tal erro poderia também ser causada por fazer um double livre.

Answer 2

Provavelmente, isso não é um problema em si malloc. Em vez disso, este é um problema com o seu pedido modificando partes do heap que não deveria.

Se você está rodando em Linux, tente usar Valgrind para ver qual código está destruindo sua pilha.

Answer 3

A causa disto é que você escreveu sobre os dados que malloc () não lhe deu permissão para escrever sobre - ou de saturação de buffer (escrever para além do fim do espaço que lhe foi dada) ou estouro de buffer (escrito antes do início do tampão).

Por vezes, pode ser causado pela libertação de um ponteiro que não foi atribuída por malloc () et ai, ou por re-libertar (duplo libertação) um ponteiro que foi atribuída por malloc (). Por exemplo, liberando um buffer estático é uma má idéia; você terá a corrupção.

Você deve assumir que o problema está no seu código -. É extremamente improvável que seja um problema no malloc () et al, e bastante improvável que seja em qualquer outra biblioteca que você está usando

Answer 4

Existem várias coisas que são causas comuns de corrupção de memória:

• ultrapassagem a alocação de memória (escrever passado o fim do bloco alocado)
• dupla libertar um bloco
• usando um ponteiro depois de ter sido libertado
• e, claro, algo escrito erroneamente através de um ponteiro que não tem nada a ver com uma alocação anterior (a 'ram hit' ou ponteiro desonestos.) - este é o caso geral, que inclui todos os itens acima

Estes problemas podem ser difíceis de depuração porque a causa e efeito são muitas vezes separados pelo tempo e espaço (área diferente do código). Assim, o erro não serem notados até uma eternidade (em tempo de computador) passa após o erro que causou as executa problemáticas.

Usando uma pilha de depuração pode ser muito útil na depuração estas questões. compiladores da Microsoft têm um CrtDebug pilha desse habilitado em compilações de depuração (mas lata tem configuração adicional itens set). Eu não tenho certeza do que GCC tem fora da caixa, mas existem ferramentas que eu estou familiarizado com, de passagem, como Valgrind e elétrico da cerca que ajuda poder. Finalmente, há uma tonelada de home-grown pilha de depuração bibliotecas que possa ser útil (Google ao redor).

Answer 5

Você poderia por favor fornecer seu malloc declaração ()?

Além disso, eu queria verifique que o valor de retorno não é nulo?

Fora de não ter a memória para alocar para começar, os problemas que tenho encontrado ao usar malloc() ou new semelhante a natureza que você mencionou, onde, na verdade, resultante de uma pilha corrompido. I normalmente encontrado algum código "interessante" em outras partes do programa fazendo soomething como memcpy () com um personagem tampão causando uma saturação de buffer e um espaço de endereço mutilado.

Bn