parcourir un tableau

Version imprimable

21/07/2010, 09h17
boboss123

parcourir un tableau
Bonjour,

Pour parcourir un tableau, il existe plusieurs méthodes :
Code:

1 2 3 4 5 6 7 8 9 int myTab[1000] = {......}; int *ptInt; // pointeur int cpt = 1000; ptInt = myTab; while(cpt){ printf("%d\n", *ptInt); cpt--; }
Code:

1 2 3 4 5 6 int myTab[1000] = {......}; int i; for(i=0; i<1000: i++){ printf("%d\n", myTab[i]); }
=> pouvez-vous (m'expliquer) me dire quelle est la méthode qui est la plus rapide ? il existe d'autres méthodes plus rapides ?
21/07/2010, 09h54
Grulim
Citation:
Envoyé par boboss123

Bonjour,

Pour parcourir un tableau, il existe plusieurs méthodes :

Code:

1 2 3 4 5 6 7 8 9 int myTab[1000] = {......}; int *ptInt; // pointeur int cpt = 1000; ptInt = myTab; while(cpt){ printf("%d\n", *ptInt); cpt--; }
Ce code affiche mille fois le 1er élément de ton tableau.
Essaie plutot ceci:
Code:

1 2 3 4 5 6 7 8 int myTab[1000] = {......}; int *ptInt; // pointeur int cpt = 1000; ptInt = myTab; while( cpt-- ){ printf("%d\n", *ptInt++); }
Citation:
Code:

1 2 3 4 5 6 int myTab[1000] = {......}; int i; for(i=0; i<1000: i++){ printf("%d\n", myTab[i]); }

=> pouvez-vous (m'expliquer) me dire quelle est la méthode qui est la plus rapide ? il existe d'autres méthodes plus rapides ?
Ca dépend de ton compilo et du niveau d'optimisation, mais sur à peine 1000 éléments, je ne pense pas qu'il y ait une différence sensible.

J'ai modifié ton exemple et les différences commence à apparaitre avec 1000000 d'éléments... et encore sans optimisation...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
/* gcc -O0 -g3 -Wall -c -fmessage-length=0 -omain.o ..\main.c
 * gcc -otest_c.exe main.o
 */
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
 
 
#define MAX_ELEMENT 1000000
 
void test3()
{
	char buf[40];
	int* myTab = (int*)malloc(MAX_ELEMENT * sizeof(int));
	int *ptInt;
	int cpt = MAX_ELEMENT;
 
	ptInt = myTab;
	while( cpt-- )
	{
	    sprintf(buf,"%d\n", *ptInt++);
	}
	free(myTab);
}
 
void test4()
{
	char buf[40];
	int* myTab = (int*)malloc(MAX_ELEMENT * sizeof(int));
	int i;
 
	for(i=0; i<MAX_ELEMENT; i++)
	{
	   sprintf(buf,"%d\n", myTab[i]);
	}
	free(myTab);
}
 
int main()
{
	clock_t tp = clock();
	test3();
	printf("test3=%f s.\n", (float)(clock() - tp)/CLOCKS_PER_SEC);
	tp = clock();
	test4();
	printf("test4=%f s.\n", (float)(clock() - tp)/CLOCKS_PER_SEC);
	return 0;
}

21/07/2010, 12h37
boboss123

ok merci
22/07/2010, 11h32
Gui13
Mon avis:
Code:

1 2 3 4 5 while( cpt-- ) // une opération (--) { sprintf(buf,"%d\n", *ptInt++); // 2e opération (++) }
-> Deux opérations d'ajout/soustraction
Code:

1 2 3 4 5 for(i=0; i<MAX_ELEMENT; i++) // 1 opération { sprintf(buf,"%d\n", myTab[i]); }
-> 1 seule opération d'ajout

On a moins d'opérations dans la deuxième boucle, du coup elle sera plus rapide.
Chez moi:

Citation:

test3=0.141000 s.
test4=0.109000 s.

Dans tous les cas, je pense que ça ne devient évident qu'à partir d'un nombre élevé d'itérations car les "++" et les "--" vont opérer sur une variable stockée dans un registre. Les accès mémoire, eux, sont plus longs et effacent totalement ce petit lag d'une opération en plus.

Pour en être sûr faudrait regarder l'assembleur.
22/07/2010, 12h47
boboss123

Citation:

Envoyé par Gui13

Pour en être sûr faudrait regarder l'assembleur.

=> oui effectivement, c'est la meilleur solution