char *ret_str(int *array, size_t ln)
{
	char *cstring = new char[16];

	for(int i = ln; i > 0; i--)
		cstring[ln-i] = ret_char(array[i-1]);

	return cstring;
	delete [] cstring;
}

void get_nmb(int limes, char* str)
{
	size_t ln = strlen(str);
	char *cstring;
	int array[ln];

	for(int i = 0; i < ln; i++)
		array[i] = 0;

	while (time (0) <= stamp);  // Aktuelle Sekunde fertig abwarten
	while(true/*time (0) <= stamp + 1*/)
	{
	std_ops++;

		cstring = ret_str(array, ln);
		//cout<<"vergleiche: "<<cstring<<" mit string: "<<str<<endl;

		if(strcmp(cstring, str) == 0)		//funktion beenden wenn passwd übereinstimmt
		{
			cout<<"gefunden: "<<cstring<<endl;
			break;
		}

		int i = 0;
		for(; array[i] == limes; ++i)		//rücksetzen der ziffern
		{
			array[i] = 0;
		}
		++array[i];
	}
}

ich habe die erfahrung gemacht, dass wenn ich

cout<<"vergleiche: "<<cstring<<" mit string: "<<str<<endl;

auskommentiere, dass programm satte 7-8x schneller läuft^^ das erinnert mich an meinem grafischen tr der auch langsamer lief je mehr er ausgeben musste LOL

naja nun zu meinem problem: wenn ich das cout auskommentiere dass läuft das prog bei längeren ln (>5) ne weile, der rechner wird ziemlich lahm, also der mauszeiger ruckelt und nach ca 30s bricht das programm ab.

terminate called after throwing an instance of 'St9bad_alloc'
  what():  St9bad_alloc
/bin/sh: line 1: 16919 Abgebrochen             ./testchecker
Betätigen Sie die Eingabetaste, um fortzufahren!

warum bricht das prog ab? kann ich eine ausgabe machen, die schneller als die bisherige ist?

char *ret_str(int *array, size_t ln)
{
    char *cstring = new char[16];///< Dieser speicher wird reserviert aber nie mehr freigegeben

    for(int i = ln; i > 0; i--)
        cstring[ln-i] = ret_char(array[i-1]);

    return cstring;
    delete [] cstring;///<Wird nie mehr aufgerufen, da die FUnktion bereits zurückgekehrt ist
}

Teste die Laufzeit doch mal mit vollständiger Ausgabe, die Du aber a) in eine Datei und b) nach /dev/null umleitest...

string ret_str(int *array, size_t ln)
{
	char *cstring = new char[ln];

	for(int i = ln; i > 0; i--)
		cstring[ln-i] = ret_char(array[i-1]);
	string str = cstring;
	delete [] cstring;

	return str;
}

so umgeändert dass das speicherleck geschlossen ist. das prob ist nur dass nun ziemlich oft der cstring zu einem string umkopiert wird nur um diesen zurückzuliefern...

wenn ich das ganze einfach so gestalte

char *ret_str(int *array, size_t ln)
{
	char cstring[ln];

	for(int i = ln; i > 0; i--)
		cstring[ln-i] = ret_char(array[i-1]);

	return cstring
}

dann bekomme ich einen buchstabensalat:
statt:
bsp:

vergleiche: aafjbs mit string: hausba
vergleiche: aafjbt mit string: hausba
vergleiche: aafjbu mit string: hausba

sieht dass dann so aus:

vergleiche: aaab+% mit string: hausba
...
vergleiche: aafj*& mit string: hausba

string ret_str_quick(int *array, size_t ln)
{
string cstring;

for(int i = ln; i > 0; i--)
cstring += ret_char(array[i-1]);

return cstring;
}

thx für die hilfe!

andererseits frag ich mich, warum du überhaupt nen cstring/string zurückgeben willst. hau doch den vergleich (strcmp) gleich mit in die funktion und returniere nur nen bool.

ich habe jetzt die funktion in die große schleife gepackt, mit new allokiert und schön deleted. jetzt muss ich nur die konsolenausgabe beschleunigen, denn die begrenzt das ganze auf ca 1 100 000 operationen, dabei wären ca 24 000 000 pro zeiteinheit möglich!! das ist nicht übel.

ok, ich habe mich etwas geirrt... das ganze mit den strings ist das mit abstand langsamste.

ich habe jetzt die funktion in die große schleife gepackt, mit new allokiert und schön deleted. jetzt muss ich nur die konsolenausgabe beschleunigen, denn die begrenzt das ganze auf ca 1 100 000 operationen, dabei wären ca 24 000 000 pro zeiteinheit möglich!! das ist nicht übel.

Das ist auch nicht verwunderlich, da die Ausgabe auf die Konsole sehr viel aufwändiger ist als deine einfache und sehr kurze Berechnung.

falls mein Programm einfach abstürzt, verwende ich GDB,
zum Checken auf Memory-Leaks nehm ich MMGR.
Im Prinzip sind das Makro-Definitionen, die Funktionen aufrufen, die
Speicheranforderungen loggen. Kostet natürlich Performance und muss in jeder
Datei inkludiert werden. Ich includier immer ne Config-Datei, die mir
das nur includiert, wenn das Makro MMBR_DEBUG gesetzt ist.
So kann man das immer zwischendurch mal zum testen reinmachen.
Allerdings gibt es (sehr) wenige Ausnahmen (statische Objekte - unter
bestimmten Bedingungen - frag mich nicht, wann genau), wo es nicht funct.

EDIT: Naja nen Link wäre auch praktisch
http://www.koders.com/cpp/fidF4248EED693AB98956E4AF0D594164BCCAB31406.aspx
http://www.koders.com/c/fidBAB9E56219A304846FAA7A14102FD65103F1CB3F.aspx

Gruß,
CSpille