Shapefile memory leak

[blinker]

Hi,

ich versuche gerade Shapefiles (.shp) einzulesen. Soweit funktioniert das Ganze auch. Ich habe mir nun eine Struktur erstellt, in die ich den Inhalt eines Shapefiles kopieren möchte. Die Shapefiles sind unterschiedlich groß. Zwischen ein paar Bytes und 46MB ist alles dabei.

Shapefiles sind folgendermaßen aufgebaut:
ShapeHeader
ShapeContentHeader---ShapeContent
ShapeContentHeader---ShapeContent
.
.
.

Die Anzahl der Einträge wird im ShapeHeader bestimmt. Der ShapeContentHeader bestimmt die Größe des ShapeContents.

Das Problem bei den Shapefiles ist, dass sich unterschiedliche Objekte darin befinden: Punkte, Linien, Flächen.

Ich versuche nun ein Polygon auszulesen.

struct stype_polygon{
	int ShapeType;
	double Box[4];  //Koordinaten
	int NumParts;   //Anzahl der Teile
	int NumPoints;  //Anzahl der Punkte
	int* Parts;     //Zeiger auf die Teile
	POINT* Points;  //Zeiger auf die Punkte
};

Das Polygon entspricht dem ShapeContent.

Den Header der Datei kann ich auslesen. Wenn ich aber mein Struct mit Daten füllen will, kommt es zum Absturz mit folgender Meldung: "Zu wenig Speicher"

Ich denke, dass ich eigentlich immer alles was ich nicht brauche auch wieder lösche.

stype_polygon* ShapeMainAgent::ReadFileContent(LPCTSTR lpszFilename){
	ifstream file(lpszFilename, ios_base::in | ios_base::binary);
	int nOffset = 0;
	int actSize = 0;
	shape_rec_header srHeader;
	shape_header shHeader;
	stype_polygon poly;
	stype_polygon* polyArray = NULL;

	unsigned char buf[100];
	unsigned char bufRecNr[8];

	if(file.is_open()){
		file.read((char*)buf, sizeof(buf));
		memcpy(&shHeader, buf, sizeof(buf));
		shHeader.FileLength = Big2LittleEndian(shHeader.FileLength);
		actSize += sizeof(buf);
		while (actSize <= shHeader.FileLength || !file.eof()) {

			file.read((char*)bufRecNr, sizeof(bufRecNr));
			memcpy(&srHeader, bufRecNr, sizeof(bufRecNr));
			actSize += sizeof(bufRecNr);
			srHeader.RecordNumber = Big2LittleEndian(srHeader.RecordNumber);
			srHeader.ContentLength = Big2LittleEndian(srHeader.ContentLength)*2;

			unsigned char* ptr = new unsigned char[srHeader.ContentLength]; ***********

			file.read((char*)ptr, srHeader.ContentLength);
			actSize += srHeader.ContentLength;

			memcpy(&poly.ShapeType, ptr, 4); //Get ShapeType
			memcpy(&poly.Box, ptr+4, 36);
			memcpy(&poly.NumParts, ptr+36, 4);
			memcpy(&poly.NumPoints, ptr+40, 4);

			int* pnParts = new int[poly.NumParts];

			memcpy(pnParts, ptr+44, sizeof(int)*poly.NumParts);

			poly.Parts = pnParts;
			POINT* pnPoints = new POINT[poly.NumPoints];

			memcpy(pnPoints, ptr+44+sizeof(int)+poly.NumParts, sizeof(POINT)+poly.NumPoints);
			poly.Points = pnPoints;

			delete [] ptr;
			delete [] pnParts;
			delete [] pnPoints;

			polyArray = (stype_polygon*)realloc(polyArray, sizeof(poly));
			polyArray[nOffset] = poly;
			nOffset++;
		}
	}
	file.close();
	return polyArray;
}

An der Stelle mit den ******* stürzt das Programm immer während des dritten Durchlaufs ab. Egal ob die Datei 412 Byte oder 46MB groß ist?

Hat evtl. jemand ne Idee?