C++ Memory Leak bei liste

[chubbchubb]

Hey Ho Digedi

Also ich bin gerade ein wenig am c++ lernen. Ich habe mir die Listen mal zu nutzen gemacht. Nun hab ich irgend was Vergessen und je länger das Programm läuft, desto mehr Memory braucht es.
Sehrwarschienlich hab ich was vergessen, weis aber nicht was. Da ich noch nicht ganz bei den verketteten listen durchsehe.

So sehen die ListenCode Teile aus

	Knoten listen_kopf;     // ist der Listenkopf
	
	Knotenptr ptrknoten;    // ist das einzufügende Element
	//Liste Initialisieren
	listen_kopf.next = NULL; // der Listenkopf hat keinen
                                         // Nachfolger
	
	ptrknoten = (Knotenptr) malloc (sizeof(Knoten));
	ptrknoten->next = NULL; // oder: (*ptrknoten).next = NULL;
	ptrknoten->asnake = a;
	ptrknoten->bsnake = b;
	listen_kopf.next = ptrknoten; //Element in liste aufnehmen

	.
	.
        .
	.

	ptrknoten= (Knotenptr) malloc (sizeof (Knoten)); // Speicher reservieren
			ptrknoten->asnake = a;
			ptrknoten->bsnake = b;

			ptrknoten->next = listen_kopf.next;		// neues Element zeigt auf
																	// Nachfolger vom Listenkopf
			listen_kopf.next = ptrknoten; // Listenkopf zeigt auf neues
			
			if(newcount == false) 
			{
			
				Knotenptr p;
				//p = NULL;
				p = listen_kopf.next; // Hilfszeiger zeigt auf den Nachfolger vom Listenkopf
				while (p->next != NULL)      // solange punkt vor dem ende Ende der Liste nicht erreicht
				{
					if(p->next->next == NULL) //übernächstepointer der liste NULL entspricht.
					{
						p->next = NULL; // letzte punkt wird auf null gesetzt
					}
					else
					{
						p = p->next;          // Zeiger um 1 Element weiterversetzen
					}
				}
			}
			else
			{
				score++;
			}
			
			newcount = false;

			
			ptrknoten = NULL;
			ptrknoten = (Knotenptr) malloc (sizeof(Knoten));
			ptrknoten->asnake = listen_kopf.asnake;
			ptrknoten->bsnake = listen_kopf.bsnake;

			ptrknoten->next = listen_kopf.next;
			
			while(ptrknoten->next != NULL)
			{
	
				x2 = ptrknoten->next->asnake;
				y2 = ptrknoten->next->bsnake;
				if(ptrknoten->next->next != NULL)
				{
					if(listen_kopf.next->asnake == ptrknoten->next->next->asnake && listen_kopf.next->bsnake == ptrknoten->next
						->next->bsnake)
					{
						MessageBox(NULL,"owned", "DirectInputKeyboard",MB_OK);
					}
				}
				ptrknoten = ptrknoten->next;
				//b = listen_kopf.bsnake;

				if(listen_kopf.next->asnake == zzx && listen_kopf.next->bsnake == zzy)
				{
					futter = true;
					newcount = true;
					
				}
				
				
			}

Wie gesagt ich bin es am lernen, also verurteilt mein Code nicht zu fest^^
zwischendurch kommen mal ein paar Punkte, die sind aber irrelevant, irgend welcher Code der nichts mit der Sache zu tun has war dort.
Genau an was liegt das Memory leak

oder wenn ihr es nicht auf anhieb seht, was muss man beachten das keine Memory Leaks entstehen

mfg Chubbchubb

 

[code404]

HY,

ein paar Anmerkungen, aber bestimmt nicht die Lösung:

1:

Knotenptr ptrknoten;    // ist das einzufügende Element
...

ptrknoten = (Knotenptr) malloc (sizeof(Knoten));

- Wenn du C++ programmierst new benutzen!
- Du hast die Variable doch schon angelegt und jetzt reservierst du noch mal Speicher dafür!
Du müsstest also aus "Knotenptr" ein Pointer machen.

Adee

 

[CodeFatal]

Moin moin zusammen,

Falls du zu dem Code oben kein Gegenstück hast und den Code oben mehrfach aufrufst, dann ist der Speicherhunger nicht verwunderlich Sorg mal für nen "delete" an geigneter Stelle.

Vielleicht hilft es dir, wenn du folgende Funktionen baust:
CreateElement -> allokiert Speicher und gibt zeiger darauf zurück
PutElementInList -> fügt Element in Liste ein
PutElementOutList -> holt ein Element aus der Liste
DestroyElement -> löscht allokierten Speicher

Wenn du die Funktionen dann in dieser Reihenfolge aufrufst, sollte sich der Speicherhunger in den Griff bekommen lassen :suspekt:

Soweit zur Theorie.

Wieso allokierst du eigentlich 2mal auf den selben Pointer und überschreibst dann auch noch den Next-Zeiger vom ListenKopf

Wenn ich das jetzt richtig sehe, dann solltest du den Teil vom 1. malloc bis zum 2.malloc einfach mal rausnehmen. Da du hier die Liste nicht aktuell hältst, kann das nur böse enden

Gruss Michael