[Debutant] Syntaxe de base, mécanisme obscur

Je me lance en autodidacte assez débutant sur le C.

J'en suis à me familiariser avec les valeurs retournées par une expression quelconque, et sur un exercice je ne comprend pas pourquoi lerésultat est ainsi, pourtant j'ai essayé plusieurs trucs pour vérifier quelques idées.

Voici le code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 int N=10, P=5, Q=10; N = 5; P = 2; printf("Avec N = %d et P = %d on a :\n", N, P); /* premier cas*/ Q = N++ > P || P++ != 3; printf ("\t'Q = N++ > P || P++ != 3;' donne : N=%d P=%d Q=%d\n", N, P, Q); /*deuxième*/ Q = P++ != 3 || N++ > P; printf ("\t'Q = P++ != 3 || N++ > P;' donne : N=%d P=%d Q=%d\n", N, P, Q); /*troisième*/ Q = 0 || P++ != 3 || N++ > P; printf ("\t'Q = 0 || P++ != 3 || N++ > P;' donne : N=%d P=%d Q=%d\n", N, P, Q);
Dans le premier cas il me donne N = 6 P = 2 Q = 1 ; dans le second 6 3 et 1 et dans le dernier 7 4 et 1.

En fait j'ai testé en inversant l'ordre des deux tests dans l'affectation de Q entre le premier et le second cas. Dans le troisième comme je ne comprennais toujours pas, j'ai essayé de rajouter un test avant pour voir ce que ferai C, mais je n'arrive pas à comprendre...

Merci bien d'avance :)

En fait, dans cette histoire les opérations de chaque ligne sont stoppées à partir du moment où l'une d'elles retourne vrai.
Dans le dernier cas, Q=0 équivaut à faux, donc on exécute le suivant, P++!=3.
Or P vaut 3 avant l'incrémentation, donc n'est pas différent de 3, on passe au dernier qui sera exécuté, N++>P, donc N vaut 7.

Citation:

Envoyé par Miles

En fait, dans cette histoire les opérations de chaque ligne sont stoppées à partir du moment où l'une d'elles retourne vrai.
Dans le dernier cas, Q=0 équivaut à faux, donc on exécute le suivant, P++!=3.
Or P vaut 3 avant l'incrémentation, donc n'est pas différent de 3, on passe au dernier qui sera exécuté, N++>P, donc N vaut 7.

Merci beaucoup Miles !

Je vient de réaliser que si ça "bug" d'apparence c'est parce que N et P ne sont pas remis à leurs valeurs initiales (5 et 2) au début de chaque cas, si c'est bien ça (je vais tester), je m'excuse bien bas :?

Edit : effectivement c'est bien ça, je ne comprenais pas ces résultats car je ne réinitialisais pas entre les 3 cas.

Mais ce que tu m'as dit est intéressant Miles. Ca veut dire que si on fait pas attention, et qu'on veuille augmenter une variable A tout en réalisant une affectation à la variable Bcomme par exemple suivant cette syntaxe :

Code:

B = C || A++;

Alors si C != 0 B serai affecté à 1 et le reste ne serai pas évalué ? Ainsi A++ ne serai pas exécuté ?

merci beaucoup. :oops:

Bonjour,

Je pense que tu gagnerasi beaucoup à parenthéser tes expressions !
Code:

1 2 B = C || A++;
Si tu as un compilateur fainéant (et c'est plus que probalement ton cas), un telle expression sera évaluée tant qu'un argument n'est pas faux.

Le parenthésage est nécessaire, mais el fait de séparer les opérations peut également s'avérer important.

Personnellement, je ne connais pas les priorités des opérateurs, et ne saurais dire si ton code équivaut à :
Code:

1 2 3 B = (C || A); A++;
Ou bien à
Code:

1 2 3 A++; B = (C || A);
Autre exemple :
Code:

1 2 tableau[i] = i++;
est un comportement indéfini (sauf erreur de ma part). Donc attention à la séparation des opérations...

Citation:

Envoyé par Reese

Code:

B = C || A++;

Alors si C != 0 B serai affecté à 1 et le reste ne serai pas évalué ? Ainsi A++ ne serai pas exécuté ?

Non, on assigne B à C, et si C est différent de 0, on exécute A++, mais C ne vaut pas forcément 1, il vaut B.

D'après ce que j'ai lu si tu met

Code:

a = b++;

Cela équivaut à
Code:

1 2 a=b; b=b+1;
Donc pour ton code avec le tableau, ça devrait être compris par le compliateur mais je veux pas m'affirmer ce n'est que d'après ce que j'ai lu :(

J'utilise Dev-C++ car ça avait l'air d'être le plus simple et tout en un. Je ne sais pas si le ocmpilateur est bon, et ce genre de choses, mais jusqu'à maintenant pour des errurs basiques elles sont bien mises en évidence ^^

Merci beaucoup, je vais faire attention aux parenthèses now.

Citation:

Envoyé par Miles

Citation:

Envoyé par Reese

Code:

B = C || A++;

Alors si C != 0 B serai affecté à 1 et le reste ne serai pas évalué ? Ainsi A++ ne serai pas exécuté ?

Non, on assigne B à C, et si C est différent de 0, on exécute A++, mais C ne vaut pas forcément 1, il vaut B.

Là je vois pas :?

Bonjour,

Citation:

Envoyé par gangsoleil

Si tu as un compilateur fainéant (et c'est plus que probalement ton cas), un telle expression sera évaluée tant qu'un argument n'est pas faux.

Plus exactement jusqu'à ce que la valeur de l'expression soit connue. Dans ce cas :

Code:

B = C || A++;

Si C vaut 1 (donc vrai), on s'arrête là, donc le reste n'est pas exécuter.
Citation:
Envoyé par gangsoleil
Personnellement, je ne connais pas les priorités des opérateurs, et ne saurais dire si ton code équivaut à :
Code:

1 2 3 B = (C || A); A++;
Ou bien à
Code:

1 2 3 A++; B = (C || A);
Aucune des deux car si C vaut 0 (faux) A n'est pas modifié mais si C vaut 1 (vrai), cela revient au même que la première solution.
Citation:
Envoyé par gangsoleil
Autre exemple :
Code:

1 2 tableau[i] = i++;
est un comportement indéfini (sauf erreur de ma part). Donc attention à la séparation des opérations...
Exact, on ne sait pas si c'est le membre de droite au celui de gauche qui va être interprété en premier.

Oups, pardon, dans mon explication, j'ai inversé B et C !!!

Citation:

Envoyé par Reese

J'utilise Dev-C++ car ça avait l'air d'être le plus simple et tout en un. Je ne sais pas si le ocmpilateur est bon, et ce genre de choses, mais jusqu'à maintenant pour des errurs basiques elles sont bien mises en évidence ^^

Dev-cpp n'est qu'un IDE (Integrated Development Environment ou environnement de développement intégré en français) il utilise, par défaut, Mingw pour la compilation qui est un portable de gcc sous Windows. Donc au niveau de la qualité du compilateur il n'y a pas de problème.

Ca fait encore plus peur après le problème que avant. Mais je vais essayer de survivre. 8O

Re: [Debutant] Syntaxe de base, mécanisme obscur

Citation:

Envoyé par Reese

Je me lance en autodidacte assez débutant sur le C.

Tu as donc un bon livre de C entre les mains...

Citation:

J'en suis à me familiariser avec les valeurs retournées par une expression quelconque,

Quelqonque ? Certainement pas. Il y a des choses qui sont définies et d'autres qui ne le sont pas (même si la syntaxe est avalée par le compilateur). Ce qui n'est pas défini peut provoquer n'importe quoi. C'est un bug. Il faut cesser de programmer au hasard, apprendre les regles du langage et s'y tenir. (comme ne pas mélangerl es opérateurs unaires et binaires dans la même expression)

Citation:

Envoyé par gege2061

Citation:

Envoyé par gangsoleil

Si tu as un compilateur fainéant (et c'est plus que probalement ton cas), un telle expression sera évaluée tant qu'un argument n'est pas faux.

Plus exactement jusqu'à ce que la valeur de l'expression soit connue. Dans ce cas :

Code:

B = C || A++;

Si C vaut 1 (donc vrai), on s'arrête là, donc le reste n'est pas exécuter.

C peut aussi valoir 2, 3 ou 15000... Toute valeur non-nulle est considere comme "vraie" pour les operateurs logiques. L'expression est (presque ?) equivalente a
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 /* En C, l'evaluation des && et || est paresseuse, i.e. toujours de gauche a droite, donc on evalue d'abord C */ if (C != 0) { /* C est non-nul, donc 'expression est vraie, l'evaluation s'arrete ici, et renvoie la valeur 1 */ B = 1; } else { /* C est nul, donc faux, l'evaluation du OU logique continue */ /* d'abord on prend la valeur de A */ if (A == 0) { /* A nul : faux, donc l'expression prend la valeur 0 */ B = 0; } else { /* A non-nul, donc vrai: l'expression prend la valeur 1 */ B = 1; } /* post-incrementation de A */ A = A + 1; }
("presque" car j'hesite entre l'ordre d'affectation entre A et B dans le cas C nul)

Citation:

Envoyé par alveric

("presque" car j'hesite entre l'ordre d'affectation entre A et B dans le cas C nul)

C'est bon, l'opérateur d'incrémentation est postfixé donc on commence par évaluer la valeur de A puis on l'incémente.

Citation:

Envoyé par gege2061

Citation:

Envoyé par alveric

("presque" car j'hesite entre l'ordre d'affectation entre A et B dans le cas C nul)

C'est bon, l'opérateur d'incrémentation est postfixé donc on commence par évaluer la valeur de A puis on l'incémente.

Je voulais dire, peut-on avoir
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 if (A == 0) { /* post-incrementation de A */ A = A + 1; /* A nul : faux, donc l'expression prend la valeur 0 */ B = 0; } else { /* post-incrementation de A */ A = A + 1; /* A non-nul, donc vrai: l'expression prend la valeur 1 */ B = 1; }
:?: i.e. une fois que le test est fait, les affectations sont-elles faites dans un ordre precis ?

Citation:

Envoyé par alveric

i.e. une fois que le test est fait, les affectations sont-elles faites dans un ordre precis ?

ça m'étonnai aussi que la question soit aussi simple :)
ça rejoin le problème de gangsoleil avec son tableau :

Citation:

Envoyé par gege2061

Citation:

Envoyé par gangsoleil

Autre exemple :
Code:

Code:

tableau[i] = i++;

est un comportement indéfini (sauf erreur de ma part). Donc attention à la séparation des opérations...

Exact, on ne sait pas si c'est le membre de droite au celui de gauche qui va être interprété en premier.

Citation:

Envoyé par gege2061

Citation:

Envoyé par alveric

i.e. une fois que le test est fait, les affectations sont-elles faites dans un ordre precis ?

ça m'étonnai aussi que la question soit aussi simple :)

:roll:

Citation:

Envoyé par gege2061

ça rejoin le problème de gangsoleil avec son tableau :

Je pense aussi, mais a defaut d'avoir la norme sous les yeux, j'avais un doute si ce cas etait determine ou non. C'est probablement au choix du compilateur, je suppose.