Les boucles sont l’un des outils les plus importants en programmation. Ils sont utiles dans les cas où vous devez faire quelque chose un certain nombre de fois.

S'il existe une telle tâche, par exemple, afficher la ligne « bonjour à tous » 1000 fois. Ensuite, sans utiliser de boucle, d’une part cela prendra beaucoup de temps et d’autre part, cela n’aura pas l’air très joli. C'est pourquoi il faut parfaitement connaître les cycles car ils sont utilisés très, très souvent.

Il y a quatre boucles dans la programmation, ce sont pendant, pendant que, pour et pour chaque. Chacun d'eux a sa propre syntaxe et chacun est utilisé dans certains cas.

Les boucles les plus couramment utilisées sont for et foreach, puis while et faire une boucle en attendant est très rare.

Et nous commencerons par boucle while.

La syntaxe de la boucle while est la suivante :

Tout d’abord, nous déclarons la variable i, qui est un compteur, et à l’intérieur de la boucle nous incrémentons ce compteur. Entre parenthèses, nous écrivons la condition d’entrée/sortie de la boucle.

Commentaire! Écrivez correctement la condition de sortie, sinon cela peut arriver cycle sans fin et puis le script se figera. Un tel cycle peut se produire si, par exemple, nous écrivons simplement true dans la condition de sortie.

Par exemple, imprimons la chaîne « Bonjour à tous ! » 10 fois.

Var je = 0 ; pendant que(i "); i++; )

La variable i peut commencer à partir de 0 ou 1 ou de tout autre nombre.

La condition de sortie est en même temps la condition d’entrée. La boucle fonctionne comme suit : tout d'abord, elle vérifie si la variable i est inférieure à 10, et si la condition est vraie, alors nous entrons dans la boucle, sinon non. Dans ce cas, si la variable i est égale à 30, par exemple, alors la boucle ne s'exécutera pas, car 30 n'est pas inférieur à 10.

Nous sommes entrés dans le cycle, avons imprimé la ligne "Bonjour à tous", incrémenté le compteur et revenons à la condition, où nous vérifions à nouveau si la valeur de la variable i est inférieure à 10, puis nous entrons dans le cycle, sinon nous en sortons. Et cela se produit jusqu'au moment où la condition d'entrée devient fausse, c'est-à-dire que la valeur de la variable i sera 10. 10 n'est pas inférieur à 10, donc on n'entre plus dans la boucle, mais on passe à autre chose.

Commentaire! N'oubliez pas d'incrémenter le compteur (i++), sinon vous vous retrouverez avec une boucle infinie.

Nous avons traité de la boucle while, passons maintenant à la boucle do-while.

La syntaxe de la boucle do-while est la suivante :

La différence entre une boucle while et une boucle do-while est qu'une boucle do-while peut être exécutée au moins une fois, quelle que soit la condition, alors qu'une boucle while ne sera pas exécutée du tout si la condition est fausse.

Commentaire! Tout comme pour la boucle while, n'oubliez pas d'incrémenter le compteur i.

Passons à la pratique. Par exemple, calculons le produit de nombres de 1 à 10.

Var je = 1 ; production var = 1 ; faire( production *= i; i++; )tandis que(i

Le résultat sera le numéro 3628800. Dans la première étape, nous sommes immédiatement entrés dans la boucle, malgré son état, où l'opération production *= i a été effectuée (c'est la même chose que production = production * 1). Ensuite, nous incrémentons le compteur. Après incrémentation, il a une valeur de 2. Et à la fin on vérifie la condition, si la valeur du compteur est inférieure ou égale à 10, alors on passe à l'itération suivante de la boucle, sinon on sort de la boucle et on passe à autre chose .

pour la boucle

Comme je l'ai écrit ci-dessus, la boucle for se produit assez souvent, vous devez donc très bien la connaître.

pour la syntaxe de la boucle suivant:

Pour une meilleure compréhension, résolvons un problème simple. Disons que nous devons calculer la somme des nombres de 1 à 1000 à l'aide d'une boucle for.

Somme var = 0 ; pour(var je = 1; je

Nous enregistrons le document, l'ouvrons dans le navigateur et voyons que le résultat est 500500.

Commentaire! S'il n'y a qu'une seule instruction dans une boucle, alors croisillons facultatif.

Pour démontrer, affichons 5 fois une chaîne à l’écran, par exemple « Bonjour ! »

Pour(var je = 1; je

Commentaire! Une fois la boucle exécutée, la dernière valeur reste dans la variable i.

Résolvons maintenant le problème un peu plus compliqué, par exemple nous devons imprimer la chaîne "Bonjour" 100 fois. Et pour que tout ne se termine pas sur une seule ligne, alors après chaque 10ème itération, passons à nouvelle ligne. Et à la fin nous imprimerons la valeur de la variable i.

Pour(var je = 1; je<= 100; i++){ document.write("привет!"); if(i % 10 == 0)  document.write("
"); ) document.write("

Variable je = " + je + "

"); // je = 101

boucle foreach Généralement utilisé pour parcourir des objets et des tableaux. Par conséquent, j'en parlerai dans l'article décrivant le travail avec des tableaux.

instruction de pause est destiné à sortir de force de la boucle.

Continuer l'opérateur permet d'interrompre l'itération en cours de la boucle et de passer à la suivante.

Pour une meilleure compréhension, nous allons également résoudre un problème simple. Disons que nous voulons calculer la somme des nombres impairs de 1 à 20. Et lorsque nous atteindrons la 15ème itération, nous sortirons de la boucle.

Somme var = 0 ; pour(var je = 1; je<= 20; i++){ //Пропускаем текущею итерацию цикла if(i % 2 == 0) continue; summa += i; //Выходим совсем из цикла. if(i == 15) break; document.write(i + ". Итерация
"); ) document.write("

somme= " + somme + "

"); //somme = 64

Nous enregistrons le document, l'ouvrons dans le navigateur et regardons le résultat.

Pour vous entraîner, essayez de modifier le script écrit pour qu'il calcule la somme des nombres pairs.

Ceci termine cet article. Maintenant tu sais syntaxe des boucles while, do-while, for et comment travailler avec elles. Nous avons également rencontré instructions break et continue.

Parce que dans do while, le corps de la boucle est d'abord exécuté, puis la condition de poursuite de la boucle est vérifiée. En raison de cette fonctionnalité, do while est appelé une boucle avec une postcondition. Ainsi, si la condition do while est manifestement fausse, alors le bloc d'instructions dans le corps de la boucle do while sera exécuté au moins une fois. En conséquence, la structure de do while diffère de la boucle while. Si dans while la condition de continuation de la boucle est vérifiée en premier, et si la condition est vraie, alors seulement le corps de la boucle est exécuté. La boucle do while fonctionne exactement dans le sens inverse, d'abord le corps de la boucle est exécuté, puis la condition est vérifiée, c'est pourquoi le corps de la boucle do while sera exécuté au moins une fois.

// forme d'enregistrement de l'opérateur de boucle do while : do // début de la boucle do while ( /*bloc d'opérateurs*/; ) while (/*condition d'exécution de la boucle*/); // fin de la boucle do while

Au début de la boucle do while, le mot réservé do est écrit, suivi d'accolades, qui peuvent être omises si une instruction est utilisée dans le corps de la boucle do while. Après l'accolade fermante, indiquant la fin du corps de la boucle do while, il y a une condition de boucle do while, après laquelle vous devez mettre un point-virgule. Considérons un programme avec une boucle do while qui effectue certaines transactions avec un compte bancaire.

// do_while.cpp : Définit le point d'entrée de l'application console. #include "stdafx.h" #include #inclure en utilisant l'espace de noms std ; int main(int argc, char* argv) ( srand(time(0)); int balance = 8; // balance do // début de boucle do while ( cout<< "balance = " << balance << endl; // показать баланс int removal = rand() % 3; // переменная, для хранения вычитаемого значения cout << "removal = " << removal << endl; // показать вычитаемое значение balance -= removal; // управление условием } while (balance >0); // fin de boucle do while system("pause"); renvoie 0 ; )

DANS ligne 11 La variable solde a été déclarée, elle est responsable du solde des fonds du compte. AVEC 12ème à 19ème lignes boucle écrite do while . Dans la boucle do while, toutes les transactions avec le compte de solde sont effectuées, à savoir le transfert de fonds vers un autre compte, ligne 17. Ligne 14 montre le solde des fonds dans le solde du compte. DANS ligne 15 une variable est déclarée dans laquelle la valeur soustraite est stockée, et cette valeur est générée aléatoirement dans l'intervalle. La variable de suppression est déclarée une fois dans le corps de la boucle do while et la variable n'est pas redéfinie à chaque fois que la boucle se répète. Mais sa valeur change en fonction du nombre généré. DANS ligne 19 la condition de la boucle do while est écrite, dès que la condition devient fausse, le programme transférera le contrôle à l'instruction suivante après la boucle do while, ligne 20. Le résultat du programme est présenté dans la figure 1.

Figure 1 Faire une boucle while en C++

Tout d'abord, le solde est affiché, puis le montant du retrait, après quoi le solde est à nouveau affiché, et ainsi de suite jusqu'à ce qu'il n'y ait plus d'argent sur le compte. La dernière ligne affichée était celle avec le montant retiré, puis le cycle a terminé son travail. Bien que le dernier solde du compte ne soit pas visible, on peut dire qu'il est égal à 0.

Rappelons-nous le programme « Devinez le numéro », de la section :. Dans cette tâche, il serait plus correct d'utiliser une boucle do while, le code sera réduit de deux lignes.

// ygadai2.cpp : Définit le point d'entrée de l'application console. #include "stdafx.h" #include #inclure en utilisant l'espace de noms std ; int main(int argc, char* argv) ( srand(time(0)); int unknown_number = 1 + rand() % 10; // nombre à deviner int enter_number; // variable pour stocker le nombre saisi do ( cout<< "Enter unknown number : "; cin >> entrez_numéro ; // devine ) while (enter_number != inconnu_number); cout<< "You win!!!\n"; system("pause"); return 0; }

Puisque while est une boucle avec une condition préalable, nous devions d'abord compter le nombre avant le début de while, puis vérifier la suite de la boucle while. Dans le cas de do while, nous n'avons pas besoin de lire le numéro avant le début de la boucle, puisque la condition de vérification do while se produit à la fin de la boucle. Selon la situation, une boucle while ou do while est utilisée, elles se complètent.

Pour consolider le matériel, nous développerons un autre programme qui calcule la somme des nombres dans un intervalle donné.

// dowhile.cpp : Définit le point d'entrée de l'application console. #include "stdafx.h" #include en utilisant l'espace de noms std ; int main(int argc, char* argv) ( cout<< "Enter the first limit: "; // начальное значение из интервала int first_limit; cin >> première_limite ; cout<< "Enter the second limit: "; // конечное значение из интервала int second_limit; cin >> seconde_limite ; int somme = 0, count = first_limit ; do ( sum += count; // augmentation de la somme count++; // incrémentation de la valeur initiale à partir de l'intervalle spécifié ) while (count<= second_limit); // конец цикла do while cout << "sum = " << sum << endl; // печать суммы system("pause"); return 0; }

Après avoir démarré le programme, vous devez saisir les limites d'intervalle, première et seconde. Après cela, la boucle do while commence à s'exécuter, ligne 13.la somme variable est destinée à stocker le montant accumulé, ligne 15. DANS ligne 16 La valeur initiale de la limite est incrémentée après chaque répétition du cycle. Le résultat du programme (voir Figure 2).

Figure 2 Faire une boucle while en C++

L'intervalle est indiqué de -6 à 10 inclus, [-6;10]. Le programme additionne tous les entiers d'un intervalle donné. La somme se forme comme suit : -6 -5 -4 -3 -2 -1 + 0 +1 +2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 34. Ainsi, l'action de sommation tous les nombres entiers sont exécutés de manière cyclique à partir d'un intervalle spécifié par l'utilisateur.

La boucle Do While... dans VBA Excel, sa syntaxe et la description des composants individuels. Exemples d'utilisation de la boucle Do While....

La boucle Do While... dans VBA Excel est conçue pour répéter un bloc d'instructions jusqu'à ce qu'une condition spécifiée soit remplie (renvoie True). La syntaxe de cette boucle est similaire à celle de , qui se répète jusqu'à ce que la condition soit remplie (renvoyant False).

Faire pendant... Syntaxe de la boucle

La syntaxe Do While... Loop se décline en deux versions qui déterminent le moment où la condition est testée.

La condition est vérifiée avant d'exécuter les instructions :

Condition Do While [ instructions ] [ Exit Do ] [ instructions ] Boucle

La condition est vérifiée après l'exécution des instructions :

Do [ instructions ] [ Exit Do ] [ instructions ] Condition de boucle While

Les crochets indiquent les attributs facultatifs de la boucle Do While....

Composants d'une boucle Do While...

*Si vous n'utilisez pas votre propre code dans une boucle, le sens de l'utilisation d'une boucle est perdu.

**Un opérateur très utile pour la boucle Do While..., puisque dans certaines circonstances elle peut devenir infinie. Si ce risque existe, vous devriez pouvoir quitter la boucle infinie VBA à l'aide d'une instruction Exit Do.

Exemples de boucles Do While...

Les cycles les plus simples

Do While... Boucle avec condition aux instructions exécutables :

Sub test1() Dim a As Byte Do While a< 10 a = a + 1 Loop MsgBox a End Sub

Do While... Boucle avec une condition après les instructions exécutables :

Sub test2() Dim a As Byte Do a = a + 1 Boucle While a< 10 MsgBox a End Sub

Dans les deux cas, la MsgBox affichera le chiffre 10. Lorsque la valeur de la variable un sera égal à 10, la condition vérifiée renverra la valeur FAUX, et la boucle sera arrêtée.

Parcourir les rangées d'une feuille

Les deux écureuils possèdent des creux situés l'un en face de l'autre. Chaque creux contient 100 cônes. Pendant leur temps libre, ils lancent des cônes dans le creux d’en face, mais ils ne frappent pas toujours. Le tableau ci-dessous indique le nombre de cônes lancés par chaque écureuil et combien d'entre eux ont atteint la cible.

Sur la base de ces données, vous devez savoir combien de cônes Squirrel 1 a laissé dans le creux. Pour ce faire, il faut soustraire de 100 cônes le nombre de cônes lancés par Écureuil 1 et ajouter les cônes lancés dans son creux par Écureuil 2. On commence les calculs à partir de la deuxième ligne (dans le premier en-tête) et dans la condition pour dans la boucle Do While..., nous indiquons "la première cellule de la ligne actuelle n'est pas vide." Le tableau doit commencer à partir de la première cellule de la feuille de calcul « A1 », et en dessous, au moins une ligne doit être vide, plus précisément la première cellule de cette ligne.

Sub test3() Dim i As Long, n As Long i = 2 n = 100 Do While Cells(i, 1)<>"" Si Cellules (i, 2) = "Écureuil 1" Alors n = n - Cellules (i, 3) Sinon n = n + Cellules (i, 4) Fin Si i = i + 1 Boucle MsgBox n End Sub

Le résultat affiché dans le message d'information MsgBox sera 40. Vous pouvez copier le tableau dans une feuille de calcul Excel et expérimenter le code VBA.

Boucle infinie et sortie Do

Exemple de boucle infinie :

Sub test4() Dim a As Byte Do While a< 10 a = a + 1 If a = 9 Then a = 0 End If Loop End Sub

Lorsque cette procédure est exécutée, la boucle Do While... commence à s'exécuter sans fin. J'ai dû arrêter les boucles VBA sans fin dans Excel 2000 et Excel 2016. Dans Excel 2000, le raccourci clavier m'a aidé Ctrl+Pause, et dans Excel 2016, lorsque vous fermez l'éditeur VBA avec une croix, une fenêtre apparaît :

Il ne sert à rien d'attendre que le programme réponde, alors cliquez sur « Redémarrer le programme » ou « Fermer le programme ».

Exemple d'utilisation de l'opérateur Quitter Faire:

Sub test5() Dim a As Byte, n As Long Do While a< 10 a = a + 1 n = n + 1 If a = 9 Then a = 0 End If If n = 1000 Then Exit Do End If Loop MsgBox n End Sub

Lorsque la boucle atteint 1 000 itérations, elle se termine et le message d'information MsgBox affichera le nombre de fois que la boucle Do While... de cet exemple a été répétée.

faire des boucles while et foreach

faire une boucle . . alors que

faire...en boucle en C#, il s'agit d'une version de while avec une vérification post-condition. Cela signifie que la condition de la boucle est vérifiée après l'exécution du corps de la boucle. Par conséquent, les boucles do...while sont utiles dans les situations où un bloc d'instructions doit être exécuté au moins une fois. Voici la forme générale d'une instruction de boucle do-while :

do (opérateurs; ) while (condition);

S’il n’y a qu’un seul opérateur, les accolades dans cette forme de notation sont facultatives. Cependant, ils sont souvent utilisés pour rendre la construction do-while plus lisible et à ne pas confondre avec la construction de la boucle while. La boucle do-while s'exécute tant que l'expression conditionnelle est vraie. Un exemple d'utilisation d'une boucle do-while est le programme suivant, qui calcule la factorielle d'un nombre :

Utilisation du système ; en utilisant System.Collections.Generic ; en utilisant System.Linq ; en utilisant System.Text ; espace de noms ConsoleApplication1 ( class Program ( static void Main(string args) ( try ( // Calculer la factorielle d'un nombre int i, result = 1, num = 1; Console.WriteLine("Entrez un nombre :"); i = int .Parse(Console .ReadLine()); Console.Write("\n\nFactorial (0) = ", i); do ( result *= num; num++; ) while (num

boucle foreach

boucle foreach sert à l'accès cyclique aux éléments d'une collection, qui est un groupe d'objets. C# définit plusieurs types de collections, chacune étant un tableau. Voici la forme générale de l'instruction de boucle foreach :

instruction foreach (tapez loop_variable_name dans la collection) ;

Ici tapez nom_variable_boucle désigne le type et le nom de la variable de contrôle de boucle qui reçoit la valeur de l'élément suivant de la collection à chaque étape de la boucle foreach. Et collection désigne une collection interrogée cycliquement, qui représente ci-après un tableau. Par conséquent, le type de la variable de boucle doit correspondre au type de l’élément du tableau. De plus, un type peut être désigné par le mot-clé var. Dans ce cas, le compilateur détermine le type de la variable de boucle en fonction du type de l'élément du tableau. Cela peut être utile pour travailler avec certains types de requêtes. Mais en règle générale, le type est spécifié explicitement.

L'instruction de boucle foreach fonctionne comme suit. Lorsque la boucle démarre, le premier élément du tableau est sélectionné et affecté à la variable de boucle. À chaque étape d'itération suivante, l'élément suivant du tableau est sélectionné et stocké dans une variable de boucle. La boucle se termine lorsque tous les éléments du tableau sont sélectionnés.

Une boucle foreach vous permet de parcourir chaque élément d'une collection (un objet qui représente une liste d'autres objets). Techniquement, pour qu'un élément soit considéré comme une collection, il doit prendre en charge l'interface IEnumerable. Des exemples de collections incluent des tableaux C#, des classes de collection de l'espace de noms System.Collection et des classes de collection personnalisées.

Cet article couvrira deux autres cycles : alors que Et faire pendant. Ils se ressemblent beaucoup. Leur syntaxe est :

Fig.1 - syntaxe while
Fig.2 - syntaxe do while

La seule différence est que lorsque la boucle démarre alors que, l'état est vérifié immédiatement. S'il renvoie faux ( FAUX), alors le corps de la boucle ne sera pas exécuté une seule fois. Et lors de l'utilisation faire pendant, le ou les opérateurs dans le corps de la boucle seront exécutés immédiatement, puis la condition entre parenthèses sera vérifiée () après le mot clé alors que. Et de même, au retour FAUX, la boucle se termine ; sinon, l’étape suivante (itération) est exécutée. C'est-à-dire le corps de la boucle faire pendant sera exécuté au moins une fois, dans n'importe quel scénario.

Parlons-en séparément. Commençons avec alors que. Comme mentionné ci-dessus, pour que le corps de la boucle soit exécuté, il faut que lors de la vérification des conditions entre parenthèses () , true a été renvoyé.

La condition est vérifiée et le corps est exécuté jusqu'à ce que la condition revienne FAUX. Il en résulte que pour interrompre le cycle, quelque chose doit se produire dans son corps, ce qui affectera la vérification de l'état.

Il peut s'agir de la valeur d'une variable saisie par l'utilisateur au clavier, présente dans la condition de test de la boucle. Il peut également s'agir d'une augmentation ou d'une diminution de la variable de contrôle, qui est également impliquée dans les conditions de test.

Prenons un exemple de modification de la valeur d'une variable de contrôle dans le corps d'une boucle. Énoncé du problème : l'utilisateur souhaite recharger son compte carte via le terminal. Il saisit le montant au clavier. Donnez au programme la possibilité de modifier un montant saisi par erreur.

Exemple - boucle while C++

#inclure en utilisant l'espace de noms std ; int main() ( setlocale(LC_ALL, "rus"); double paiement = 0; int exit = 1; // variable de contrôle while (exit == 1) ( cout<< "Введите сумму для пополнения счета: "; cin >> paiement ; cout<< "Оплатить и выйти - нажмите 0. Изменить сумму - нажмите 1: "; cin >> sortir; // change la variable de contrôle ) cout<< "\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n"; cout << "Ваш счет пополнен на " << payment << "$ Спасибо! До свидания!"; cout << "\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n"; return 0; }

#inclure en utilisant l'espace de noms std ; int main() double paiement = 0 ; int sortie = 1 ; // variable de contrôle pendant que (sortie == 1 ) cout<< ; cin >> paiement ; cout<< ; cin >> sortie ; // change la variable de contrôle cout<< ; cout<< "Votre compte a été réapprovisionné avec "<< payment << "$Merci ! Au revoir !"; cout<< "\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~\ n\n"; renvoie 0 ;

Variable de contrôle sortie déclaré et initialisé à un avant la boucle alors que– ligne 9. Par conséquent, lors de l’entrée dans la boucle, vérifier la condition pendant que (sortie == 1) reviendra vrai(vous pouvez en savoir plus à ce sujet) et le programme procédera à l’exécution du corps de la boucle. Cette condition s’écrit souvent ainsi : pendant que (sortie). Avec cette condition, le programme fonctionne comme le précédent. Ceci s'explique par le fait que toute valeur de la variable sortie non nul sera interprété par le compilateur comme vrai. Le corps de la boucle sera exécuté jusqu'à ce que l'utilisateur change la valeur de cette variable à 0. Ensuite pendant que (sortie) sera équivalent tandis que (0). Autrement dit, la condition du test est fausse. Cette entrée est plus courante car elle est plus courte, bien qu'elle ne soit pas aussi claire que celle de l'exemple. Il faut juste s'y habituer.

Aux lignes 16 à 17, l'utilisateur se voit poser une question et doit faire un choix : cout<< “Оплатить и выйти – нажмите 0. Изменить сумму – нажмите 1: “; Autrement dit, s'il s'est trompé lors de la saisie du montant du réapprovisionnement, il a la possibilité de la corriger en appuyant sur 1.

Dès que l'utilisateur saisit le montant correct et appuie sur 0 (ce qui correspond à « Payer et quitter »), la boucle se terminera et le programme continuera à fonctionner. En conséquence, un message sur le montant du réapprovisionnement du compte apparaîtra à l'écran - lignes 20 à 22.

Résultat:

Le même problème peut être résolu en utilisant une boucle faire pendant. Dans ce cas, initialement la valeur de la variable sortieça pourrait être n'importe quoi. Dans tous les cas, la boucle exécutera le corps et proposera de faire un choix. Regardons:

#inclure en utilisant l'espace de noms std ; int main() ( setlocale(LC_ALL, "rus"); double paiement = 0; int exit = 0; do ( cout<< "Введите сумму для пополнения счета: "; cin >> paiement ; cout<< "Оплатить и выйти - нажмите 0. Изменить сумму - нажмите 1: "; cin >> sortir; ) while (sortie == 1); cout<< "\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n"; cout << "Ваш счет пополнен на " << payment << "$ Спасибо! До свидания!"; cout << "\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n"; return 0; }

#inclure en utilisant l'espace de noms std ; int main() setlocale(LC_ALL, "rus"); double paiement = 0 ; int sortie = 0 ; cout<< « Saisissez le montant pour recharger votre compte : »; cin >> paiement ; cout<< "Payez et sortez - appuyez sur 0. Modifiez le montant - appuyez sur 1 : "; cin >> sortie ;