Die Klasse ist eine Zahl und besteht aus einer Liste. Jede Ziffer der Zahl ist ein Element der Liste.

Ich habe nun z.b. die Funktion "Add" für die Addition. Diese liefert als Wert halt diese Klasse zurück.

_twTlz twTlzAdd( _twTlz zahl1, _twTlz zahl2 ){

		_twTlz temp;

		zahl1.pos = zahl1.end;
		zahl2.pos = zahl2.end;

		int uebertrag = 0;
		int max = twTlzMax_laenge( &zahl1, &zahl2 );

		/* solange beide zahlen an pos noch eine ziffer haben */
		while(zahl1.pos != NULL && zahl2.pos != NULL){

			if(zahl1.pos->ziffer + zahl2.pos->ziffer + uebertrag >= 10){
				temp.insert_front( (zahl1.pos->ziffer + zahl2.pos->ziffer + uebertrag)%10 );
				uebertrag = 1;				
			}else{
				temp.insert_front( zahl1.pos->ziffer + zahl2.pos->ziffer + uebertrag );
				uebertrag = 0;
			}

			zahl1.pos = zahl1.pos->prev;
			zahl2.pos = zahl2.pos->prev;
		}

		/* solange min eine der zahlen noch eine ziffer an pos hat */
		while( zahl1.pos != NULL || zahl2.pos != NULL ){

			if(zahl1.pos == NULL){
				if(zahl2.pos->ziffer + uebertrag >= 10){
					temp.insert_front( (zahl2.pos->ziffer + uebertrag)%10 );
					uebertrag = 1;
				}else{
					temp.insert_front( zahl2.pos->ziffer + uebertrag );
					uebertrag = 0;
				}
				zahl2.pos = zahl2.pos->prev;
				continue;
			}

			if(zahl2.pos == NULL){
				if(zahl1.pos->ziffer + uebertrag >= 10){
					temp.insert_front( (zahl1.pos->ziffer + uebertrag)%10 );
					uebertrag = 1;				
				}else{
					temp.insert_front( zahl1.pos->ziffer + uebertrag );
					uebertrag = 0;
				}			
				zahl1.pos = zahl1.pos->prev;
				continue;
			}

		}
		/* pruefen ob am ende uebertrag existiert */
		if(zahl1.pos == NULL && zahl2.pos == NULL){
			if(uebertrag == 0) return temp;
			else {
				temp.insert_front( 1 );
				return temp;
			}
		}

		return temp;

	}

In der main addiere ich testweise auf eine x-Beliebige Zahl eine x-beliebige andere Zahl z.b. 1000000 auf.

for(int i=1;i!=1000000;i++) zahl1 = twTlzAdd(zahl1, zahl2);

Mein Physikalischer Speicher geht auf 100% voll. Wenn ich das z.b. mit 10000000
mache, stürtzt mein PC ab.

Eigentlich sollten nach jeder Addition alle Temporären Daten gelöscht sein und nur zahl1 überschrieben sein, was dann eigentlich keinen zursätzlichen Speicheraufwand haben sollte. Irgendwas jedoch wird aufjedenfall nicht gelöscht und ich weiß nicht was und warum.

Ich habe Testweise zwei Statics mitlaufen lassen für erstellte Objekte und gelöschte. Die Zahl der gelöschten Objekte ist immer um x4 größer als die Erstellten. Das kann doch auch nicht stimmen. Den Inkrementierer habe ich btw in Konstruktor und Destruktor gepackt.

mfg Jan

Falls die Klassen Methoden auch benötigt werden:

/* Metoden */

		int insert_front( int new_ziffer ){

			twTlz *newItem = (twTlz*) malloc(sizeof(twTlz));
			if(newItem==NULL) return 0;							/* ERROR */

			if(anf==NULL){

				anf=newItem;
				end=newItem;
				pos=newItem;
				newItem->prev = NULL;
				newItem->next = NULL;
			}else{

				newItem->prev = NULL;
				newItem->next = anf;
				anf->prev = newItem;
				anf=newItem;		
			}
			newItem->ziffer = new_ziffer;		
			laenge++;

			return 1;
		}

		int insert_back( int new_ziffer ){

			twTlz *newItem = (twTlz*) malloc(sizeof(twTlz));
			if(newItem==NULL) return 0;							/* ERROR */

			if(anf==NULL){

				anf=newItem;
				end=newItem;
				pos=newItem;
				newItem->prev=NULL;
			}else{

				newItem->prev = anf;
				end->next = newItem;
				end = newItem;		
			}
			newItem->next = NULL;
			newItem->ziffer = new_ziffer;		
			laenge++;

			return 1;
		}

		int ausgeben(){
			pos=anf;
			while(true){
				if(pos==NULL){
					pos = end;
					return 1;
				}

				std::cout << pos->ziffer;
				pos=pos->next;
			}

		}

		int step(){
			if(pos==NULL) return 0;
			prev=pos;
			pos=pos->next;
			return 1;
		}

		int back(){
			if(pos->prev==NULL) return 0;
			pos = pos->prev;
			prev = pos->prev;

			return 1;
		}

		int del(){

			pos=anf;
			while(step()){
				if(prev==NULL) return 0;
				free(prev);
			}
			return 1;
		}

		/* Destruktor */

		~_twTlz(){
			b++;
		}

	};

	int _twTlz::a = 0;
	int _twTlz::b = 0;

am Ende der Main lösche ich auch zahl1 und zahl2 mit del( );

Ausserdem: In C++ verwendet man new und delete (bzw new[] und delete[]), aber seit C++11 eigentlich in aller Regel nur noch in Verbindung mit smart pointer (unique_ptr und shared_ptr, dann braucht es kein explizites delete mehr) und in Deinem Fall waere ein std::vector sicherlich am Besten geeignet, so dass Du auch kein new und delete mehr brauchst.

Die Ressource ist bei dir Speicher.

P.S.: Wieso malloc statt new? Wieso die static-Variablen? Wieso short als Datentyp? Insgesamt: Einige fragwürdige Designentscheidungen, die nach voreiliger (und falscher) Optimierung aussehen. Erst einmal sauber programmieren und testen, dann Mikrooptimierungen einbauen (und zwar solche, die auch funktionieren!).

Das Speicherleck dürfte daher zustandekommen, dass du für " _twTlz temp; " vergessen hast, del() aufzurufen (bzw. aus unerfindlichen Gründen del() nicht im Destruktor aufrufst).

Der short int ist einfach daraus entstanden, dass ich den Speicherbedarf (wenn schon irgendwo n Speicherleck ist) klein halten will.

[quote="mmmalloc"]ganz viel malloc, niemals free - das kann, zumindest auf Dauer, nicht gut gehen.
quote]

ich habe eine funktion, die die ganze Liste durchgeht und jedes Element wieder freed. Wie gesagt, am ende der Main rufe ich für beide objekte die del() funktion auf.

Btw benutze ich malloc 2 mal im ganzen Code. Wo siehst du ganz viel malloc?

Ich würde halt scon gerne wissen, wo nun mein Leck ist. Das Programm läuft richtig, halt nur mit der unschönen Eigenschaft, dass es den Speicher füllt.

Das ist die kryptischte und langsamste Implementierung eines Bigints, die ich je gesehen habe. Jedes Detail ist schlecht und das Grunddesign ist ein Performancekiller.

Das Speicherleck dürfte daher zustandekommen, dass du für " _twTlz temp; " vergessen hast, del() aufzurufen (bzw. aus unerfindlichen Gründen del() nicht im Destruktor aufrufst).

ich hatte del() schon im destruktor, aber dann kommt es zur heapzerstörung.

wie kann ich temp mit del() löschen? Hab ich auch schon gedacht, aber ich muss das temp ja zurückgeben. wenn ich das danach noch del() will, kommt es ja gar nicht zum delete, weil return aus der funktion führt.

Der short int ist einfach daraus entstanden, dass ich den Speicherbedarf (wenn schon irgendwo n Speicherleck ist) klein halten will.

Und es ist völlig falsch. Du erreichst nicht im geringsten, was du damit vor hast und das Vorhaben geht am Problem vorbei.

ich habe eine funktion, die die ganze Liste durchgeht und jedes Element wieder freed. Wie gesagt, am ende der Main rufe ich für beide objekte die del() funktion auf.

Und zwar machst du es falsch. Mach es so wie vorgeschlagen dann kann so ein Fehler gar nicht auftreten, weil zu jedem malloc automatisch(!) ein passendes free kommen würde.

Btw benutze ich malloc 2 mal im ganzen Code. Wo siehst du ganz viel malloc?

Es geht nicht um das Vorkommen im Code, sondern darum, wie oft und worauf es aufgerufen wird. Was bei dir offensichtlich falsch ist, was kein Wunder ist, da du alles von Hand machst und selber nicht mehr durchblickst. Lass den Compiler für dich arbeiten! Ein Computer ist dafür gebaut, den Durchblick zu behalten.

Ich würde halt scon gerne wissen, wo nun mein Leck ist. Das Programm läuft richtig, halt nur mit der unschönen Eigenschaft, dass es den Speicher füllt.

heulsuse schrieb:

Das Speicherleck dürfte daher zustandekommen, dass du für "_twTlz temp;" vergessen hast, del() aufzurufen (bzw. aus unerfindlichen Gründen del() nicht im Destruktor aufrufst).

ich hatte del() schon im destruktor, aber dann kommt es zur heapzerstörung.

Dann hast du noch mehr Fehler drin. Du hast den Überblick verloren.

wie kann ich temp mit del() löschen?

Wie schon oft im Thread gesagt: Gar nicht. Es ist zwar möglich, aber tu es nicht! Du kommst dabei nur selber durcheinander. Nutze die Mittel der Sprache! Mit Smartpointern kannst du gar nicht mehr versehentlich Speicherlöcher bauen, bloß noch durch absichtlichen Missbrauch. Wenn du die Standardbibliothek benutzt, dann brauchst du dafür nicht einmal eine Zeile programmieren und der gesamte Code fällt auf wenige Zeilen zusammen.

heulsuse schrieb:

Das ist die kryptischte und langsamste Implementierung eines Bigints, die ich je gesehen habe. Jedes Detail ist schlecht und das Grunddesign ist ein Performancekiller.

Das Speicherleck dürfte daher zustandekommen, dass du für " _twTlz temp; " vergessen hast, del() aufzurufen (bzw. aus unerfindlichen Gründen del() nicht im Destruktor aufrufst).

ich hatte del() schon im destruktor, aber dann kommt es zur heapzerstörung.

wie kann ich temp mit del() löschen? Hab ich auch schon gedacht, aber ich muss das temp ja zurückgeben. wenn ich das danach noch del() will, kommt es ja gar nicht zum delete, weil return aus der funktion führt.

Ok, ich habe falsch geguckt.

Deine Schleife macht im Prinzip

for(int i=1;i!=1000000;i++) {
  ehemals_temp = twTlzAdd(zahl1, zahl2);
  zahl1 = ehemals_temp;
}

Das Problem ist, dass der Wert, der vorher in zahl1 stand, nicht gelöscht wird.

Der Fix wäre also:

for(int i=1;i!=1000000;i++) {
  ehemals_temp = twTlzAdd(zahl1, zahl2);
  zahl1.del();
  zahl1 = ehemals_temp;
}

Der Fix wäre also:

for(int i=1;i!=1000000;i++) {
  ehemals_temp = twTlzAdd(zahl1, zahl2);
  zahl1.del();
  zahl1 = ehemals_temp;
}

Das ist die Lösung. Es funktioniert. Vielen Dank für den Hinweis. Super wäre noch wenn jemand erklären könnte, was bei der Zuweisung passiert?

Ich dachte zahl1 = zahl2 würde zahl1 überschreiben, sodass kein speicher verloren geht. Anscheind ist das nicht so. Was passiert da?

void operator= (_twTlz zahl){

			del();
			laenge = zahl.laenge;

			anf = zahl.anf;
			pos = zahl.pos;
			end = zahl.end;
			prev = zahl.prev;
		}

Dann kann ich auch meine erste (vorher Fehlerhafte) Schleife verwenden. Ich bedanke mich für die viele Hilfe hier. cucu