Löschen einer verketteten Liste führt zu Speicherzugriffsfehler

Reply to Löschen einer verketteten Liste führt zu Speicherzugriffsfehler on Tue, 29 Jan 2008 17:33:59 GMT

jensr — Tue, 29 Jan 2008 17:33:59 GMT

Hallo,
ich habe eine Liste, welche ich in einer Funktion mit Elementen "fülle".
Die Liste habe ich global definiert. Jedesmal, wenn ich die Funktion neu aufrufe,
soll die Liste gelöscht und neu "gefüllt" werden um nicht zu viel Speicherplatz zu belegen.

Folgend mein Code, welcher funktioniert, aber nach mehrmaligen Aufrufen der Funktion CreateQSDTriangles() immer mehr speicher belegt.

Ich definiere meine Liste global:

struct TriangleList
{
	Triangle 		t;
	TriangleList	*next;	
};

TriangleList 	*triangles = new TriangleList;

Meine Funktion, welche die Liste füllt:

void CreateQSDTriangles(void)
{

	TriangleList *triangles_begin;
	TriangleList *triangles_node;
	TriangleList *triangles_delete;

	triangles_begin = triangles;
	while (quads)
	{
		q = quads->q;		

		triangles_node = new TriangleList;
		triangles_node->t = quad.t1;
		triangles_node->next = NULL;
		triangles->next = triangles_node;
		triangles = triangles_node;
	}
	triangles = triangles_begin;
}

Folgend die geänderte Funktion, mit welcher das Programm leider wegen Speicherzugriffsfehler abstürtzt.

void CreateQSDTriangles(void)
{

	TriangleList *triangles_begin;
	TriangleList *triangles_node;
	TriangleList *triangles_delete;

	while (triangles)
	{
		triangles_delete = new TriangleList;
		triangles_delete = triangles;
		triangles = triangles->next;
		delete triangles_delete;
		triangles_delete = NULL;

	}
	triangles = new TriangleList;

       triangles_begin = triangles;
	while (quads)
	{
		q = quads->q;		

		triangles_node = new TriangleList;
		triangles_node->t = quad.t1;
		triangles_node->next = NULL;
		triangles->next = triangles_node;
		triangles = triangles_node;
	}
	triangles = triangles_begin;
}

Vielleicht kann mir jemand sagen wo der Fehler steckt. Ich habe den Code hier extrem gekürzt reinkopiert. Mein Programm funktioniert wie gesagt einwandfrei, nur wenn ich den Code zum Löschen der Dreiecksliste einbaue, stürtzt das Programm ab.

Viele Grüße
Jens

Reply to Löschen einer verketteten Liste führt zu Speicherzugriffsfehler on Tue, 29 Jan 2008 17:40:59 GMT

Braunstein — Tue, 29 Jan 2008 17:40:59 GMT

Hallo,

Lass einfach mal das hier weg (Zeile 10)

triangles_delete = new TriangleList;

Du allozierst hier Speicher, überschreibst aber danach die Variable wieder. Dieser Speicher wird also nie freigegeben.

Reply to Löschen einer verketteten Liste führt zu Speicherzugriffsfehler on Tue, 29 Jan 2008 19:21:47 GMT

jensr — Tue, 29 Jan 2008 19:21:47 GMT

Hallo,

die Zeile habe ich testweise eingefügt.
Ohne diese bleibt das Problem leider bestehen..

Reply to Löschen einer verketteten Liste führt zu Speicherzugriffsfehler on Tue, 29 Jan 2008 19:37:19 GMT

Badestrand — Tue, 29 Jan 2008 19:37:19 GMT

Ich finde, du machst es dir ein wenig kompliziert! Füg doch wenigstens Konstruktor und Destruktor in die Liste ein, die nehmen dir immerhin ein wenig was ab:

struct TriangleList
{
    Triangle         t;
    TriangleList    *next;

    TriangleList()
    {
        next = NULL;
    }

    ~TriangleList()
    {
        if ( next )
            delete next;
    }
};

// ...

// Liste löschen
delete triangles;

Zu deinem Fehler: Ich wüsste nicht, wo hier die while-Schleife aushören sollte (Singlethreaded jedenfalls)

while (quads)
{
    q = quads->q;
    // ...
}

Vielleicht meinst du quads = quads->q; ?

Reply to Löschen einer verketteten Liste führt zu Speicherzugriffsfehler on Tue, 29 Jan 2008 22:18:59 GMT

jensr — Tue, 29 Jan 2008 22:18:59 GMT

Ich poste einfach mal die ganze Funktion. Wahrscheinlich habe ich das alles sehr umständlich gemacht, aber habe bisher wenig mit verketten Listen gearbeitet.

Der auskommentierte Teil macht Probleme.

/** 
 * Create triangles by quad subdivision
 * */
void CreateQSDTriangles(void)
{
	int precision = 1;
	triangle_count = 0;
	TriangleList *triangles_begin;
	TriangleList *triangles_node;
	TriangleList *triangles_delete;
	QuadList *quads = new QuadList;
	QuadList *quads_delete;
	QuadList *temp_quads; 
	QuadList *temp_quads_node;
	QuadList *temp_quads_begin;
	QuadTree quad;
	Quad q, temp_q;
	Vertex middle;

	/*
	while (triangles)
	{
		triangles_delete = new TriangleList;
		triangles_delete = triangles;
		triangles = triangles->next;
		printf("%i\n", triangles_delete->t.a.x);
		delete triangles_delete;
		triangles_delete = NULL;

	}
	triangles = new TriangleList;*/

	//init quad list with first quad
	q.a = CreateVertex(terrain_corner.x, terrain_corner.z);
	q.b = CreateVertex(terrain_corner.x + terrain_size, terrain_corner.z);
	q.c = CreateVertex(terrain_corner.x + terrain_size, terrain_corner.z + terrain_size);
	q.d = CreateVertex(terrain_corner.x, terrain_corner.z + terrain_size);

	quads->q = q;
	quads->next = NULL;

	//refine terrain up to max precision
	while (precision <= max_precision)
	{
		temp_quads = new QuadList;
		temp_quads_begin = temp_quads;
		while (quads)
		{
			q = quads->q;

			//quad should be refined
			//triangle should be refined
			if (ApproxError(q) || !mesh_simplification)
			{
				//refine quad into 4 quads and append it to temp_quad list
				middle.x = q.a.x + (q.b.x - q.a.x) / 2;
				middle.z = q.a.z + (q.d.z - q.a.z) / 2;

				temp_q.a = CreateVertex(q.a.x, q.a.z);
				temp_q.b = CreateVertex(middle.x, q.a.z);
				temp_q.c = CreateVertex(middle.x, middle.z);
				temp_q.d = CreateVertex(q.d.x, middle.z);

				temp_quads_node = new QuadList;
				temp_quads_node->q = temp_q;
				temp_quads_node->next = NULL;
				temp_quads->next = temp_quads_node;
				temp_quads = temp_quads_node;

				temp_q.a = CreateVertex(middle.x, q.a.z);
				temp_q.b = CreateVertex(q.b.x, q.b.z);
				temp_q.c = CreateVertex(q.b.x, middle.z);
				temp_q.d = CreateVertex(middle.x, middle.z);

				temp_quads_node = new QuadList;
				temp_quads_node->q = temp_q;
				temp_quads_node->next = NULL;
				temp_quads->next = temp_quads_node;
				temp_quads = temp_quads_node;

				temp_q.a = CreateVertex(middle.x, middle.z);
				temp_q.b = CreateVertex(q.b.x, middle.z);
				temp_q.c = CreateVertex(q.c.x, q.c.z);
				temp_q.d = CreateVertex(middle.x, q.c.z);

				temp_quads_node = new QuadList;
				temp_quads_node->q = temp_q;
				temp_quads_node->next = NULL;
				temp_quads->next = temp_quads_node;
				temp_quads = temp_quads_node;

				temp_q.a = CreateVertex(q.a.x, middle.z);
				temp_q.b = CreateVertex(middle.x, middle.z);
				temp_q.c = CreateVertex(middle.x, q.c.z);
				temp_q.d = CreateVertex(q.d.x, q.d.z);

				temp_quads_node = new QuadList;
				temp_quads_node->q = temp_q;
				temp_quads_node->next = NULL;
				temp_quads->next = temp_quads_node;
				temp_quads = temp_quads_node;

			}
			else
			{
				temp_quads_node = new QuadList;
				temp_quads_node->q = q;
				temp_quads_node->next = NULL;
				temp_quads->next = temp_quads_node;
				temp_quads = temp_quads_node;
			}
			quads = quads->next;
		}
		temp_quads = temp_quads_begin;
		quads = temp_quads->next;

		precision++;
	}

	//create triangles out of quads and delete quads
	triangles_begin = triangles;
	while (quads)
	{
		q = quads->q;

		middle.x = q.a.x + (q.b.x - q.a.x) / 2;
		middle.z = q.a.z + (q.d.z - q.a.z) / 2;

		quad.t1.a = CreateVertex(q.a.x, q.a.z);
		quad.t1.b = CreateVertex(q.b.x, q.b.z);
		quad.t1.c = CreateVertex(middle.x, middle.z);

		quad.t2.a = CreateVertex(middle.x, middle.z);
		quad.t2.b = CreateVertex(q.b.x, q.b.z);
		quad.t2.c = CreateVertex(q.c.x, q.c.z);

		quad.t3.a = CreateVertex(q.d.x, q.d.z);
		quad.t3.b = CreateVertex(middle.x, middle.z);
		quad.t3.c = CreateVertex(q.c.x, q.c.z);

		quad.t4.a = CreateVertex(q.a.x, q.a.z);
		quad.t4.b = CreateVertex(middle.x, middle.z);
		quad.t4.c = CreateVertex(q.d.x, q.d.z);

		triangles_node = new TriangleList;
		triangles_node->t = quad.t1;
		triangles_node->next = NULL;
		triangles->next = triangles_node;
		triangles = triangles_node;

		triangles_node = new TriangleList;
		triangles_node->t = quad.t2;
		triangles_node->next = NULL;
		triangles->next = triangles_node;
		triangles = triangles_node;

		triangles_node = new TriangleList;
		triangles_node->t = quad.t3;
		triangles_node->next = NULL;
		triangles->next = triangles_node;
		triangles = triangles_node;

		triangles_node = new TriangleList;
		triangles_node->t = quad.t4;
		triangles_node->next = NULL;
		triangles->next = triangles_node;
		triangles = triangles_node;

		quads_delete = quads;
		quads = quads->next;
		delete quads_delete;
		quads_delete = NULL;

		triangle_count += 4;
	}
	triangles = triangles_begin;
}

Reply to Löschen einer verketteten Liste führt zu Speicherzugriffsfehler on Tue, 29 Jan 2008 22:22:35 GMT

Braunstein — Tue, 29 Jan 2008 22:22:35 GMT

Bist du gezwungen mit einer eigenen Liste zu arbeiten oder kannst du auch was aus dem Standard (hier z.Bsp. list) nehmen?
Wenn du unbedingt eine eigene Liste nehmen willst würde ich sie an deiner Stelle aber trotzdem in eine Klasse packen.

Reply to Löschen einer verketteten Liste führt zu Speicherzugriffsfehler on Tue, 29 Jan 2008 22:30:08 GMT

Ramsis — Tue, 29 Jan 2008 22:30:08 GMT

Für einen echten c++ programmierer muss das eine Horrorschow sein.

Du muss für jede neue TriangleList das Element next auf NULL setzen.

triangles = new TriangleList;
triangles->next = NULL;

Reply to Löschen einer verketteten Liste führt zu Speicherzugriffsfehler on Wed, 30 Jan 2008 17:32:38 GMT

jensr — Wed, 30 Jan 2008 17:32:38 GMT

Hallo, habe es jetzt hinbekommen mit dem Löschen der Liste, aber seltsamerweise stürzt mir das Programm jetzt bei ca. 200.000 Dreiecken ab. Lösche ich die Dreiecksliste nicht, funktioniert es.

TriangleList *Triangles;

struct TriangleList
{
	Triangle 		t;
	TriangleList	*next;

	TriangleList()
    {
        next = NULL;
    } 

	~TriangleList()
    {
        if (next)
        	delete next;
    }
};

/** 
 * Create triangles by quad subdivision
 * */
void TerrainViewer::CreateQSDTriangles(void)
{
	int precision = 1;
	triangle_count = 0;
	TriangleList *triangles_begin;
	TriangleList *triangles_node;
	QuadList *quads = new QuadList;
	QuadList *temp_quads; 
	QuadList *temp_quads_node;
	QuadList *temp_quads_begin;
	QuadTree quad;
	Quad q, temp_q;
	Vertex middle;

	//delete previous triangle list to save memory 
	delete Triangles;
	Triangles = NULL;

	/*********************************************\
	|*      init quad list with first quad       *|
	\*********************************************/

	q.a = CreateVertex(terrain_corner.x, terrain_corner.z);
	q.b = CreateVertex(terrain_corner.x + terrain_size, terrain_corner.z);
	q.c = CreateVertex(terrain_corner.x + terrain_size, terrain_corner.z + terrain_size);
	q.d = CreateVertex(terrain_corner.x, terrain_corner.z + terrain_size);

	quads->q = q;

	/*********************************************\
	|*     refine terrain up to max precision    *|
	\*********************************************/

	//refine terrain up to max precision
	while (precision <= max_precision)
	{
		temp_quads = new QuadList;
		temp_quads_begin = temp_quads;
		while (quads)
		{
			q = quads->q;

			//quad should be refined
			//triangle should be refined
			if (ApproxError(q) || !mesh_simplification)
			{
				//refine quad into 4 quads and append it to temp_quad list
				middle.x = q.a.x + (q.b.x - q.a.x) / 2;
				middle.z = q.a.z + (q.d.z - q.a.z) / 2;

				temp_q.a = CreateVertex(q.a.x, q.a.z);
				temp_q.b = CreateVertex(middle.x, q.a.z);
				temp_q.c = CreateVertex(middle.x, middle.z);
				temp_q.d = CreateVertex(q.d.x, middle.z);

				temp_quads_node = new QuadList;
				temp_quads_node->q = temp_q;
				temp_quads->next = temp_quads_node;
				temp_quads = temp_quads_node;

				temp_q.a = CreateVertex(middle.x, q.a.z);
				temp_q.b = CreateVertex(q.b.x, q.b.z);
				temp_q.c = CreateVertex(q.b.x, middle.z);
				temp_q.d = CreateVertex(middle.x, middle.z);

				temp_quads_node = new QuadList;
				temp_quads_node->q = temp_q;
				temp_quads->next = temp_quads_node;
				temp_quads = temp_quads_node;

				temp_q.a = CreateVertex(middle.x, middle.z);
				temp_q.b = CreateVertex(q.b.x, middle.z);
				temp_q.c = CreateVertex(q.c.x, q.c.z);
				temp_q.d = CreateVertex(middle.x, q.c.z);

				temp_quads_node = new QuadList;
				temp_quads_node->q = temp_q;
				temp_quads->next = temp_quads_node;
				temp_quads = temp_quads_node;

				temp_q.a = CreateVertex(q.a.x, middle.z);
				temp_q.b = CreateVertex(middle.x, middle.z);
				temp_q.c = CreateVertex(middle.x, q.c.z);
				temp_q.d = CreateVertex(q.d.x, q.d.z);

				temp_quads_node = new QuadList;
				temp_quads_node->q = temp_q;
				temp_quads->next = temp_quads_node;
				temp_quads = temp_quads_node;

			}
			else
			{
				temp_quads_node = new QuadList;
				temp_quads_node->q = q;
				temp_quads->next = temp_quads_node;
				temp_quads = temp_quads_node;
			}
			quads = quads->next;
		}
		temp_quads = temp_quads_begin;
		quads = temp_quads->next;

		precision++;
	}

	/*********************************************\
	|*       create triangles out of quads       *|
	\*********************************************/

	while (quads)
	{
		q = quads->q;

		middle.x = q.a.x + (q.b.x - q.a.x) / 2;
		middle.z = q.a.z + (q.d.z - q.a.z) / 2;

		quad.t1.a = CreateVertex(q.a.x, q.a.z);
		quad.t1.b = CreateVertex(q.b.x, q.b.z);
		quad.t1.c = CreateVertex(middle.x, middle.z);

		quad.t2.a = CreateVertex(middle.x, middle.z);
		quad.t2.b = CreateVertex(q.b.x, q.b.z);
		quad.t2.c = CreateVertex(q.c.x, q.c.z);

		quad.t3.a = CreateVertex(q.d.x, q.d.z);
		quad.t3.b = CreateVertex(middle.x, middle.z);
		quad.t3.c = CreateVertex(q.c.x, q.c.z);

		quad.t4.a = CreateVertex(q.a.x, q.a.z);
		quad.t4.b = CreateVertex(middle.x, middle.z);
		quad.t4.c = CreateVertex(q.d.x, q.d.z);

		if (!Triangles)
		{
			Triangles = new TriangleList;
			triangles_begin = Triangles;
			Triangles->t = quad.t1;
		}
		else
		{
			triangles_node = new TriangleList;
			triangles_node->t = quad.t1;
			Triangles->next = triangles_node;
			Triangles = triangles_node;
		}
		triangles_node = new TriangleList;
		triangles_node->t = quad.t2;
		Triangles->next = triangles_node;
		Triangles = triangles_node;

		triangles_node = new TriangleList;
		triangles_node->t = quad.t3;
		Triangles->next = triangles_node;
		Triangles = triangles_node;

		triangles_node = new TriangleList;
		triangles_node->t = quad.t4;
		Triangles->next = triangles_node;
		Triangles = triangles_node;

		quads = quads->next;

		triangle_count += 4;
	}
	Triangles = triangles_begin;

	//delete quadlist to save memory
	delete quads;
	quads = NULL;
}

Gruß Jens