Salut,

Selon vous, quelle est la forme la plus optimisée ?

short i = nb;
while ( i--){
// blabla
}

/******************************/

for ( short i = 0; i < nb; i++)

/******************************/

for ( short i = ( nb-1); i > = 0; i--)

Je me disais que avec FOR, le compilateur aurait la bonne idée de stocké " i" dans un des registres du processeur. Vroi ou faux ?

Cette question n´a raison d´etre que si tu programme sur un processeur ( tres) lent.
Si c´est le cas, laisse tomber le C++ ( comme le for de ton exemple) et fait le en C.
Pour ta question, le for me semble plus lisible, mais c´est une question de gout.

register int i;
for( i = 0; i<nb; i++) { }

le mot register demande explicitement au compilateur de mettre la variable dans un registre. Mais en general le compilo est assez intelligent pour le faire lui meme sans demande explicite.

Sur quel machine devrait tourné ce code ?

Si tu veux tout savoir, je suis entrain d´implenter Rijndael. Et pour ce genre d´application, le but c´est d´être le plus rapide possible.

Parce que des boucle, il n´y en aura pas une, mais des dixaines de millers à la seconde... lol...

ca depend de ton compilateur...

tu n´a qu´a regardé le code source assembleur généré par ton compilateur ( facile avec Visual C)

ou tu codes carréement en assembleur tes boucles.
comme ca, tu es sur du resultat :p

Euh... On va dire que ej en suis pas très assembleur... lol...

J´ai VC++ 6

Dans ce cas, si c´est un compilateur recent, il n´y a pas de questions a ce possées, c´est le compilateur qui fera les optimisations. Il me semble bien que le mot clée ´register´ n´est maintenant plus pris en compte.

for est bcp plus rapide

for est bcp plus rapide

C´est neligable je pense.

FOR est effectivement plus performant ( un MOV en moins à chaque itération).

8: int a = 0;
00401048 mov dword ptr [ebp-4],0
9:
10: for ( int i = 0; i < 4; i++)
0040104F mov dword ptr [ebp-8],0
00401056 jmp main+31h ( 00401061)
00401058 mov eax,dword ptr [ebp-8]
0040105B add eax,1
0040105E mov dword ptr [ebp-8],eax
00401061 cmp dword ptr [ebp-8],4
00401065 jge main+3Fh ( 0040106f)
11: a = i;
00401067 mov ecx,dword ptr [ebp-8]
0040106A mov dword ptr [ebp-4],ecx
0040106D jmp main+28h ( 00401058)

//--------------------------------------------

8: int a = 0;
00401048 mov dword ptr [ebp-4],0
9: int i = 4;
0040104F mov dword ptr [ebp-8],4
10: while ( i--)
00401056 mov eax,dword ptr [ebp-8]
00401059 mov ecx,dword ptr [ebp-8]
0040105C sub ecx,1
0040105F mov dword ptr [ebp-8],ecx
00401062 test eax,eax
00401064 je main+3Eh ( 0040106e)
11: a = i;
00401066 mov edx,dword ptr [ebp-8]
00401069 mov dword ptr [ebp-4],edx
0040106C jmp main+26h ( 00401056)

Merci pour la confirmation, c´est donc effectivement negligable.

combien de fois ton programme va-t´il passer dans ton for?
un while(1) d´une boucle principale de jeu a fortement interet a etre remplacée par un for(;;)

Avant d´affirmer cela, trouve combien coute un MOV supplementaire.
Je te garantis qu´un code lisible sans reflechir vaux bien un MOV en +

bah ecoute je te conseille de faire un test simple, tu fais

int main() { int i; for ( i = 0; i > = 0; i++) ; }

et

int main() { int i; i = 0; while ( i > = 0) i++; }

tu lances et tu chronometres et on en reparle

Ton test ne sert à rien car il est plutôt rare ( et pas très malin) d´utiliser une boucle vide dans un programme !

Tu sais peut être pas mais des optmisations se font lorque une boucle contient d´autres instructions / appels de fonction etc...

Donc un test comme celui là n´a aucun intérêt

( de plus tu oublies d´initialiser ton i dans le for, ce qui peut grandement fausser les résultats de ton test ( si par exemple i démarre à -1 par ex . . mais j´ose espérer qu´il ne s´agit que d´un oubli de ta part)

oops autant pour moi j´ai mal lu l´init

( xxx@solaria 63)time . /boucle_while ; time boucle_for
6.476u 0.004s 0:06.49 99.6% 0+0k 0+0io 0pf+0w
6.471u 0.000s 0:06.48 99.8% 0+0k 0+0io 0pf+0w

( xxx@jcvd 48)time . /boucle_while ; time boucle_for
10.642u 0.000s 0:10.75 98.9% 0+0k 0+0io 0pf+0w
10.576u 0.000s 0:10.66 99.1% 0+0k 0+0io 0pf+0w

( xxx@min 43)time . /boucle_while ; time boucle_for
55.88u 0.00s 0:55.91 99.9%
55.87u 0.00s 0:55.90 99.9%

solaria etant une station alpha, jcvd un i386 et min une sun

Sinon les boucles vides ca existe bel et bien.. comment veux tu traiter tes callbacks autrement?

je n´ai qu´un mot à dire :

ouais bon la sun elle a pas aimé je crois :p

Ca y est ! J´ai fait le test en incrementant un compteur dans chacunes des boucles for et while.
Resutat, pour 4294967295 incrementation, for prend une seconde ( environ) de plus.
Donc, faut pas te casser la tete la dessus, comme le dit Altonfrere c´est le reste du code qu´il faut optimiser.