boucle while, precision syntaxe

**S2S** · 27/06/2007, 19h42

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

Code :

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

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 :

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

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'

**Laurent Gomila** · 27/06/2007, 19h49

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).

**Bakura** · 27/06/2007, 19h50

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

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

**S2S** · 27/06/2007, 20h07

rapide merci,

un apercu de la boucle:

Code :

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

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 :

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

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)

**Bakura** · 27/06/2007, 20h11

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);

**S2S** · 27/06/2007, 20h16

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

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 :

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

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

mais non, ca na fonctionne pas
il faut:

Code :

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

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

maintenant j'aimerai comprendre pourquoi '&&' fait un 'OU'...

**Shugo78** · 27/06/2007, 20h43

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).

**Bakura** · 27/06/2007, 20h49

Lit mon message juste avant le tiens

.

**koala01** · 27/06/2007, 21h15

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

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

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

**Laurent Gomila** · 27/06/2007, 22h20

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.

**droggo** · 28/06/2007, 00h33

Sie,

Envoyé par koala01

Quand on parle, on dira par exemple ...

Ah bon, qui ça ?

**koala01** · 28/06/2007, 01h23

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

**gb_68** · 28/06/2007, 13h48

Ah bon, qui ça ?

N'importe qui...

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

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

devient

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

soit

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

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.

**S2S** · 28/06/2007, 15h01

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

Code :

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

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

**coyotte507** · 28/06/2007, 15h06

Code :

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

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

**S2S** · 28/06/2007, 15h55

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.

je met quand meme resolu, la boucle fonctionne (du moin ca fait ce que j'en attend).

**Laurent Gomila** · 28/06/2007, 16h19

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.