Zusammenfassung: malloc.c: 3074 - Warum dieser Code tut bewirkt, dass der Fehler [geschlossen]

Question

Die folgenden C-Code angebracht, wenn Sie die Fehler gibt

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.

Auf jedem beliebigen jeden Anruf für malloc (21); (Siehe unten). Kann jemand bitte erklären, warum ?? Ich habe alles mögliche versucht, ich mir vorstellen kann und es immer noch nicht.

Datei: 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;
}

Datei manipulation.c

    /*
    * 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);
    }

Bearbeiten Bitte beachten Sie, wird dieser Code eine abgespeckte Version, die hier gebracht wird, um das Problem zeigen. Ich habe alle nicht relevanten Teile gelöscht.

Answer 1

EDIT: woah, wird mir klar, dass Sie einen ziemlich schlechten Logikfehler in Ihrem Code haben. Dies ist nicht nur undicht, Sie haben auch einen Pufferüberlauf!

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

Das wird zuteil 18 Bytes (das lengh von Input) und behandeln, dass wie ein Array von int ist, was bedeutet, können Sie 18 / sizeof(int) ints darin passen. übliche x86 Größe unter der Annahme, das bedeutet, dass Sie nur passen (18/4) == 4,5 ganze Zahlen! Später wird Ihr Code mehr mehr als das in das Array schreiben. Große Fehler.

Um das Problem zu beheben, sollten Sie mit realloc sein. So etwas wie folgt aus:

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;

---

Es leckt, weil Sie 2 mallocs haben, die Sie nicht das Ergebnis irgendwohin speichern. Dies macht es unmöglich Rück den Zeiger diese Anrufe free.

In der Tat, ich bin nicht sicher, welche aggregatedArray soll im Moment tatsächlich tun, ist, es tut nichts und Leck.

Auch Sie haben results = parseInput(str, &resultsSize); wo parseInput einen malloced Zeiger zurückgibt. Sie sollten eine free(results); haben später, wenn Sie nicht mehr benötigen, diese (wahrscheinlich direkt nach dem aggregatedArray Anruf).

Schließlich als eine Randnotiz. Ich würde vermuten, dass aggregatedArray((int*)NULL, (int)NULL); sollte aggregatedArray(results, resultsSize); :-P in der Tat sein.

Answer 2

Die folgende Anweisung ordnet einen Speicher von 18 Bytes ( "3 5 234 11 77 44 5")

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

aber Sie setzen ganze Zahlen auf diesen Speicherbereich ... so ist es lange dauern wird nicht, wenn Sie usedup den ganzen Raum haben würde ... also das ist definitiv falsch zu tun.

weiter .. Sie sind mit bis nicht frei () ruft .. so das wäre auch ein Problem sein ..

Answer 3

In der Funktion „aggregatedArray“ Sie zuweisen nicht die Zeiger zurück von malloc auf eine Variable, so dass sie später befreit werden können. Sie sind verloren im Raum!