4. free() spinnt rum

free() spinnt rum

  • W

    Hallo,

    ich hab ein Problem mit der Freigabe eines allozierten Speichers.

    Ich habe ein Struktur struct str definiert, und struct str a1 will ich im Heap ablegen.

    struct str *a1;
int initial_size = 20;

a1 = (struct str *)malloc(sizeof(struct str)+initial_size);

if(a1==NULL) {
	perror("Error allocating space...\n");
	return NULL;
}

free(a1);

    Aus diesem Programmausschnitt habe ich nichts gekürzt, aber zur Laufzeit erhalte ich folgenden Fehler:

    main(1473) malloc: *** error for object 0x1001000a0: pointer being freed was not allocated
*** set a breakpoint in malloc_error_break to debug
Abort trap

    Welche Gründe kann das denn haben? Ich komm auf nichts... 😕

    Vielen Dank wenn mir da jemand auf die Sprünge helfen könnte 🙂

    Beste grüße,

    wertix

    0
  • ?

    Probiers mal mit:

    a1 = malloc(sizeof(str)+initial_size);
    0
  • ?

    Entschuldigung, ich meinte natürlich

    a1 = malloc(sizeof(*a1)+initial_size);

    Aber initial_size kommt mir komisch vor, eigentlich sollte man das weglassen. Was bedeutet das denn?

    0
  • W

    Geht leider auch nicht, selbe Fehlermeldung 😞

    Zu initial_size:

    Ich will im Heap direkt hinter der Struktur immer noch Elemente von insgesamt Größe initial_size ablegen.

    EDIT:

    Wenn ich den entsprechenden Programmausschnitt separat ausführe, erhalte ich keine Fehlermeldung:

    #include <stdlib.h>

struct str {
	void *mem;
	int nr;
};

int main() {

	struct str *a1;

	size_t initial_size = 20;

		a1 = malloc(sizeof(struct str)+initial_size);

		if(a1==NULL) {
			perror("Error allocating space: malloc()!\n");
			return 0;
		}

		free(a1);

	return 1;

}

    D.h. es muss wohl an der Programmumgebung liegen.

    Im eigentlichen Programm ist dieser Programmausschnitt in einer Funktion int initStr(init_size); enthalten, die in einem Modul A ist und von der main-Methode des Moduls B aufgerufen wird.

    Ich checks einfach nicht 😕

    0

  • Ich versuch mal laut zu denken.

    Grundsätzlich sind deine Beispiele etwas seltsam. Was bringt es, Speicher zu reservieren, um ihn sofort wieder freizugeben.
    Kann es sein, dass du Speicher an einer Stelle reservierst und einer komplett anderen Stelle freigibst? Dann sollte geprüft werden, ob zwischendurch der Speicher nicht schon an einer 2. Stelle freigegeben wird.

    if(a1 != NULL)
    free(a1);
    0
  • ?

    Dann sollte man aber auch den Zeiger auf NULL setzen.

    if(a1 != NULL) {
    free(a1); 
    a1 = NULL;	
}

    Bzw. da wo der Zeiger abgelegt war (Liste, Array, Struktur)

    0

  • Hallo,

    wozu forderst Du überhaupt den Speicher an, wenn Du ihn ohne lange zu fackeln gleich wieder frei gibts?

    Bis Du Dir sicher, daß Du den Laufzeitfehler von dem free in Zeile 11 erhälst?

    BTW.: Den Parameter von free muß man/frau nicht auf NULL überprüfen. Das mavht schon free selber.

    mfg Martin

    0
Anmelden zum Antworten