C *** glibc detected *** ./mat: realloc(): invalid next size: 0x09619170 ***

[Charlie85]

Guten tag ich bekomme beim aufruf dieses Programms die Fehlermeldung
Beschreibung des Programms :
das Programm soll aus einem file matrizen lesen und die wollte ich in einem 3d Array verpacken
matrizen[nr/index][zeile][spalte];
aber nach dem 200 aufruf kann es nicht mehr allocated werden .

:*** glibc detected *** ./mat: realloc(): invalid next size: 0x09619170 ***
was mache ich hier falsch bitte um HILFE !!!!!

#include<stdio.h>
#include<stdlib.h>
#include "matrix.h"

int*** matrizen ;
FILE *fp;
int speicher;

int read(){
int zahl;
int zl=0;
int sp=0;
int i=0;
if ( ( fp = fopen("matrix.dat", "r") ) == NULL ) {
         fprintf(stderr," *** Error: Can't open 'Dateiname' for read!\n");
    return 1 ;
  }
init();
while(fscanf(fp,"%d",&zahl) != EOF ){

		 matrizen[i][zl][sp]=zahl;
	 printf("\nmatrizen[%d][%d][%d]= %3d\n ",i,zl,sp,matrizen[i][zl][sp]);
		 if((zl==DIM-1) && (sp==DIM-1) ){ getmem();zl=0; sp=0; i++; }
		 else if(sp==DIM-1){	zl++;sp=0;	}
	         else {sp++;}
}

free(matrizen);
fclose(fp);
return 0;
}

void init(){
int zl;

matrizen=(int***) malloc(100*sizeof(int));
matrizen[0]=(int**)malloc(DIM*sizeof(int));

for(zl=0;zl<DIM;zl++){
matrizen[0][zl]=(int*)malloc(DIM*sizeof(int));
}


}

void getmem(){
int zl;
speicher++;
static int zaehler;
if(zaehler>=100){
matrizen= (int***)realloc(matrizen,100*sizeof(int));
printf("\n\nspeicher reservierti\n\n");
zaehler=0;
}
printf("zaehler :%d",zaehler);
matrizen[speicher]=(int**)malloc(DIM*sizeof(int));
for(zl=0;zl<DIM;zl++){
matrizen[speicher][zl]=(int*)malloc(DIM*sizeof(int));
}
zaehler++;
}


int main(){

read();

return 0;
}

 

[antred]

Das riecht, als hättest du dir durch Speicherkorruption deinen Heap zerballert. Irgendwo über eine Arraygrenze hinaus geschrieben oder anderweitig wohin geschrieben, wo du nicht hättest hinschreiben dürfen.


P.S. Rück das mal anständig ein. Kann ja kein Schwein lesen.

 

[Adrenalin2]

Deine Speicherallokation ist nicht ganz in Ordnung, vor allem gibst du den Speicher so auch nicht wieder richtig frei. Das Einlesen sieht etwas umständlich aus. Hast du DIM im Header fest definiert? Wie groß sind deine Matrizen? Sind sie quadratisch?

Ergänzung (11. Juni 2013)

So müsste es funktionieren:

#include<stdio.h>
#include<stdlib.h>
//#include "matrix.h"

int*** matrizen ;
FILE *fp;
int nMatrizen = 0;

const int DIM = 5;

void getmem(int *n);

int read(){
  int zahl;

  if ( ( fp = fopen("matrix.dat", "r") ) == NULL ) {
    fprintf(stderr," *** Error: Can't open 'Dateiname' for read!\n");
    return 1 ;
  }

  matrizen = malloc(sizeof(int**));

  int zl, sp;

  while(1){

    for(zl=0; zl<DIM; zl++){
      for(sp=0; sp<DIM; sp++){

	if(fscanf(fp,"%d",&zahl) == EOF){

	  fclose(fp);

	  if(zl==0 && sp==0){
	    printf("Dateiende erreicht. %d Matrizen gelesen\n", nMatrizen);
	    return 0;
	  }else{
	    printf("Vorzeitiges Dateiende!\n");
	    return 1;
	  }
	}else if(zl==0 && sp==0) getmem(&nMatrizen);
	
	matrizen[nMatrizen-1][zl][sp] = zahl;

	printf("matrizen[%d][%d][%d]= %3d\n ",nMatrizen-1,zl,sp,matrizen[nMatrizen-1][zl][sp]);
      }
    }
  }
  
  free(matrizen);

  return 0;
}

void getmem(int *n){
  //printf("Init Matrix: %d\n", n);

  matrizen = realloc(matrizen, (*n+1)*sizeof(int**));
  matrizen[*n] = malloc(DIM*sizeof(int*));

  int zl;
  for(zl=0; zl<DIM; zl++) matrizen[*n][zl] = malloc(DIM*sizeof(int));

  *n = *n + 1;
}

void dealloc(int n){
  int zl;
  
  for(zl=0; zl<DIM; zl++) free(matrizen[n][zl]);
  free(matrizen[n]);
}


int main(){
  
  int ret = read();
  
  // Freigeben
  int n;
  
  for(n=0; n<nMatrizen; n++) dealloc(n);

  free(matrizen);

  return ret;
}

 

[Charlie85]

Erstmal ein dankeschön für dieses code und die damit hängenden mühe .
Im grunde genommen hatte ich dass vor was du mir hier zusammen gebastelt hast aber ich hätte da eine Frage warum erweiterst du bei getmem() den speicher um ein vielfaches als gebraucht wird
Heisst es nicht dass (n*+1) dieses speicher doppelt so gross erweitert wird als gebraucht ? Oder wo liegt der gedanken fehler ?

Ergänzung (11. Juni 2013)

Ein schwein solls ja auch nicht lesen können

 

[Adrenalin2]

Realloc erweitert die Größe eines reservierten Blocks. Ich erweitere in Zeile 58 den Speicherblock für die Liste von n Pointern auf 2D-Integer-Arrays (Matrizen) auf n+1 Pointer. Es kommt also nur eine Matrix dazu. Das Sternchen vor dem n dereferenziert nur, gibt also den Wert von n zurück.
Die Matrix benötigt dann natürlich noch die Felder für die Pointer auf die Matrix-Zeilen (Zeile 59) und den Speicherplatz für die Integer-Elemente der Matrizen (Zeile 62). Die Elemente werden dann auf die gleiche Weise in dealloc() wieder freigegeben. Du hattest dort z.B. nur "free matrizen" stehen. Das gibt meines Wissens nach nur den Speicher für das Matrizenfeld frei, nicht aber die darunterliegenden Strukturen.