Discussion :

[boboss123]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[Grulim]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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++);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Grulim]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[boboss123]

ok merci

[Gui13]

Mon avis:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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:

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.

[boboss123]

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

=> oui effectivement, c'est la meilleur solution