Boucles For et while, instructions break et continue, le mot magique else. Javascript while, do-while et for boucles

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, suivies de while, et la boucle do while est très rare.

Et nous allons commencer par la 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 une boucle infinie et ensuite 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, les accolades ne sont pas nécessaires.

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 n'apparaisse pas sur une seule ligne, après chaque 10ème itération, nous passons à une 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.

Cette leçon examine l'opérateur conditionnel en Pascal ( si). Explique comment utiliser plusieurs conditions dans une seule construction ( ET Et OU). Des exemples de travail avec un opérateur sont considérés

Nous vous rappelons que ce site n'a pas la prétention de fournir une présentation complète des informations sur le sujet. Le but du portail est de fournir la possibilité d'apprendre du matériel basé sur des exemples résolus prêts à l'emploi sur le thème « Langage de programmation Pascal » avec des tâches pratiques pour renforcer le matériel. Les tâches Pascal présentées sur le site sont classées séquentiellement à mesure que leur complexité augmente. Le site Web peut être utilisé par les enseignants et les conférenciers comme aide visuelle auxiliaire.

Avant d'aborder ce sujet, on utilisait principalement des algorithmes linéaires en Pascal, typiques des problèmes très simples lorsque les actions (opérateurs) sont exécutées séquentiellement, les unes après les autres. Des algorithmes plus complexes impliquent l’utilisation d’une construction de branchement.

Schéma fonctionnel de l'opérateur conditionnel :

L'instruction conditionnelle en Pascal a la syntaxe suivante :

Version courte :

si condition alors déclaration ;

Version complète :

if condition then instruction else instruction ;

L'opérateur conditionnel en Pascal - si - sert à organiser la progression d'une tâche de telle manière que la séquence d'exécution des opérateurs change en fonction d'une condition logique. Une condition logique peut prendre l'une des deux valeurs suivantes : respectivement vraie ou fausse, elle peut être vraie ou fausse.

Opérateur composé

Si, dans une condition vraie, il est nécessaire d'exécuter plusieurs instructions, alors Selon les règles du langage Pascal, ils doivent être enfermés dans un bloc, commençant par le mot de fonction début et se terminant par le mot de fonction fin . Un tel bloc est généralement appelé supports d'opérateur, et cette construction - opérateur composé:

Opérateur parenthèses et opérateur composé en Pascal :

si expression logique, alors commencez l'instruction 1 ;

opérateur2 ; fin sinon début instruction1 ;

opérateur2 ; fin;	La traduction de l’anglais de l’opérateur de condition facilitera la compréhension de son utilisation :	SI
ALORS	AUTRE	SI

QUE
SINON

• La condition (dans une expression logique) utilise des opérateurs relationnels.
• Considérez la liste des opérateurs relationnels de Pascal :
• supérieur ou égal à en Pascal >=
• inférieur ou égal à en Pascal
• comparaison en Pascal =
• pas égal en Pascal

Exemple: trouver le plus grand de deux nombres

Option 1	Option 2

Comprendre le travail en détail vous pouvez utiliser l'opérateur conditionnel en Pascal en regardant le didacticiel vidéo :

Exemple: calculer la valeur de la variable y en utilisant l'une des deux branches

Afficher la solution :

var x,y:réel; commencer writeln("entrez x"); lire(x); si x>0 alors y:=ln(x) sinon y:=exp(x); writeln ("y=", y:6:2) (le nombre résultant occupera 6 positions et aura 2 décimales) end.

Remarquez comment y est affiché dans cet exemple. Lors de la déduction de variables de type en pascal, vous pouvez utiliser ce qu'on appelle sortie formatée, ou notation avec deux deux-points :
y:6:2
- le chiffre après le premier deux-points (6) indique le nombre de caractères que le numéro occupera lorsqu'il sera affiché à l'écran
- le nombre après le deuxième deux-points (2) indique combien de décimales du nombre réel seront affichées

Ainsi, utiliser une telle notation en pascal permet pratiquement d'arrondir aux centièmes, millièmes, etc.

Tâche 0. Calculez la valeur de la variable y en utilisant l'une des deux branches :

Tâche 1. Deux nombres sont saisis dans l'ordinateur. Si le premier est supérieur au second, calculez leur somme, sinon le produit. Après cela, l'ordinateur devrait imprimer le résultat et le texte PROBLÈME RÉSOLU

Tâche 2. Le dragon fait pousser trois têtes chaque année, mais après l’âge de 100 ans, il n’en reste plus que deux. Combien de têtes et d’yeux a un dragon ? N années?

Opérations logiques en Pascal (en expression logique)

Lorsque vous devez utiliser une double condition en Pascal, vous aurez besoin d’opérations logiques.

• Opération logique ET (Et), placé entre deux conditions, dit que ces deux conditions doivent être remplies en même temps (doit être vraie). Le sens logique de l’opération est « conjonction ».
• Placé entre deux conditions, le signe OU (OR) dit qu'il suffit qu'au moins une d'entre elles soit satisfaite (une des deux conditions est vraie). Le sens logique de l’opération est « disjonction ».
• En Pascal XOR - un signe d'une opération logique qui a le sens de « disjonction stricte » et indique qu'il faut que l'une des deux conditions soit remplie (vrai), et l'autre non satisfaite (faux).
• Opération logique PAS devant une expression logique ou une variable, cela signifie « négation » ou « inversion » et indique que si une variable ou une expression donnée est vraie, alors sa négation est fausse et vice versa.

Important: Chaque condition simple doit être mise entre parenthèses.

Exemple: Regardons des exemples d'opérations logiques dans des expressions logiques en Pascal

1 2 3 4 5 6 7 8

var n : entier ;<10 ) then writeln ("истина" ) ; if (n>début n : = 6 ;<10 ) then writeln ("истина" ) ; if (n>si (n>5 ) et (n<10 ) then writeln ("истина" ) ; if not (n>7 ) ou (n

7)xor(n<10) then writeln("истина"); if (n>7) puis writeln("true");<10) then writeln("истина"); if (n>fin.<10) then writeln("истина"); if not(n>var n:entier; commencer n :=6 ; si (n>5) et (n

Exemple: 7) ou (n
7)xor(n 7) puis writeln("true"); fin.

Exemple: L'entreprise recrute des salariés de 25 à 40 ans inclus. Saisissez l'âge de la personne et déterminez si elle convient à cette entreprise (affichez la réponse « convenable » ou « ne convient pas »).

Particularité: nous devons vérifier si deux conditions sont remplies simultanément.

Étant donné un nombre entier A. Vérifiez la véracité de l’énoncé : « Le nombre A est impair. » Ramification

(instruction conditionnelle) est une construction de langage de programmation qui garantit l'exécution d'une commande ou d'un ensemble de commandes spécifique uniquement si une certaine expression logique est vraie, ou l'exécution d'une parmi plusieurs commandes (ensembles de commandes) en fonction de la valeur d'un certain expression.

Faire du vélo

est un type de structure de contrôle conçu pour organiser l'exécution multiple d'un ensemble d'instructions. Les branchements et les boucles individuelles sont basés sur des opérateurs de comparaison logiques qui déterminent s'il faut exécuter les lignes de code suivantes ou passer aux autres. Opérateurs de comparaison

• Majorité
• opérateurs de comparaison
• < оператор «меньше»
• <= оператор «меньше или равно»
• applicable aux valeurs numériques. Ce sont tous des opérateurs binaires qui ont deux arguments numériques mais renvoient une valeur booléenne.
• > opérateur "supérieur à"

>= opérateur supérieur ou égal != Opérateur "différent"== opérateur d'équivalence

Les deux derniers

opérateur de comparaison

sont utilisés non seulement pour les valeurs numériques, mais aussi pour les valeurs logiques. La comparaison de deux opérateurs de texte s'effectue à l'aide des méthodes equals(String object), equalsIgnoreCase(String object).

Il est très important de ne pas confondre l’opérateur d’équivalence avec l’opérateur d’affectation. Dans les expressions contenant des opérateurs de types différents, les opérations arithmétiques sont effectuées en premier, puis les opérations de comparaison, puis les opérations logiques et enfin l'affectation.

Tout comme pour les opérateurs arithmétiques, les parenthèses sont utilisées pour ajuster la priorité d'une opération. Si une paire de parenthèses est imbriquée dans une autre paire de parenthèses, la valeur entre parenthèses intérieures est évaluée en premier.

Exemples d'utilisation d'opérateurs logiques

Booléen a = vrai ; booléen b; booléen c; b = une || vrai; // b est vrai b = !b; // b faux System.out.println(b); // affiche la valeur false sur la console a = a || b; // a est vrai c = a && (a || b); // avec vrai System.out.println(c); // affiche sur la console la valeur true boolean m; booléen w; m = 5 >= 4 ; // vrai m = 5 != 5 || FAUX; // faux w = m == faux ; // true System.out.println(w); // affiche la valeur true sur la console

Opérateurs de succursales

Syntaxe de l'instruction de branche si sinon

If (condition)( ... // opérateur composé n° 1 ) else ( ... // opérateur composé n° 2 )

Si une instruction composée dans la branche principale ou alternative d'une instruction de contrôle ne contient qu'une seule instruction simple, les accolades peuvent être omises. Dans ce cas, la syntaxe de l'opérateur de branche prendra la forme :

Si (condition) ... // opérateur simple n°1 ; sinon... simple déclaration n°2 ;

L'objectif principal de l'opérateur de branchement est de mettre en œuvre des algorithmes de branchement. Par exemple, un fragment d'un programme pour calculer la fonction : Y(x) = x*x, pour x< 0 и Y(x) = 2*x, при x >= 0

Int x, y ; // Lecture des valeurs x, y depuis la console Scanner in = new Scanner(System.in); System.out.println("Entrez x:"); x = in.nextLine(); System.out.println("Entrez y:"); y = in.nextLine(); si(x< 0) y = x*x; else y = 2*x; System.out.printf ("Результат: %i\n", y);

Lors de la construction de programmes avec plusieurs instructions de branchement consécutives, la règle suivante doit être prise en compte : instruction autre fait référence à la dernière déclaration si. Par exemple, considérons un fragment de programme :

Si (x > 10,0) y = 2*x + 5 ; si (y< z) y = fabs(x); else y = 2.5*x;

S'il est nécessaire de rompre cet ordre (c'est-à-dire une succursale autre se référer au premier opérateur si), alors il faut inclure la deuxième instruction if dans l'opérateur composé de la branche directe de la première instruction if :

Si (x > 10,0) ( y = 2*x + 5; si (y< z) y = fabs(x); } else y = 2.5*x;

En programmation, il est souvent nécessaire de créer des instructions de branchement en cascade. La syntaxe d'une telle structure est :

Si (condition n° 1) (énoncé composé n° 1) sinon si (condition n° 2) (énoncé composé n° 2) ... ( ) sinon si (condition n° N) (énoncé composé n° N) sinon (déclaration composée n° N+ 1)

Branchement multivarié, instruction switch

Conception si sinon peut être gênant si vous devez choisir parmi plusieurs options. Opérateur changer fournit un moyen clair de basculer entre différents morceaux de code en fonction de la valeur d'une seule variable ou expression. La forme générale de cet opérateur est :

Switch (choix) (valeur de cas1 : pause ; valeur de cas2 : pause ; valeur de cas : pause ; valeur par défaut : )

L'exécution du code commence au niveau de l'étiquette cas, correspondant à la valeur de l'expression choix, et continue jusqu'à l'instruction suivante casser ou fin de déclaration changer. Si aucune étiquette ne correspond à la valeur de la variable, la section par défaut est exécutée, si elle est fournie.

Notez que l'étiquette cas doit être un entier. Vous ne pouvez pas vérifier les chaînes. Toutes les valeurs de cas doivent être des littéraux uniques. Si deux instructions case contiennent les mêmes valeurs, le traducteur générera un message d'erreur.

Notez que l'instruction par défaut est facultative. Dans le cas où aucune des instructions case ne correspond à la valeur de l'expression et dans changer il n'y a pas d'instruction par défaut. L'exécution du programme continue avec l'instruction qui suit l'instruction switch.

Si case ne se termine pas par une instruction break, alors après la section case en cours, la suivante sera exécutée. Parfois, il est pratique d'avoir plusieurs sections case contiguës dans une instruction switch, non séparées par une instruction break.

boucles Java

Il existe deux types de boucles en Java :

• boucle comme « while » - while et do… while
• tapez "n-time" - pour (initialisation ; condition ; itération)

Le premier type de « pendant » est conçu pour répéter une action tant qu’une certaine condition est remplie. Exemple : augmenter la valeur d'une variable de 3 jusqu'à ce qu'elle atteigne trois chiffres.

Le deuxième type « n-time » est destiné à répéter certaines actions un nombre de fois prédéterminé. Exemple : trouver la factorielle de 6.

Boucles while et do... while

Opérateur alors que répète les actions spécifiées tant que son expression a une vraie valeur.

Syntaxe de la boucle While

While (expression logique) ( ​​... // corps de la boucle )

Un exemple de sortie de valeurs de tableau sur la console :

String lst = ("Hiver", "Été", "Automne", "Printemps"); int je = 0; pendant que(i++< lst.length){ System.out.print(lst[i] + " "); }

La condition de nécessité de répéter le cycle est vérifiée avant chaque étape du cycle, y compris la toute première.

Java offre également la possibilité d'utiliser une boucle avec des tests post-conditions. Pour l'écrire, on utilise une construction d'opérateurs faire... pendant que.

Do ( ... // corps de la boucle ) while (expression logique)

La boucle suivante sera exécutée 4 fois et "1 2 3 4" sera imprimé sur la console :

Int je = 0 ; faire ( i++; System.out.print(Integer.valueOf(i) + " "); ) while(5 > i);

Corps en boucle faire... pendant que exécuté au moins une fois. Cet opérateur est pratique à utiliser lorsqu'une action du programme doit être effectuée au moins une fois, mais dans certaines conditions, elle devra être répétée plusieurs fois.

pour la boucle

Opérateur pour contient trois paramètres : paramètre d'initialisation, paramètre de répétition, paramètre d'itération.

pour la syntaxe de la boucle

For (initialisation; condition; itération) ( // corps de la boucle, c'est-à-dire actions répétées cycliquement)

Le premier paramètre définit une variable qui servira à compter le nombre de répétitions de la boucle. Cela s'appelle un compteur. Le compteur reçoit une valeur initiale (ils indiquent à partir de quelle valeur il va changer). Le deuxième paramètre indique une certaine limitation sur le compteur, c'est-à-dire à quelle valeur cela changera. Le troisième paramètre spécifie une expression qui modifie le compteur après chaque étape de boucle. Il s'agit généralement d'un incrément ou d'un décrément, mais vous pouvez utiliser n'importe quelle expression dans laquelle le compteur se verra attribuer une nouvelle valeur.

Le programme présenté affiche les valeurs du tableau sur la console :

String lst = ("Hiver", "Été", "Automne", "Printemps"); // dans l'ordre direct pour (int i = 0; i< lst.length; i++) { System.out.print(lsti] + " "); } // в обратном порядке for (int i = (lst.length - 1); i >= 0 ; i--) ( System.out.print(lsti] + " "); )

En un seul cycle, vous pouvez régler plusieurs compteurs à la fois. Pour ce faire, vous devez séparer plusieurs expressions en itération et initialisation par des virgules. Une seule condition de répétition peut être spécifiée, mais il peut s'agir d'une expression contenant plusieurs compteurs à la fois.

Le code présenté affichera la séquence suivante sur la console : « 0 -1 -4 -9 -16 -25 »

Pour(int a = 0, b = 0; a - b<= 10; a++, b--){ System.out.print(" " + a*b); }

Interrompre un cycle, pause

Pour terminer la boucle plus tôt, utilisez l'opérateur casser. Dans ce cas, il y a une sortie immédiate du cycle ; l'étape en cours ne sera pas terminée. Ceux. s'il y avait d'autres instructions après la pause, elles ne seront pas exécutées.

Exemples de boucles d'interruption :

// Interrompt la boucle for for (int a = 1; a<= 10; a++){ if (a == 5) break; System.out.println("a = " + a); } // Прерывание цикла while int s = 100; while(true) { System.out.print(s +" "); s = s / 2; if (s == 0) break; System.out.println("s = " + s); }

Interrompre la boucle, continuer

Pour interrompre la boucle, vous pouvez utiliser l'opérateur continuer. Contrairement à l'instruction break, qui termine la boucle, l'instruction continue interrompt uniquement l'étape en cours de la boucle et transfère le contrôle au début de la boucle.

// Interrompt la boucle while int s = 100; while(true) ( ​​​​​​System.out.print(s +" "); s = s / 2; if (s == 25) continue; else if (s == 0) ( break; ) else System.out .println ("s = " + s);

Dans l'exemple, si la valeur de s est égale à 25, la prochaine itération de la boucle sera interrompue et le contrôle sera transféré au début de la boucle.

Si l'opérateur continuer utilisé en boucle pour, il transférera alors le contrôle à l'opérateur d'incrémentation du compteur de boucle.

C++ fournit un ensemble standard d'opérateurs pour sélectionner une sélection et des cycles.

Les mots-clés liés à la construction des conditions de branchement pour le code sont :

• changer
• casser
• défaut

Les mots clés relatifs à la construction des cycles sont :

• alors que
• casser
• continuer

Déclarations de conditions

L'instruction If

La construction de condition utilisant l'instruction if est formée comme suit :

Int x = 56 ; bool check_x() ( si (x > 0) renvoie vrai ; renvoie faux ; )

Dans ce cas, la condition est placée entre parenthèses après l’instruction if. Dans cette construction, le code retour est vrai ; Sera exécuté si x est supérieur à 0. la ligne suivante renvoie false ; Ne s'applique plus au code qui sera exécuté lorsque la condition sera remplie. Dans les constructions de conditions, si cette condition est remplie, une seule ligne de code sera exécutée si le code n'est pas entouré d'accolades, c'est-à-dire si le corps du code exécuté sous condition n'est pas formé. Considérons deux options du code :

Première possibilité :

Int x = 56 ; bool check_x() ( if (x > 0) x = 0; return true; return false; )

Dans ce code, retournez true ; Sera toujours exécuté, car seule la chaîne x = 0 est pertinente pour le code en cours d'exécution ;

Deuxième option :

Int x = 56 ; bool check_x() ( if (x > 0) ( x = 0; return true; ) return false; )

Dans ce code, retournez true ; Ne sera satisfait que si la condition x> 0 est satisfaite.

La déclaration else

Le autre La déclaration est utilisée conjointement avec la si instruction pour former une séquence de conditions.

Int x = 56 ; bool check_x() ( if (x > 0) ( x = 0; return true; ) else if (x< 0) { x = 0; return false; } else { return false; } }

L'instruction else peut être utilisée pour ajouter une nouvelle condition si la condition précédente, l'instruction else if, échoue. Et comme code final dans une séquence de conditions, si les conditions précédentes n'étaient pas remplies. Alternativement, il est possible d'utiliser les accolades pour le corps du code si le code tient sur une seule ligne.

Instruction switch, case, break, default

Le boîtier de commutation La construction permet de sélectionner le branchement du code, dans lequel le choix se fait par valeurs entières. Cela signifie que le cas de commutation peut être utilisé uniquement pour des valeurs entières, des énumérations et des sélections par le code du symbole.

Int x = 100 ; bool check_x() ( switch (x) ( cas 0 : retour vrai ; cas 50 : x = 0 : pause ; cas 100 : retour faux ; par défaut : retour faux ; )

Dans le code ci-dessus, la variable x est vérifiée pour être égale aux nombres 0, 50, 100. L'opérateur par défaut sélectionne le code qui est exécuté si aucune des conditions n'est remplie. Notez également que dans le bloc de code avec le cas 50 : ajout d'une instruction break, cette instruction quitte la condition, tandis que l'instruction return quitte la fonction. Si vous n'ajoutez pas d'instruction break, l'exécution du code continuera dans le cas 100 :. Grâce à cette particularité de construction du boîtier de commutation, il est possible de combiner des conditions pour lesquelles il est nécessaire d'exécuter le même code. Par exemple:

Int x = 100 ; bool check_x() ( switch (x) ( case 0 : case 50 : case 100 : return true; par défaut : return false; ) )

, pour x égal à 0, 50, 100, la fonction renvoie vrai, tandis que pour toutes les autres valeurs, la fonction renvoie faux.

De plus, le code de sélection de la casse dans cette construction peut être encapsulé dans des blocs de code, ce qui limitera la portée et utilisera des déclarations de variables portant le même nom.

Int x = 100 ; int check_x() ( switch (x) ( case 0 : ( int y = 1 ; return y; ) case 50 : ( int y = 2 ; return y; ) case 100 : ( int y = 3 ; return y; ) par défaut : retourner x; ) )

Ainsi, en limitant la portée, nous pouvons utiliser des variables portant les mêmes noms dans des conditions de cas. Mais n'oubliez pas qu'en dehors du périmètre, délimité par des accolades, la variable y n'existera pas dans ce cas.

Opérateurs de cycles

L'instruction while

L'instruction while répète le code dans son corps tant que la condition est remplie. Par exemple:

Int je = 0 ; pendant que (je< 10) { i = i + 1; }

Dans ce code, j'aurai 10 après la boucle.

L'instruction do

L'instruction do est utilisée conjointement avec l'instruction while et permet d'exécuter le corps de la boucle au moins une fois, avant que la condition de la boucle ne soit vérifiée. Par exemple:

Int je = 15 ; faire ( je = je - 5; std :: cout<< i << std::endl; } while (i >0 && je< 13);

Dans ce code, la variable I ne correspond pas initialement à la condition et dans la boucle while habituelle, le code du corps de la boucle n'a pas été exécuté, mais comme la boucle do-while est utilisée, le test sera effectué après que le corps de la boucle soit exécuté. En conséquence, le résultat de std::cout est :

Vous pouvez demander pourquoi y a-t-il 0 dans la sortie ? Cela ne correspond pas à la condition. Encore une fois, cela est dû au fait que la vérification est effectuée après l'exécution du code dans le corps de la boucle. C'est-à-dire que le corps de la boucle a été exécuté, puis une vérification est effectuée, à la suite de laquelle le cycle termine son travail.

La déclaration de pause

Comme dans le cas switch, cette instruction peut être utilisée dans des boucles. Ceci est nécessaire pour sortir de la boucle, avant que la condition du cycle ne soit remplie. Par exemple:

Int je = 15 ; pendant que (je< 50) { if (i < 0) { break; } i = i - 5; }

Dans cet exemple artificiel, il en résulterait un cycle éternel car la variable i diminue au lieu d'augmenter, et par la condition de la boucle, la sortie ne sera produite que si i est supérieur à 50. Mais grâce à l'instruction break et à la condition de test pour la valeur négative de la variable i L'exécution du programme sortira de cette boucle dès que i deviendra inférieur à 0.

La déclaration continue

Cet opérateur permet d'abandonner l'itération d'une boucle et de démarrer une nouvelle itération de la boucle avant d'exécuter tout le code du corps de la boucle. Par exemple:

Int je = 0 ; pendant que (je< 5) { if (i == 3) { i = i + 1; continue; } std::cout << i << std::endl; i = i + 1; }

Lors de l'exécution de ce code, nous obtenons le résultat suivant :

Autrement dit, la sortie du numéro 3 sera omise.

La déclaration pour

Les boucles avec l'instruction for permettent de combiner l'initialisation de variables, la condition et le changement de ces variables.

Autrement dit, la boucle while suivante

Int je = 0 ; pendant que (je< 10) {

Ce sera équivalent à la boucle for suivante :

Pour (int je = 0; je< 10; i++) { // ToDo Something }

L'avantage de cette boucle for sera que la variable I sera dans la portée locale de la boucle for.

Les boucles For peuvent être initialisées avec plusieurs variables du même type. Par exemple:

Pour (int i = 0, *p = i< 9; i += 2) { std::cout << i << ":" << *p << " "; }

Aussi, la condition peut être une déclaration, une initialisation d'une variable. Par exemple:

Char cstr = "Bonjour" ; pour (int n = 0; char c = cstr[n]; ++n) ( std::cout<< c; }

Compte tenu de la norme C++ 11, la variable auto peut être utilisée comme type de variable, ce qui vous permet d'afficher le type de variable à partir de l'initialiseur :

Std :: vecteur v = (3, 1, 4, 1, 5, 9) ; for (auto iter = v.begin(); iter != v.end(); ++iter) ( std::cout<< *iter << " "; }

Un autre point intéressant est que l'initialiseur, la condition et le bloc de changement peuvent être l'expression :

Int n = 0 ; pour (std :: cout<< "Loop start\n"; std::cout << "Loop test\n"; std::cout << "Iteration " << ++n << "\n") { if(n >1) pause ; )

À partir de la norme C++11, les boucles for, l'itération a été ajoutée pour les conteneurs prenant en charge l'itération. Par exemple, le conteneur vectoriel de la bibliothèque standard :

Std :: vecteur v = (0, 1, 2, 3, 4, 5) ; pour (const int& i: v) std :: cout<< i << " ";

Dans ce code, la construction de la boucle est la suivante :

Pour (Récupéré du conteneur à chaque itération de l'objet : conteneur) ( // Corps du cycle )

De plus, les boucles for basées sur une plage prennent en charge l'instruction auto. Par exemple:

Std :: vecteur v = (0, 1, 2, 3, 4, 5) ; pour (auto& i: v) std :: cout<< i << " ";

Dans cet article, je parlerai de boucles for et while, opérateurs casser Et continuer, et aussi sur le mot autre, qui, lorsqu'il est utilisé avec une boucle, peut rendre le code du programme un peu plus compréhensible.

boucle while

While est l'une des boucles les plus polyvalentes de Python, elle est donc assez lente. Exécute le corps de la boucle tant que la condition de la boucle est vraie.

>>> i = 5 >>> tandis que je< 15 : ... print (i ) ... i = i + 2 ... 5 7 9 11 13

pour la boucle

La boucle for est un peu plus compliquée, un peu moins universelle, mais elle s'exécute beaucoup plus rapidement que la boucle while. Cette boucle parcourt n'importe quel objet itérable (tel qu'une chaîne ou une liste) et exécute le corps de la boucle à chaque passage.

>>> pour i dans "hello world" : ... print (i * 2 , end = "" ) ... hheelllloo wwoorrlldd

Continuer l'opérateur

L'instruction continue commence la prochaine itération de la boucle, en contournant le corps restant de la boucle (for ou while)

>>> for i in "hello world" : ... if i == "o" : ... continue ... print (i * 2 , end = "" ) ... hheellll wwrrlldd

instruction de pause

L'instruction break termine la boucle plus tôt.

>>> for i in "hello world" : ... if i == "o" : ... break ... print (i * 2 , end = "" ) ... hheellll

Le mot magique autrement

Le mot else utilisé dans une boucle for ou while vérifie si la boucle a été quittée par une instruction break ou de manière "naturelle". Le bloc d'instructions à l'intérieur de else ne sera exécuté que si la boucle s'est terminée sans l'aide de break.

>>> for i in "hello world" : ... if i == "a" : ... break ... else : ... print ( "La lettre a n'est pas dans la ligne") ... Il n'y a pas de lettre a dans la ligne