Article complet: Pre/Postincrementation : Fight !

Introduction

Au long de vos divagations programmistiques vous avez certainement dû apercevoir du code qui resemblait à ça :
for(int i = 0; i < 1000; ++i);

Mais quelle est donc la différence entre i++ et ++i? C’est ce que nous allons essayer de décrouvrir au long de cet article avec un petit bonus final...

[Suite:]

Une version PDF de mon article est disponible ici si vous le souhaitez. (Petit soucie de provider, le PDF sera dispo directement la semaine prochaine...)

Une question d’objet temporaire

Tout d’abord, il faut considérer ces incrémentations dans la cadre d’une expression composée. Par exemple :

int tableau[50]; 
int i = 0; // Cas 1.  
tableau[i++] = 0;  
 
i = 0; // Cas 2. 
tableau[++i] = 0;

Quelle est la différence entre ++i et i++ ?

* i++ : Appelée post-incrémentation, l’expression envoie la valeur de i à la fonction, puis incrémente sa valeur de 1. Dans le cadre de notre exemple :
- tableau[0] vaudra 0.
- i vaudra 1 après l’affectation.

* ++i : Appelée pré-incrementation, l’expression incrémente de 1 la valeur de i puis envoie sa nouvelle valeur à la fonction. Dans notre exemple:
- tableau[1] vaudra 0.
- i vaudra 1.

Il y a donc une différence énorme de signification dans les deux écritures et il faudra faire attention au comportement de notre porgramme lorsqu’on manie ce genre d’expressions.
Quel est la différence entre ++i et i++ dans une expression simple ?

Dans un code du type :

int i = 0; 
++i; // i = i + 1; 
i++; // i = i + 1;

Les deux expressions ont exactement le même comportement et ne font qu’incrémenter la valeur de i de 1.

Pourquoi vaut-il mieux utiliser la pré-incrémentation que la post-incrémentation ?

C’est simplement une question de rapidité. En effet, la post-incrémentation va créer une variable temporaire pour s’exécuter ce que ne fera pas le pré-incrémentation. Qui dit variable temporaire, dit accès mémoire et donc perte de temps et de place.
Voici les équivalences :

int i = 0; 
tableau[i++] = 0; 
 
// Equivaut a : 
 
int i = 0; 
int tmpi = i; // Une variable temporaire est cree. 
tableau[tmpi] = 0; 
i++; 


et

int i = 0; 
tableau[++i] = 0; 
 
// Equivaut a :  
 
int i = 0; 
i = i + 1; 
tableau[i] = 0;

Tout ça pour ça ?

Une variable temporaire, c’est pas grande chose, mais rappelez vous de la boucle for : l’incrémentation est appelée à chaque itération ce qui, à terme peut ralentir l’exécution du programme.
Il faut tout de même savoir que la plupart du temps, le compilateur optimisera. Il y a cependant des cas o`u le compilateur ne saura pas si pré-incrémenter ne changera pas le comportement et ne fera donc rien alors qu’une optimisation aurait dûe être faite.
Comme précisé par Matthieu Brucher, le compilateur aura surtout du mal à optimiser dans le cas d'objets plus complexes et notamment des itérateurs (Cf STL).
D'après les tests effectué d'après l'observation de spiceguid, la pré-décrémentation est plus lente (encore que...) que la pré-incrémentation :
time ./TestDecrementation && time ./TestIncrementation  
 
real  0m3.600s 
user  0m3.590s 
sys  0m0.000s 
 
real  0m3.550s 
user  0m3.440s 
sys  0m0.000s 


avec un code du type :

for(int i = 1000000000; i >= 0; --i); 
// Et 
for(int i = 0; i < 1000000000; ++i);

Vous êtes prévenus maintenant !

Bonus : Surchage des opérateurs

Vous êtes vous déjà demandé comment faire la différence entre une post-opération et une pré-opération lorsqu’il faut surcharger l’opérateur unaire d’incrémentation (++ ou - -) ? Parce qu’à priori, le code est du genre :

inline operator ++() { // Post ou pre-incrementation ??  
  // Code ... 3  
}

Il y a une astuce ! En effet, pour surcharger une post-opération, il faut ajouter un paramètre inutile ! D’o‘u :

inline operator ++() { // Pre-incrementation 
  // Code ... 
}  
 
inline operator ++(int) { // Post-incrémentation 
  // Code ... 
} 


Conclusion

J’espère que ce premier article vous a plu et qu’il vous incitera à revenir régulièrement !

Références

C++ Cookbook
By Jeff Cogswell, Christopher Diggins, Ryan Stephens, Jonathan Turkanis
Publisher: O’Reilly
Pub Date: November 2005
ISBN: 0-596-00761-2

C++ Coding Standards: 101 Rules, Guidelines, and Best Practices
By Herb Sutter, Andrei Alexandrescu
Publisher: Addison Wesley Professional
Pub Date: October 25, 2004
ISBN: 0-321-11358-6

Et surêment plein d’autres...

Merci à Jey et à Paulo pour la relecture.\\
Merci aussi à Matthieu Brucher et spiceguid pour leurs observations très contructives.