Postincrémentation

Bonjour,
Je suis débutant en C.
J'ai déjà cherché une solution à mon problème (ou erreur :-) sur ce forum mais je n'ai pas trouvé la solution, alors voilà le problème:
Je pense avoir bien compris la différence entre préincrémentation et postincrémentation mais mon compilateur, lui ne semble pas faire de différence (peut-être, aurai-je du poser cette question dans la section consacré au compilateur ou au EDI?).
Voilà ce qui se passe:
Avec x = 1,
x++ donne 2 et ensuite x vaut 2.
par contre (toujours avec x = 1) x = x++ donne 1 mais ensuite x vaut 2 !?! (alors que j'attend 1).
Où est le problème? Que n'ai-je pas compris? Mon compilateur est-il mal configuré?
Merci à tous pour votre aide. Ce problème devant être une énorme faute de débutant, je m'en excuse d'avance.

Avec x = x++, tu prends la valeur de x et puis tu incrémentes c'est à dire que x++ renvoie la valeur de x avant incrémentation, ce qui fait que finalement tu ne changes pas la vlaeur de x.
Ce genre de manips est évidemment très dangereux

Oui, mais pourquoi le compilateur me dit que x = 2 alors? (au lieu de x = 1)?
Peut-être que ma question n'était pas très claire!

J'avais lu de trop vite ta question :oops:
Le problème de faire deux choses en même temps.
En fait je n'ai pas d'explication qui me satisfasse, il faudrai avoir l'avis de spécialistes et tester sur différents compilateurs, mais comme je ne suis pas chez moi...
Peut-être cet après midi si personne n'a répondu avant.

Bonjour,

Citation:

---

Envoyé par Lucky-94

(toujours avec x = 1) x = x++ donne 1 mais ensuite x vaut 2 !?! (alors que j'attend 1).

---

La se n'est pas trés clair.

Code:

---

x = x++;

---

Peut être remplacé par :

Code:

---

1 2	x = x; x++;

---

Donc si x vaut 1, tu obtiens 2, c'est normal :loi:

Merci.
Moi non plus je ne suis pas "chez moi".
Je suis en province et je me connecte depuis une cyber base (genre cyber café mais sans café ;-).
Je ne pourrais donc voir vos prochains messages que demain si tout va bien ou alors aujourd'hui jusqu'à 12H maximum.
Pas d'inquiétude donc si je répond tardivement à vos aides.

Pour illustrer la différence entre pré et post incrémentation, je voudrais utiliser ce genre de code:

Code:

---

1 2 3 4 5 6 7 8

int x = 1; printf("Avec x = %d\n", x); printf("x++ donne: %d\n", x++); printf('x vaut maintenant: %d\n", x); x = 1; printf("Avec x = %d\n", x); printf("x = x++ donne: %d\n, x = x++); printf("x vaut maintenant: %d\n, x);

---

J'attend donc comme résultat:
Avec x = 1
x++ donne: 2
x vaut maintenant: 2
Avec x = 1
x = x++ donne: 1
x vaut maintenant: 1

Alors qu'après compilation j'obtiens:
Avec x = 1
x++ donne: 2
x vaut maintenant: 2
Avec x = 1
x = x++ donne: 1
x vaut maintenant: 2

d'où ma surprise!
Où est le problème?

Citation:

---

Envoyé par Lucky-94

Voilà ce qui se passe:
Avec x = 1,
x++ donne 2 et ensuite x vaut 2.
par contre (toujours avec x = 1) x = x++ donne 1 mais ensuite x vaut 2 !?! (alors que j'attend 1).
Où est le problème? Que n'ai-je pas compris? Mon compilateur est-il mal configuré?
Merci à tous pour votre aide. Ce problème devant être une énorme faute de débutant, je m'en excuse d'avance.

---

Ces notions de pre et post incrémentations sont difficiles à aborder et à mettre en oeuvre de façon portable.

D'autre part, il y a de nombreux cas indéfinis. Pour être clair, et dans une optique de codage industriel où la qualité prime, il est recommandé de ne pas utiliser les opérateurs unaires autrement que tout seuls.

'i++' et '++i' ont alors le même comportement et les résultats deviennent facilement prévisibles. Autra avantage, le code devient lisible, et les intenstions du codeurs sont clairement exprimées. Il n'y a aucun bénéfice à tirer d'une écriture cryptique.

Code:

---

1 2 3

i++; a=i;

---

ou

Code:

---

1 2 3

a=i; i++;

---

et non

Code:

---

a = i++;

---

ou

Code:

---

a = ++i;

---

dont l'interprétation exacte demande un niveau de connaissance de la norme qui va bien au-dela de ce qui est nécessaire pour coder en C simplement...

En contrôle de qualité (QC), c'est retour à l'envoyeur avec la mention 'illisible'.

Emmanuel >> le comportement de x = x++ dépend-il de la norme, ou de l'implémentation d'un compilo ?
Pour moi, avec x = 1, x devrait encore valoir 1 après x = x++.

Citation:

---

Envoyé par gege2061

Code:

---

x = x++;

---

Peut être remplacé par :

Code:

---

1 2	x = x; x++;

---

---

Tu en es sûr ?
Moi j'aurais analysé de cette façon.
etape 1 : on mémorise la valeur de x avant incrémentation soit 1 pour envoi en valeur retour de celle-ci
etape 2 : on incremente la valeur de x qui passe à 2
etape 3 : l'incrémentation est terminée on renvoie la valeur soit 1
etape 4 : on affecte à x la valeur retour de l'incrémentation soit 1

Citation:

---

Envoyé par Trap D

Citation:

---

Envoyé par gege2061

Code:

---

x = x++;

---

Peut être remplacé par :

Code:

---

1 2	x = x; x++;

---

---

Tu en es sûr ?

---

C'est pour éviter ces discussions de gourous de niveau 4 que je préconise d'éviter ce genre d'écriture...

A mon avis, l'absence de point de séquencement implique un comportement indéfini. Mais je ne suis pas un gourou (même de niveau 0).

Voici la réponse du gourou C++ Builder:

Citation:

---

L'ordre dans lequel C++Builder évalue les opérandes d'une expression n'est pas spécifié, sauf lorsqu'un opérateur l'énonce explicitement. Le compilateur essaie de réordonner l'expression afin d'améliorer la qualité du code généré. Vous devez donc être attentif aux expressions où une valeur est modifiée plusieurs fois. En général, évitez d'écrire des expressions qui modifient et utilisent la valeur du même objet. Prenons l'expression

i*=*v[i++];**//*i*est*non*défini

La valeur de i est différente selon que i est incrémenté avant ou après l'affectation. De même,

int*total*=*0;

somme*=*(total*=*3)*+*(++total);*//*somme*=*4*ou*somme*=*7*??

est ambiguë pour somme et total. La solution est de reformuler l'expression en utilisant une variable temporaire*:

int*temp,*total*=*0;

temp*=*++total;

somme*=*(total*=*3)*+*temp;

Lorsque la syntaxe met en oeuvre une séquence d'évaluation, il est plus sûr d'avoir plusieurs évaluations*:

somme*=*(i*=*3,*i++,*i++);*//*OK:*somme*=*4,*i*=*5

Chaque sous-expression d'une expression avec virgule est évaluée de gauche à droite, et l'ensemble a pour résultat la valeur la plus à droite.

C++Builder regroupe les expressions, en réordonnant les opérateurs associatifs et commutatifs indépendamment des parenthèses, afin de créer une expression compilée de façon optimale*; en aucun cas ce réarrangement n'affecte la valeur de l'expression.

---

Citation:

---

Envoyé par 10_GOTO_10

Voici la réponse du gourou C++ Builder:

---

Peu importe si c'est différent dans une autre implémentation. Soit c'est parfaitement défini par la norme et c'est portable, soit ça dépend de l'implémentation, et ça ne nous interesse pas vraiment. Qui irait écrire du code non portable quand des atlernatives standards existent ?

Merci pour ces eclaircissements.
En conclusion, pour obtenir un code "propre", mieux vaut utiliser les opérateurs d'incrémentation et de décrémentation seul.
Je vais essayer d'appliquer cette règle dans le futur.
Le problème est que ce genre de lignes de codes, je ne les ai pas inventées mais elles proviennent d'un livre d'apprentissage du langage C.

Citation:

---

Envoyé par Lucky-94

Le problème est que ce genre de lignes de codes, je ne les ai pas inventées mais elles proviennent d'un livre d'apprentissage du langage C.

---

Eh oui, il existe de mauvais livres...

Le K& R est un mauvais livre ??
rappel : un exemple de strcpy est

Code:

---

while (*s++ = *t++) ;

---