Les instructions de contrôle sont des instructions exécutables qui modifient la séquence d'exécution des instructions du programme. De toutes les instructions utilisées dans les langages de programmation, les instructions de contrôle ont causé le plus de controverses. Le principal sujet de discussion est l'instruction de contrôle goto la plus simple. Il vous permet de modifier l'ordre dans lequel le programme est exécuté et de sauter à l'exécution du programme en commençant à un emplacement spécifique, qui est indiqué par un nom ou un numéro. Par conséquent, cette instruction n'est rien de plus qu'une application directe d'une instruction de saut en langage machine. La présence d'un tel opérateur dans le langage haut niveau permet aux programmeurs d'écrire de tels programmes non systématiques1 :

goto 40 20 Appliquer la procédure Evade

aller à 70 40 si (KryptoniteLevel< LethalDose) then goto 60

60 Appliquer la procédure RescueDamsel 70 ...

alors que toutes ces actions peuvent être écrites avec une seule structure :

si (KryptoniteNiveau< LethalDose)

then (appliquer la procédure RescueDamsel) else (appliquer la procédure Evade)

Pour éviter de telles complications, les langages de programmation modernes contiennent des instructions de contrôle qui permettent d'écrire des structures de branchement avec une seule expression. Certaines structures de branchement généralement acceptées et les opérateurs de contrôle qui leur correspondent dans différents langages de programmation sont illustrés à la Fig. 5.7. Notez que nous avons déjà rencontré les deux premières structures au chapitre 4. Dans notre pseudocode, elles sont représentées par des instructions if-then-else et while. La troisième structure, appelée choix, peut être considérée comme une extension de la structure si-alors-sinon. La différence entre eux est que l'instruction if-then-else vous permet de choisir parmi deux options, tandis que l'instruction case vous permet d'en choisir plusieurs.

Une autre structure courante est l'instruction de boucle for (Figure 5.8), similaire à l'instruction while de notre pseudocode. La différence entre eux est que l'initialisation, la modification et la vérification de la condition de fin de boucle sont combinées dans une seule instruction. Un tel opérateur est pratique à utiliser lorsque le corps de la boucle doit être exécuté un certain nombre de fois - une fois pour chaque valeur de la variable compteur dans un intervalle donné. En particulier, l'opérateur représenté sur la Fig. 5.8, indique que le corps de la boucle doit être exécuté plusieurs fois : lorsque la valeur de la variable Count est 1, puis lorsque sa valeur est 2, et la dernière fois lorsque sa valeur est 3.

À partir des exemples ci-dessus, nous pouvons conclure que les structures de branchement sont présentes avec des variations mineures dans les langages de programmation impératifs et orientés objet. En informatique théorique, on suppose que la solution de tout problème ayant une solution algorithmique peut être écrite en utilisant un nombre limité de structures. Nous discuterons de cette affirmation au chapitre 11. En attendant, il convient de noter que l'apprentissage d'un langage de programmation n'est pas une étude sans fin. divers opérateurs gestion. En fait, la plupart des structures de contrôle utilisées dans les langages de programmation modernes sont une variante des structures décrites dans ce chapitre.

Le choix des structures à inclure dans un langage de programmation est une question de goût. Le but du créateur d'un langage est de développer un langage qui permet non seulement d'écrire des algorithmes sous une forme lisible, mais aide également le programmeur à le faire. Cet objectif est atteint en limitant l'utilisation des éléments qui ont historiquement conduit à une programmation bâclée et en introduisant des éléments bien pensés. En conséquence, nous avons une programmation structurée, qui combine les méthodes d'écriture des programmes et l'utilisation correcte des instructions de contrôle. L'objectif est de créer un programme qui est facile à comprendre et qui fait ce qu'il est censé faire.

commentaires

L'expérience montre que lorsqu'une personne essaie de comprendre un programme volumineux, il n'est pas si important de savoir si le langage de programmation est bien pensé et comment ses fonctionnalités sont utilisées, si elles sont utiles ou même nécessaires. Informations Complémentaires présenté dans un langage humain normal. Par conséquent, les langages de programmation prévoient la possibilité de placer des commentaires explicatifs (commentaires) dans le programme. Le compilateur ignore les commentaires, donc leur présence ou leur absence n'a aucun effet sur le programme du point de vue de la machine. La version en langage machine du programme généré par le traducteur reste inchangée, avec ou sans commentaires. Mais les informations qu'ils contiennent sont importantes pour une personne. Sans elle, il serait impossible de comprendre des programmes vastes et complexes.

Visual Basic est un langage de programmation orienté objet. Il a été développé par Microsoft comme un outil par lequel les utilisateurs système opérateur Microsoft Windows pourraient développer leur propre interface utilisateur graphique. En fait, Visual Basic est plus qu'un simple langage de programmation. C'est un package de développement complet logiciel, qui permet au programmeur de créer une interface utilisateur à partir de composants spécifiques (tels que des boutons, des cases à cocher, des champs de texte, des barres de défilement, etc.) et de personnaliser ces composants en fonction de leurs besoins, en décrivant comment ils doivent répondre à certains événements. Par exemple, dans le cas d'un bouton, le programmeur peut décrire ce qui doit se passer lorsque le bouton est cliqué. Cette méthode de création de logiciels à partir de composants prédéfinis est la tendance actuelle dans le développement de logiciels.

En raison de la popularité de l'exploitation Systèmes Windows et la facilité d'utilisation du package Visual Basic, le langage Visual Basic est devenu l'un des langages de programmation les plus courants aujourd'hui. D'autre part, comme Visual Basic n'est compatible qu'avec outils logiciels par Microsoft, il n'est pas reconnu comme un langage de programmation à usage général.

Il existe deux manières principales de séparer les commentaires du texte du programme. L'une d'entre elles consiste à placer le commentaire entre parenthèses spéciales. Une autre méthode consiste à marquer le début d'un commentaire, qui peut occuper le reste de la ligne à droite du caractère. En C++, C# et Java, les deux façons d'écrire des commentaires sont possibles. Dans ceux-ci, un commentaire peut être placé entre les signes /* et */ ou commencer par //. Ainsi, en C++, C# et Java, les deux notations sont valides :

/* Ceci est un commentaire. */

// Ceci est un commentaire.

Il convient de dire quelques mots sur ce qui doit être écrit dans les commentaires. Les programmeurs débutants, lorsqu'on leur dit qu'il est nécessaire de fournir un programme avec des commentaires, généralement à une expression telle que

ApproachAngle - SlipAngle - HyperSpacelncine :

ajouter un commentaire "Soustraire HyperSpacelncine de SlipAngle et attribuer une valeur à la variable ApproachAngle". De tels commentaires ne rendent pas le programme plus compréhensible, mais ne font que l'allonger. Rappelez-vous que le but du commentaire est d'expliquer le programme, pas de le répéter. DANS cet exemple il est préférable d'expliquer pourquoi la valeur de la variable ApproachAngl est calculée (si ce n'est pas clair dans le programme). Par exemple, le commentaire : "La variable ApproachAngle est utilisée plus tard pour calculer la valeur de la variable ForceFiel dJetti sonVel ocity" est beaucoup plus utile que le précédent.

De plus, les commentaires placés entre les énoncés de programme rendent parfois le programme difficile à lire et à comprendre. Il est préférable de placer des commentaires sur un bloc de programme à un endroit, par exemple au début de celui-ci. C'est ainsi qu'une certaine section du programme est créée, qui contient une description de l'objectif et Caractéristiques générales bloc du programme où l'utilisateur peut trouver les explications nécessaires. Si vous utilisez cette technique pour tous les blocs du programme, alors le programme devient uniforme : chaque bloc est constitué de commentaires explicatifs, suivis d'une présentation formelle de ce bloc. Cette uniformité rend le programme beaucoup plus facile à lire.

Unités procédurales

Dans les chapitres précédents, nous avons parlé des avantages de diviser de grands programmes en petites unités gérables. Dans cette section, nous porterons notre attention sur le concept de procédure, qui est le principal moyen d'obtenir une représentation modulaire d'un programme écrit dans un langage de programmation impératif. Une procédure est également un outil utilisé dans un programme écrit dans un langage orienté objet pour décrire comment un objet doit répondre à diverses entrées.

Procédures

Une procédure est un ensemble d'instructions permettant d'effectuer une tâche que d'autres unités de programme peuvent utiliser comme outil abstrait. Le contrôle est transféré à la procédure (à l'aide d'une instruction de saut en langage machine) lorsque ses actions sont nécessaires, puis, une fois l'exécution de la procédure terminée, il est à nouveau renvoyé à l'unité de programme d'origine (Fig. 5.9). Le processus de transfert de contrôle à une procédure s'appelle un appel de procédure. L'unité de programme qui demande l'exécution d'une procédure sera appelée programme appelant ou unité appelante.

À bien des égards, une procédure est un petit programme composé d'instructions de déclaration suivies d'instructions exécutables qui définissent les actions à effectuer par la procédure. En règle générale, une variable déclarée dans une procédure est une variable locale, ce qui signifie qu'elle ne peut être utilisée que dans cette procédure. Cette approche élimine la confusion qui peut survenir si deux routines indépendantes utilisent des variables portant le même nom. Les variables dont l'effet n'est pas limité à une partie du programme sont appelées variables globales et sont disponibles n'importe où dans le programme. La plupart des langages de programmation utilisent à la fois des variables locales et globales.

Dans les langages de programmation que nous envisageons, la description de la procédure est quasiment la même que dans notre pseudocode (voir chapitre 4). Il commence par une expression appelée en-tête de procédure, qui contient, entre autres, le nom de la procédure. L'en-tête est suivi d'instructions qui définissent la procédure plus en détail.

Cependant, contrairement à notre pseudocode lâche, où nous avons demandé que la procédure soit exécutée avec une expression telle que "Apply procedure DeactivateCrypton", la plupart langues modernes La programmation permet d'appeler une procédure en spécifiant simplement son nom. Par exemple, si GetNames, SortNames et WriteNames sont les noms des procédures pour obtenir, trier et imprimer une liste de noms, alors le programme qui obtient la liste, la trie et l'imprime peut être écrit comme

Appliquez la procédure GetNames. Appliquer la procédure SortNames. Appliquer la procédure WriteNames.

Notez que puisque nous avons donné à chaque procédure un nom qui représente l'action que la procédure exécute, cette forme abrégée est une séquence de commandes qui reflète l'objectif du programme.

structuré les opérateurs - ce sont des constructions construites selon certaines règles d'autres opérateurs. Les déclarations structurées incluent :

Déclaration composée

Opérateur conditionnel

Opérateurs de sélection

Instructions de boucle

avec déclaration

1. Opérateur composé

Composite opérateur est un groupe d'un nombre quelconque d'instructions quelconques, séparées les unes des autres par un point-virgule et délimitées par des parenthèses d'opérateur début et fin.

Format d'instruction composé :

commencer<Оператор1>; ... ; <ОператорN>;

Quel que soit le nombre d'instructions qu'il contient, une instruction composée est traitée comme une seule entité. L'utilisation la plus courante de l'instruction composée concerne les instructions conditionnelles et les instructions de boucle.

Les instructions composées peuvent être imbriquées les unes dans les autres et il n'y a aucune restriction sur la profondeur d'imbrication des instructions composées.

2. Opérateur conditionnel

Conditionnel opérateur assure que certaines instructions sont exécutées ou non en fonction de certaines conditions.

Format d'instruction conditionnelle :

Si alors<Оператор1> ;

La condition est une expression de type booléen. L'instruction fonctionne comme suit : si la condition est vraie (a la valeur True), alors instruction1 est exécutée, sinon instruction2 est exécutée. Les deux opérateurs peuvent être composés.

Une instruction conditionnelle peut être écrite sous une forme abrégée lorsqu'il n'y a pas d'autre mot et d'instruction2 après elle.

Pour organiser les branches dans trois directions ou plus, vous pouvez utiliser plusieurs instructions conditionnelles imbriquées les unes dans les autres. Dans ce cas, chaque else correspond au then qui le précède immédiatement. À cause de erreurs possibles l'imbrication des instructions conditionnelles doit être évitée.

3.Sélectionnez l'opérateur

Opérateur choix est une généralisation de l'opérateur conditionnel et vous permet de faire un choix parmi un nombre arbitraire d'options disponibles. Cette instruction consiste en une expression appelée sélecteur, une liste d'options et une branche else facultative qui a la même signification que dans l'instruction conditionnelle.

Sélectionnez le format de déclaration :

cas<Выражение-селектор>de

<Список1> : <Оператор1>;

<СписокN> : <ОператорN>

Expression du sélecteur doit être de type ordinal. Chaque variante est une liste de constantes séparées par deux-points de l'opérateur associé à cette variante. La liste des constantes de sélection se compose de montant arbitraire valeurs et plages séparées par des virgules. Les limites de plage sont écrites sous la forme de deux constantes séparées par "..". Le type des constantes doit correspondre au type de l'expression du sélecteur.

L'instruction select est exécutée comme suit :

1. La valeur de l'expression du sélecteur est évaluée.

2. Un examen séquentiel des options est effectué pour la correspondance de la valeur du sélecteur avec les constantes et les valeurs des plages de la liste correspondante.

3. Si cette recherche aboutit pour la variante suivante, alors l'opérateur de cette variante est exécuté. Après cela, l'exécution de l'instruction select se termine.

4. Si toutes les vérifications ont échoué, l'instruction après le mot else (le cas échéant) est exécutée.

Exemple. Sélectionner l'instruction

caseNumberJour du

1..5 : strDay:= "Jour ouvrable" ;

6..7: strDay:= "Jour férié"

sinon strJour:="";

En fonction de la valeur de la variable entière NumberDay, qui contient le numéro du jour de la semaine, la variable chaîne strDay reçoit la valeur appropriée.

>> Ouvrages de contrôle. informations généralesà propos des cycles

Cours de formation :

Structures de contrôle. Informations générales sur les cycles

Structures de contrôle

Informations générales sur les cycles

Les cycles sont la répétition d'opérations tant qu'une condition logique est vraie. Par exemple, définissons une condition de boucle selon laquelle une variable a est inférieure à 10.

La boucle sera exécutée jusqu'à (c'est-à-dire que les instructions qu'elle contient seront exécutées tant de fois) jusqu'à ce que cette condition devienne vraie.

Il existe trois types de boucles : for, do...while, while. Considérons, par exemple, la construction de la boucle for.

for (Initialisation de variable ; Condition ; Changement de variable après chaque exécution du bloc d'instructions de boucle)
{
corps de boucle
}

Regardons un exemple d'utilisation d'une boucle for (extrait 3.1).

Liste 3.1.
Pour l'exemple de boucle

Ce programme affichera dix astérisques sur une ligne. Il n'est pas nécessaire d'initialiser la variable compteur dans la boucle (une variable compteur est une variable qui détermine le nombre d'exécutions du corps de la boucle). Prenons un exemple de programme sans déclarer de variable compteur dans une boucle (extrait 3.2).

Liste 3.2.
Un exemple de programme sans déclaration de variable compteur dans une boucle

Vous pouvez utiliser plus d'une variable compteur, mais plusieurs. Prenons un exemple d'un tel programme, présenté dans le Listing 3.3.

Liste 3.3.
Exemple d'utilisation de plusieurs variables de compteur

Prenons une boucle while. Dans cette boucle, une condition est spécifiée en tant que paramètre. La condition est vérifiée avant l'exécution de la boucle. La boucle while a la forme suivante.

tandis que (état)
{
corps de boucle
}

Prenons un exemple de programme qui utilise une boucle while (extrait 3.4).

Liste 3.4.
Exemple d'utilisation d'une boucle while

La sortie de ce programme sera dix astérisques.

Gardez à l'esprit que si vous oubliez de spécifier un incrément à une variable dans la condition, ou si vous spécifiez simplement la condition de manière incorrecte, une erreur d'exécution peut se produire qui ne sera pas détectée à l'étape de compilation et la boucle sera exécutée indéfiniment.

Un exemple de programme erroné.

Considérons maintenant la boucle do...while.
Elle est très similaire à la boucle while et diffère uniquement en ce qu'elle vérifie la condition non pas avant la prochaine exécution de la boucle, mais après son exécution. La boucle do...while est illustrée ci-dessous.

Les instructions if , if-else et switch sont les moyens les plus importants de contrôler l'exécution d'un programme C. Ils doivent être utilisés pour mettre en œuvre la structure globale du programme. Les trois opérateurs décrits ci-dessous sont généralement moins fréquemment abordés, car leur utilisation excessive nuit à la lisibilité du programme, augmente la probabilité d'erreurs et rend difficile sa modification. Niklaus Wirth a défini la programmation structurée comme une programmation sans goto.

déclaration de rupture

L'instruction break est utilisée pour sortir d'une instruction while , do , for , switch qui la contient directement. Le contrôle est transféré à l'instruction qui suit l'instruction à partir de laquelle la sortie a été effectuée. L'instruction break a la forme

while((ch=getchar()) != EOF) /* Lit le caractère ch=getchar(). S'il ne correspond pas à EOF, le corps de l'instruction while */ est exécuté ( if(ch=="\n") break; putchar(ch); )

La boucle est complètement terminée dès que le caractère saisi " nouvelle ligne".

continuer la déclaration

L'instruction continue est utilisée pour ignorer le reste de l'itération en cours de la boucle qui la contient immédiatement. Si une nouvelle itération est autorisée par les conditions de la boucle, alors elle est exécutée, sinon la boucle se termine. L'instruction continue a la forme suivante :

while((ch=getchar()) != EOF) /* Lit le caractère ch=getchar(). S'il ne correspond pas à EOF, le corps de l'instruction while */ est exécuté ( if(ch=="\n") continue; putchar(ch); )

La version avec l'instruction continue ignore simplement les caractères de retour à la ligne et quitte la boucle uniquement lorsque l'indicateur EOF est lu.

Aller à l'instruction

L'instruction goto est destinée à transférer inconditionnellement le contrôle à l'instruction avec l'étiquette spécifiée. Il a la forme suivante :

aller à l'étiquette ;

Kernighan et Ritchie considèrent que l'instruction goto est "extrêmement mauvaise" et suggèrent de l'utiliser le moins ou le moins possible. Voici un exemple d'entrée d'opérateur :

Pour que cette instruction s'exécute correctement, il doit y avoir une autre instruction intitulée part1 . Dans ce cas, l'entrée de l'instruction commence par une étiquette suivie de deux points :

part1 : printf("point de saut\n");

Si vous ne pouvez pas vous passer des instructions goto , break , continue , return , alors lorsque vous utilisez goto, avancez dans le code et ne revenez pas en arrière.

Il est préférable de ne pas utiliser l'instruction break pour sortir prématurément d'une boucle, il est utile de l'utiliser à l'intérieur d'une instruction switch.

L'instruction continue ne doit pas être utilisée pour modifier la logique des boucles.

Pourquoi n'est-il pas souhaitable d'utiliser des fonctions avec de nombreuses instructions de retour. L'un des principes de la programmation structurée est qu'un programme doit avoir un point d'entrée et un point de sortie. Les fonctions avec de nombreuses instructions de retour sont plus difficiles à lire que celles avec une seule instruction de retour à la fin du corps de la fonction.

Le plus structure simple- suivant. Il peut être représenté comme ceci :

Les modules "a" et "c" peuvent contenir à la fois une instruction et n'importe quel nombre de structures se succédant, incl. et discuté ci-dessous.

La structure de fourche (if-then-else) sert à sélectionner l'une des deux manières possibles d'exécuter l'algorithme. La vérification est sa base. La fourche ressemble à ceci :

Les structures IF-THEN-ELSE peuvent être imbriquées les unes dans les autres, par exemple, de cette manière.

Le nombre de structures imbriquées est limité par les capacités du PC et du logiciel installé dessus. Ce numéro est généralement spécifié dans la description de la langue. Pour assurer la lisibilité du schéma fonctionnel, les structures imbriquées peuvent être remplacées par des rectangles, et le schéma fonctionnel de chaque rectangle est représenté en détail sur une feuille séparée. En général, tout organigramme ou programme est mieux lu s'il est placé entièrement sur une seule page.

La structure illustrée dans le dernier schéma fonctionnel vous permet de choisir l'un des trois chemins. De même, en utilisant des structures imbriquées, vous pouvez organiser le choix d'un chemin parmi n'importe quel nombre. Comme le besoin en apparaît assez souvent, une structure spéciale a été introduite - un choix qui ressemble à ceci

Ici, le symbole "P" désigne toujours la condition, basée sur la réalisation de laquelle l'un des chemins possibles est sélectionné.

Lors du développement d'algorithmes, il devient souvent extrêmement important de répéter n'importe quelle opération ou groupe d'opérations. Pour afficher de tels fragments de l'algorithme, des structures spéciales sont fournies - des cycles. Il existe trois types de Οʜᴎ : bye-loop, do-loop et contre-boucle. Le travail de la boucle-while est illustré par le schéma fonctionnel suivant.

Avant la première exécution du bloc d'instructions, qui est communément appelé le corps de la boucle, la condition "P" est vérifiée et, si elle est vraie, alors le corps de la boucle est exécuté et le contrôle est renvoyé au début de la boucle. Ensuite, la condition est vérifiée à nouveau, et ainsi de suite jusqu'à ce que la condition de boucle devienne fausse. Dans ce cas, la boucle est terminée. Il est exécuté tant que la condition est remplie.

Le cycle do est organisé différemment.

La vérification de la vérité de la condition de la boucle est effectuée après l'exécution du corps de la boucle, et la sortie de celle-ci est effectuée lorsque la condition est vraie. De plus, le corps de la boucle est toujours exécuté une fois, contrairement à cycle-bye, qui n'est jamais exécuté si la condition de boucle n'est pas remplie.

Le troisième type de boucle est la boucle de compteur. Il est utilisé dans les cas où il est extrêmement important de répéter le corps de la boucle un certain nombre de fois. Sa structure peut être représentée par le schéma fonctionnel suivant.

On peut en déduire que ce cycle est un cas particulier cycle-bye, mais comme ce cas est courant, dans les langages de programmation, en particulier dans VBA, un opérateur spécial est introduit pour décrire un cycle avec un compteur.
Hébergé sur ref.rf
Pour cette raison, nous avons prévu une structure spéciale pour ce cycle.

À titre d'exemple, considérons un organigramme pour trouver l'élément maximum dans une table de N nombres.

Ici Max est le nombre maximum, i est le numéro du nombre dans le tableau des nombres X, N est la taille du tableau. L'organigramme contient les constructions structurelles suivantes : follow, une boucle while, qui est exécutée jusqu'à ce que le numéro du nombre vérifié soit inférieur ou égal à la taille de la table, et une bifurcation dans laquelle un chemin est sélectionné contenant l'affectation du nombre actuel de la table à la variable Max, auquel cas , si cette variable est inférieure au nombre actuel.

Structures de contrôle de base - concept et types. Classement et caractéristiques de la catégorie "Principales structures de gestion" 2017, 2018.