Discussion :

[r0d]

Bonjour à tous,

j'ai une question qui n'est pas vraiment importante, c'est juste par curiosité.
Dans une boucle for du style:

Code :

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

1
2
3
4
for (int i=0; i<iMax; i++ /*ou ++i*/ )
{
   monVecteur[i] = 0;
}

Quelle est la différence entre ++i et i++ (s'il y en a, car j'ai testé, et je n'en ai vu aucune)?

merci.

[khayyam90]

http://c.developpez.com/faq/c/?page=...ATEURS_i++_++i

[r0d]

Oui certes, mmh.. j'ai dû mal poser ma question. Je vais donc la reformuler:

J'ai testé ces deux boucles:

Code :

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

for (int i =0; i<10; i++){tab[i]=1;}

et

Code :

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

for (int i =0; i<10; ++i){tab[i]=1;}

Je pensais qu'il y aurait une différence au niveau du premier et dernier élément de mon tableau, mais il n'en est rien. Apparemment, les deux boucles sont identiques.

Pourtant, il doit bien y avoir une différence, ne serait-ce qu'au niveau de la compilation. Qu'en pensez-vous?

[Jean-Marc.Bourguet]

La difference entre i++ et ++i n'est que pour l'expression en cours. Comme ici cette expression est reduite a i++ ou ++i, il n'y a pas de difference visible.

Pour des classes (par exemple des iterateurs) ++i peut avoir a faire moins de travail que i++ (puisqu'il ne faut pas retourner l'ancienne valeur) et donc la tendance c'est repandue en C++ de faire plutot ++i que i++ dans ce genre de contextes. Ceux qui ont essayer de mesurer la difference ont rarement trouve quelque chose de significatif.

[jmv]

avec les itérateurs, il vaut mieux utilser ++i pour des raisons de performance (i++ crée une copie de i, pas ++i).
dans les autres cas (pointeurs ou indice d'un tableau) ça ne change rien.

[edit]oups je n'avais pas vu le post précédent[/edit]

[r0d]

Donc, selon vous, dans le cas d'un simple entier, le code asm généré sera absolument identique dans les deux cas?

[bigquick]

dans les autres cas (pointeurs ou indice d'un tableau) ça ne change rien.

Vraiment ? (je ne vois pas pourquoi la copie faite avant le return "sauterait" dans le cas des pointeurs ou des types de base). A mon avis, c'est forcément plus négligeable qu'avec la copie d'un iterateur, mais il y a quand même une copie ....

Par contre, est-ce que le compilateur n'optimiserait pas lui-même tous les appels a l'operateur de post-incrémentation, quand une pre-incrémentation suffit ? (j'imagine qu'il suffit de regarder si la valeur de la variable est utilisée ailleurs dans l'expression courante)

[Jan Rendek]

Dans le cas d'un type simple, ça ne change rien parce que l'optimisateur peut voir que la valeur de retour n'est pas affectée, et donc supprimer cette copie.
Dans le cas d'un type complexe, ce n'est plus possible, il est peut-être du souhait de l'utilisateur que le constructeur de copie de l'objet soit appelé, ainsi que son destructeur.

[pacoco]

la difference n est que le syntaxe mais tu demande a lordinateur de faire le meme travail donc tu as le meme resultat si tu ajoute 1 a p ++p
si tu ajout a la valeur p 1 p++ donc tu voie c est la meme chose

[bigquick]

si tu ajoute 1 a p ++p
si tu ajout a la valeur p 1 p++

Euh, j'espère avoir mal compris
++i et i++ ne marchent pas comme ça.

C'est plutôt (si on explique rapidement):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
++i
{
    i = i+1;
    return i;
}
 
i++
{
    tmp = i;
    i = i+1;
    return tmp;
}

Donc dans le second cas, l'operateur retourne la valeur non-incrémentée.

[r0d]

bon, j'avais laissé ce sujet ouvert au cas où quelqu'un n'ait quelque chose à rajouter. Il semble que ce ne soit plus le cas. Je le clos donc.

à tous