da sind 3 versch. Funktionen die dieselben Ergebnisse liefern - die Aufgabe ist es einfach die Strings zu kopieren. als Beispiele gegeben und der Autor meint
die arbeiten wie strcpy
Er meint also: Zeigerversionen sind der Index vorzuziehen, da sie schneller sind. Hier mal die Beispiele:

1:
Indexversion von strcpy():

void strcpy1( char s1[], char s2[])
{
	int i;
	for( i = 0; s2[i] != '\0'; ++i)
		s1[i] = s2[i];
	s1[i] = '\0';
}

2:
Zeigerversion 1 von strcpy():

void strcpy2( char *s1, char *s2)
{
	for( ; *s2 != '\0'; ++s1, ++s2)
		*s1 = *s2;
	*s1 = '\0';
}

3:
Zeigerversion 2 von strcyp():

void strcpy3( char *s1, char *s2)
{
	while( (*s1++ = *s2++) != '\0' );
}

4:
die gewöhnliche standard-strcpy

strcpy( ziel, quelle);

Jetzt habe ich sie mal mit Stoppuhr getestet mit 80000000 Wiederholungen:

Die Ergebnisse:

1: 2.27148 Sekunden
2: 2.30907 Sekunden
3: 2.58862 Sekunden
4: 2.11555 Sekunden

Es ist also genau andersrum - die Zeigerversionen sind nicht schneller als die Indexversion. Zeigerversion 3 ist das langsamste - wieso? Und wieso ist die standard-strcpy nochmal um 0.2 Sekunden schneller das erste? Wie schaffen die das?

wenn ich die nummer von case vertausche, sind die geschwindigkeiten ganz anders

dann ist strcpy (standard-strcpy) viel langsamer als strcpy3 (Zeigerversion)

[cpp]int a;
cin >> a;
cout << "Gedrueckt: " << a << endl;
cin.get();

QueryPerformanceCounter(&start_ticks);
QueryPerformanceFrequency(&frequenz);

// ... hier irgendwas machen ...

char ziel[30], quelle[] = "Ein String";

int repeats = 80000000;
for (int i = 0; i < repeats; i++) {

switch( a ) {
case 1:
strcpy1( ziel, quelle);
break;
case 2:
strcpy2( ziel, quelle);
break;
case 3:
strcpy3( ziel, quelle);
break;
case 4:
strcpy( ziel, quelle);
break;
default:
break;
}
}[/cpp]

Nur wenn ich die nummer 3 und 4 vertausche - verstehe ich nicht?
Nummer 4 ist immer das schnellste egal welche funktion ich da nehme?????? Wieso liegt das jetzt an case?

deine tests habe so einiges an unperformanten dingen, z.b. switch im inneren der schleife, du wolltest im switch die schleifendurchlaeufe machen!!!

char ziel[30], quelle[] = "Ein String";

int repeats = 80000000;

	switch( a ) {
		case 1:
			for (int i = 0; i < repeats; i++)
				strcpy1( ziel, quelle);
			break;
		case 2:
			for (int i = 0; i < repeats; i++)
				strcpy2( ziel, quelle);
			break;
		case 3:
			for (int i = 0; i < repeats; i++)
				strcpy( ziel, quelle);
			break;
		case 4:
			for (int i = 0; i < repeats; i++)
				strcpy3( ziel, quelle);
			break;
		default:
			break;
	}

ergebnisse:

2,8
2,3
2,3
2,3

ok alles klar

laut intel und amd sind die arrayversionen schneller, besonders unrolled. laut arm sind die pointerversionen schneller (ich hab beides auch richtig gebenched sodass ich das bestaetigen kann).

deine tests habe so einiges an unperformanten dingen, z.b. switch im inneren der schleife, du wolltest im switch die schleifendurchlaeufe machen!!!

was ist arm?

1.85
2.2
2.3
2.3

stimmt array ist doch schneller.

du solltest nicht mit einer Stopuhr messen. µBenchmarks richtig hinzubekommen ist nicht leicht!

rüdiger schrieb:

arm => http://de.wikipedia.org/wiki/ARM-Architektur

du solltest nicht mit einer Stopuhr messen. µBenchmarks richtig hinzubekommen ist nicht leicht!

wie? also ich benütz immer

#include <windows.h>

LARGE_INTEGER start_ticks, ende_ticks, frequenz;

double tick_diff     = 0;
start_ticks.QuadPart = 0;
ende_ticks.QuadPart  = 0;

QueryPerformanceCounter(&start_ticks);
QueryPerformanceFrequency(&frequenz);

// ... Hier Funktionen testen

QueryPerformanceCounter(&ende_ticks);

// benötigte zeit berechnen
tick_diff = ((double) ende_ticks.QuadPart - (double) start_ticks.QuadPart) / frequenz.QuadPart;
cout << tick_diff << endl;

kommen doch immer milisekundengenaue ergebnisse oder was ist nicht leicht? oder du meinst , es hängt immer so sehr von sprüngen ab z.b. funktionssprünge, if-anweisungen usw dass es nicht immer das richtige ergebnis rauskommt?

Und letzten Endes hängen solche Messungen stark vom Zielrechner ab. Auf meinen System z.B. sind die Pointer-Versionen im Schnitt 10% schneller als die Index-Versionen.

das ganze wirkt stark wie premature optimizing...

Wiki hab ich schon durchgelesen aber keine Beispiele

Messem mit QueryPerformanceCounter ist im Übrigen schon OK, man muss halt mehrere Messungen machen, und ein wenig aufpassen dass man im Hintergrund nix laufen hat was grob dazwischenfunken könnte.

könnt ihr mir einen Profiler empfehlen? Wo find ich sie oder wie mach ich das?

Bei AMD gibts einen kostenlosen Profiler Und in der GCC ist glaub ich auch einer dabei.

Angenommen ich bekomme dann über den Profiler raus dass A schneller ist, aber alle Messungen die ich mit QueryPerformanceCounter gemacht habe zeigen dass B schneller ist, dann verlasse ich mich auf QueryPerformanceCounter, nicht auf der Profiler.

----

Einen Profiler verwende ich vielleicht um rauszubekommen wo ich noch was optimieren kann, aber sicher nicht um zu entscheiden welche Version einer Funktion schneller ist. Schliesslich läuft das Programm auf dem Zielsystem ja auch nicht mit dem Profiler, sondern "frei", also genau so wie man es mit QueryPerformanceCounter messen kann.

Solche Messungen eine "Schätzung" zu nennen halte ich für Unsinn.