lstrcat zu langsam?

Hallo.

Ich habe ein kleines Preformance-Problem:
Ich lese aus einem ListView Text aus und will alle Items + SubItems in einem String abspeichern. Dazu habe ich 2 in einander verschachtelte Schleifen um Spalten und Zeilen nacheinander abzugrasen. Die Strings hänge ich mit einem

lstrcat(pszZiel, pszItemText);
lstrcat(pszZiel, TEXT("\t");

hinten dran (den Tab brauche ich auch). Allerdings dauert das bei 8000 Zeilen und 6 Spalten ca. 5 Minuten. Ich habe das ausgemessen die eigentliche Bremse ist das lstrcat. Ich habe auch schon folgendes versucht:

lstrcpy(&pszZiel[lstrlen(pszZiel)], pszItemText);
pszZiel[lstrlen(pszZiel)] = '\t';

Allerdings hat es keinen Geschwindigkeitsvorteil gebracht.
wsprintf kann ich leider nicht benutzen, da es eine Längenbegrenzung der Parameter zu geben scheint. Und sprintf wird vieeeeel langsamer, so daß ich es gar nicht durchlaufen lassen kann.

Hat jemand eine Idee wie ich das anders lösen kann?

Vielen Dank im Voraus.
Gruß, kRUSty

Hallo.

Es scheint so zu sein, daß je länger der String, an den man anhängen will, umso länger benötigt die lstrcat-Funktion. Dadurch, daß ich kurze Strings 8000*6 Mal anhänge wird am Ende ein rieeeeesen String. Das gleiche Problem scheint auch mit der Funktion lstrlen aufzutreten (was ja schon logisch nachvollziehbar ist).
Also habe ich folgende Lösung ausprobiert:

long lLength = lstrlen(pszClipBoard);
	while(iZeile < iMaxZeile)
	{
		while(iSpalte < iMaxSpalte)
		{
                        //Funktion zum Auslesen eines Textes aus LV
			GetListViewItem(GetDlgItem(hwndParent, IDL_ERGEBNIS), iZeile, iSpalte, szItemText, sizeof(szItemText)-sizeof(TCHAR));

                        //Das Tab-Zeichen vor dem Anhängen anfügen
			lstrcat(szItemText, TEXT("\t"));

                        //Den String mithilfe eines Pointers auf
                        //das Ende des Ziels anhängen.
			lstrcpy(&pszClipBoard[lLength], szItemText);
                        //Länge aktualisieren
			lLength += lstrlen(szItemText);

			iSpalte++;
		}
		iZeile++;
		iSpalte = 0;
		lstrcpy(&pszClipBoard[lLength], TEXT("\n"));
		lLength++;
	}

Also einfach eine nebenbei laufender Counter für die Anzahl der Zeichen merken und den Pointer ans Ende zeigen lassen.

Habe das ganze mit einer Preformance-Klasse gemessen und bin von 208289 Msec (ca. 4 min) auf 240 MSec gekommen. Ist doch ein Unterschied, oder? Da werden sich meine User freuen.

Gruß,
kRUSty

supertux

Tut mir leid, ich kann da dir nicht helfen, das ist der ANSI C Forum! Keine Ahnung, was lstrcpy & Co. macht. Frag mal lieber im WinAPI Forum, da werden sie dir bestimmt mehr helfen.

Shade Of Mine

kRUSty schrieb:

Es scheint so zu sein, daß je länger der String, an den man anhängen will, umso länger benötigt die lstrcat-Funktion.

strcat wäre naiv so zu implementieren:

void strcat(char* str, char* app)
{
  while(*str)
    ++str;

  while(*app)
  {
    *str=*app;
    ++str; ++app;
  }
}

oder ganz kurz:

void strcat(char* str, char* app)
{
  str+=strlen(str);
  strcpy(str, app);
}

Logisch dass es langsamer als laenge merken und strcpy ist
wenn du die laenge von app auch kennst, wäre memcpy sogar noch einen tick besser...