boucle while, precision syntaxe

Version imprimable

27/06/2007, 19h42
S2S

[*]boucle while, precision syntaxe
lu,
je n'arive pas a faire fonctionné le test d'une boucle do...while
ca marche si je la simplifie comme ca:
Code:

1 2 while (mode!= 1)
mais (il en fallait un...), je doit tester si la saisi est egale a 1 OU 2 OU 3,
j'ai donc essayer ca:
Code:

1 2 3 while (mode!= 1 || 2 || 3) while (mode!= 1 || mode!= 2 || mode != 3)
:?
mais la boucle ne fini jamais meme si 'mode' est bien egale a 1,2 ou 3 (verifier)
je n'ai pas trouver de syntaxe tres precise sur mes doc. (pdf, htm...)

Je souhaiterai donc avoir des precisions sur la syntaxe 'do...while'
27/06/2007, 19h49
Laurent Gomila

Les opérateurs logiques (||, &&, etc.) renvoient un booléen. Tu ne peux donc pas les chaîner de cette manière (mode!= 1 || 2 || 3).
Ta seconde syntaxe est plus correcte, il faut juste remplacer les || par des && (tu veux boucler tant que mode n'est pas 1 ET mode n'est pas 2 ET mode n'est pas 3).
27/06/2007, 19h50
Bakura

EDIT : après avoir lu la réponse de Laurent, je crois que je me suis embrouillé avec les || et les && :aie:

EDIT2 : bon j'ai rien dit, je me suis trop embrouilllé :aie:

rapide merci,

un apercu de la boucle:
Code:

1 2 3 4 5 6 7 8 9 10 11 int mode; do { cout << "Choix du mode (1,2 ou 3) : "; cin >> mode; cout << "mode = " << mode << endl; } while (mode!= 1 || mode!= 2 || mode != 3); cout << "valeur de sorti : " << mode; return 0; }
je souhaite sortir de la boucle quand 'mode' prend une des valeur suivante: 1,2,3

ca resemble a un OU quand meme, et pourtant:
Code:

1 2 3 4 5 6 7 do { cout << "Choix du mode (1,2 ou 3) : "; cin >> mode; cout << mode << endl; } while (mode!= 1 && mode!= 2 && mode != 3);
&& fonctionne a merveille.
j'ai besoin d'une petite explication la :? suis perdu (mais ca marche)

27/06/2007, 20h11
Bakura

Citation:

je souhaite sortir de la boucle quand 'mode' prend une des valeur suivante: 1,2,3

C'est à dire lorsque mode est égal à 1, ou mode est égal à 2, ou mode est égal à 3, or l'opérateur est égal est ==, donc :

while (mode == 1 || mode == 2 || mode == 3);

or toi tu utilises !=, donc différent de. Ton code se traduit par :

Je souhaites sortir de la boucle lorsque mode est différent de 1, différent de 2 et différent de 3 (donc quand mode vaut 1, 2, ou 3), ce qui se traduit en C++ par :

while (mode != 1 && mode != 2 && mode != 3);
27/06/2007, 20h16
S2S

apparament, do...while execute la boucle tant que la condition est vrai:

Citation:

La structure de contrôle do permet, tout comme le while, de réaliser des boucles en attente d'une condition. Cependant, contrairement à celui-ci, le do effectue le test sur la condition après l'exécution des instructions. Cela signifie que les instructions sont toujours exécutées au moins une fois, que le test soit vérifié ou non. Sa syntaxe est la suivante :

do opération;
while (test);
opération est effectuée jusqu'à ce que test ne soit plus vérifié.

L'ordre d'exécution est :

opération
test

Exemple 2-4. Boucle do

p = i = 1;
do
{
p = p * i;
i = i + 1;
} while (i != 10);

donc !=

Code:

while (mode != 1 || mode != 2 || mode != 3);

mais non, ca na fonctionne pas
il faut:

Code:

while (mode != 1 && mode != 2 && mode != 3);

maintenant j'aimerai comprendre pourquoi '&&' fait un 'OU'...
27/06/2007, 20h43
Shugo78

Citation:

Envoyé par bakura

Je souhaites sortir de la boucle lorsque mode est différent de 1, différent de 2 et différent de 3 (donc quand mode vaut 1, 2, ou 3).
27/06/2007, 20h49
Bakura

Lit mon message juste avant le tiens :).
27/06/2007, 21h15
koala01

Salut,

Le grand problème vient, le plus souvent, du simple mauvais usage, en francais de OU par rapport au ET...

Quand on parle, on dira par exemple

Citation:

Tant que a est différent de 1 OU que a est différent de 2 OU que a est différent de 3

alors qu'il faudrait, dans ce contexte, dire

Citation:

Tant que a est différent de 1 ET que a est différent de 2 ET que a est différent de 3

En effet, le test doit donner VRAI tant que a n'a pas l'une des trois valeurs, et, passer à FAUX si a passe à une des valeurs envisagée.

Or, l'opérateur qui permet de passer de VRAI à FAUX si une des parties du test devient fausse, c'est l'opérateur ET :P
27/06/2007, 22h20
Laurent Gomila

Tu veux sortir de la boucle lorsqu'il vaut 1 ou 2 ou 3. Or la condition de while est la condition pour continuer la boucle, donc l'inverse.
Donc : tu veux rester dans la boucle tant qu'il ne vaut pas 1 et pas 2 et pas 3.
28/06/2007, 00h33
droggo

Sie,

Citation:

Envoyé par koala01

Quand on parle, on dira par exemple ...

Ah bon, qui ça ?
28/06/2007, 01h23
koala01

N'importe qui...

Bien souvent, tu entendra les gens utiliser un OU alors qu'en fait ils auraient du utiliser un ET, voire l'inverse ;)

EDIT entend par là le fait que, sémantiquement parlant ils auraient du utiliser le ou au lieu du et... ou l'inverse
28/06/2007, 13h48
gb_68

Citation:

Ah bon, qui ça ?

Citation:

N'importe qui...

Je dirais plutôt ceux qui ne connaissent pas la logique booléen de base :mrgreen:

Citation:

sortir si (il fait beau) OU (j'ai un parapluie)

devient

Citation:

rester tant que NON [ (il fait beau) OU (j'ai un parapluie)]

soit

Citation:

rester tant que NON(il fait beau) ET NON(j'ai un parapluie)

Citation:

rester tant que (il ne fait pas beau) ET (je n'ai pas de parapluie)

Et dans ce genre de cas (phrases qui sont plus parlantes que !(a!=0) || (b && c) ... ) tout le monde est d'accord sur l'usage des OU et des ET.

dzl plantage du net (j'etait en train de repondre)
Apres moulte test, ceci fonctionne comme il faut (du moin comme je veut)
Code:

1 2 3 4 5 6 7 8 9 10 11 int mode; do { cout << "Choix du mode (1,2 ou 3) : "; cin >> mode; cout << "mode = " << mode << endl; } while (mode != 1 && mode! = 2 && mode != 3); cout << "valeur de sorti : " << mode; return 0; }
en bon francois:
continue tant que "mode" different de "1" =VRAI
ET continue tant que "mode" different de "2" =VRAI
ET continue tant que "mode" different de "3" =VRAI

DONC si une des conditions devient FAUX, on on sort :? j'ai bon la :?

Code:

1
2
3
4
5
6
7
8
9
10
int mode;                                                   
do
{
cout << "Choix du mode (1,2 ou 3) : ";
cin >> mode;
cout << "mode = " << mode << endl;
} while ( !(mode == 1 || mode == 2 || mode == 3) );
cout << "valeur de sorti : " << mode; 
return 0;
}

Faire la boucle tant qu 'il n' y a pas mode = 1, mode = 2 ou mode = 3.
sinon t'as bon

28/06/2007, 15h55
S2S

:D alors c'est bon.

un dernier chose pour que ce soit complet...le OU:continue tant que "mode"

Pouquoi ca ne fonctionne pas si je met:
continue tant que "mode" different de "1" =VRAI
OU continue tant que "mode" different de "2" =VRAI
OU continue tant que "mode" different de "3" =VRAI

d'apres mes cours (resorti du placard pour l'ocasion):
ET logique // DONC (pour move= 1 2 ou 3) :
| A | B |out|/| 1 | 2 | 3 |out|
| 0 | 0 | 0 |//| 0 | 0 | 0 | 0 | VRAI SEULEMENT
| 1 | 0 | 0 |//| 1 | 0 | 0 | 0 | SI TOUS SONT FERMER (=1)
| 0 | 1 | 0 |//| 1 | 1 | 0 | 0 |
| 1 | 1 | 1 |//| 1 | 1 | 1 | 1 |
OU logique
| A | B |out|/| 1 | 2 | 3 |out|
| 0 | 0 | 0 |//| 0 | 0 | 0 | 0 |
| 1 | 0 | 1 |//| 1 | 0 | 0 | 1 | VRAI SI AU MOIN UN EST FERMER (=1)
| 0 | 1 | 1 |//| 1 | 1 | 0 | 1 |
| 1 | 1 | 1 |//| 1 | 1 | 1 | 1 |

et je ne voudrai pas lacher avant d'avoir bien comprit
car la, c'est un peut l'inverse quand meme
dailleur le ET ne devait jamais etre vrai= move ne peut etre a la foit 1 ET 2 ET 3.
:aie:
je met quand meme resolu, la boucle fonctionne (du moin ca fait ce que j'en attend).
28/06/2007, 16h19
Laurent Gomila

Citation:

Pouquoi ca ne fonctionne pas si je met:
continue tant que "mode" different de "1" =VRAI
OU continue tant que "mode" different de "2" =VRAI
OU continue tant que "mode" different de "3" =VRAI

Parce que mode sera toujours différent de 1 ou différent de 2 ou différent de 3, ça n'a aucun sens d'écrire ça. S'il vaut 1 il sera différent de 2, s'il vaut 2 il sera différent de 1, etc. Donc il y aura toujours au moins deux des trois conditions qui seront vraies, et le test sera par conséquent toujours vrai.
28/06/2007, 16h31
S2S

Merci 'Laurent Gomila', tu la dit dans le bonne ordre pour que mon cerveau :idea: comprene :cfou: a la premiere lecture. :mouarf:

donc c'est vraiment [RESOLU]
merci @++