resumo: malloc.c: 3074 - Por que esse código faz com que o erro [fechado]

Question

O anexado abaixo código C quando executado dá o erro

summary: malloc.c:3074: sYSMALLOc: Assertion `(old_top == (((mbinptr) (((char *) &((av)->bins[((1) - 1) * 2])) - __builtin_offsetof (struct malloc_chunk, fd)))) && old_size == 0) || ((unsigned long) (old_size) >= (unsigned long)((((__builtin_offsetof (struct malloc_chunk, fd_nextsize))+((2 * (sizeof(size_t))) - 1)) & ~((2 * (sizeof(size_t))) - 1))) && ((old_top)->size & 0x1) && ((unsigned long)old_end & pagemask) == 0)' failed.

Em cada qualquer todas as chamadas para malloc (21); (Ver abaixo). Alguém pode explicar por que ?? Eu tentei cada coisa possível que eu posso pensar e ainda falhar.

arquivo: summary.c

/* 
* File:   summary.c
* Author: Maxim Veksler
*
* Created on December 4, 2009, 3:09 AM
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "manipulation.h"

/*
* Main for Maman 12, task 1 : Array summary utility
*/
int main(int argc, char** argv) {
    /*STUB*/
    char str[100];
    strcpy(str, "3 5 234 11 77 44 5");
    /*STUB*/

    int resultsSize;
    int* results;
    int* aggregated;

    results = parseInput(str, &resultsSize);
    aggregatedArray((int*)NULL, (int)NULL);


    return 0;
}

manipulation.c Arquivo

    /*
    * File:   manipulation.c
    * Author: Maxim Veksler
    *
    * Created on December 4, 2009, 3:09 AM
    */

    #include <stdlib.h>
    #include <string.h>
    #include <stdio.h>

    /*
    * Parse the input from user, dynamically allocate memory to the maximum
    * possible requirment. Then convert the array of string tokens into an
    * simple array of integers.
    */
    int* parseInput(char* input, int* nOfResults) {
        /* Allocate memory by the maximum possibly required size for int... */
        int *results = (int*) malloc(strlen(input));

        int* insertIterator = results;
        char* pch;


        /* We trash the user input, but it's cool - Worthless as usual. */
        pch = strtok(input,"\t ,.-");
        *nOfResults = 0;

        while(pch != NULL) {
        (*nOfResults)++;

        *insertIterator = atoi(pch);
        insertIterator++;
        pch = strtok(NULL, "\t ,.-");
        }

        return results;
    }


    /*
    * Summary the values given in the int array and return adress to new array
    * containing an increasin sum of the values.
    */
    int* aggregatedArray(int* inputArray, int size) {
        int* results;
        malloc(20);
        malloc(21);
    }

Editar Por favor tenha em conta este código é um despojado versão que é trazido aqui mostrar o problema. Eu já eliminado todas as partes não relevantes.

Answer 1

EDIT: woah, eu só percebi que você tem um erro de lógica muito ruim em seu código. Este não é apenas vazando, você tem um buffer overflow também!

int *results = (int*) malloc(strlen(input));

Isso irá alocar 18 bytes (o lengh de entrada) e tratar isso como uma série de int de, que significa que você pode caber 18 / sizeof(int)s int nele. assumindo tamanho usual x86, isso significa que você só pode caber (18/4) == 4,5 inteiros! Mais tarde, seu código irá escrever vários mais do que isso para a matriz. erro grande.

Para corrigir o problema, você deve estar usando realloc. Algo parecido com isto:

int *results = malloc(sizeof(int));
int result_size = 1;
int result_count = 0;

while(/*whatever*/) {
    /* ok, i want to add an element to results */
    if(result_count == result_size - 1) {
        int *p = realloc(results, (result_size + 1) * sizeof(int));
        if(!p) {
            free(results);
            return NULL; /* no more memory! */
        }
        results = p;
        result_size++;
    }
    results[result_count++] = /*value*/
}
return results;

---

É vazamentos porque você tem 2 mallocs que você não armazenar o resultado de qualquer lugar. Isso torna impossível para free o ponteiro essas chamadas retornam.

Na verdade, eu não sei o que aggregatedArray é suposto ser realmente fazendo, no momento, ele não faz nada e vazamento.

Além disso, você tem results = parseInput(str, &resultsSize); onde parseInput retorna um ponteiro malloced. Você deve ter uma free(results); mais tarde, quando você não precisa mais deste (provavelmente logo após a chamada aggregatedArray).

Finalmente, como uma nota lateral. Eu diria que aggregatedArray((int*)NULL, (int)NULL); deve de fato ser aggregatedArray(results, resultsSize); :-P.

Answer 2

O seguinte declaração atribui uma memória de 18 bytes ( "3 5 234 11 77 44 5")

int *results = (int*) malloc(strlen(input));

mas você está colocando inteiros em que área de memória ... por isso não vai durar muito tempo, quando você teria usedup todo o espaço ... então isso é definitivamente errada a fazer.

mais .. você não estiver usando-se quaisquer chamadas gratuitas () .. por isso que seria um problema também ..

Answer 3

Na função "aggregatedArray" você não está atribuindo os ponteiros retornados de malloc para uma variável para que eles possam ser libertados mais tarde. Eles estão perdidos no espaço!