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 un langage de 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 ramification communes et leurs correspondants dans différentes langues les opérateurs de commande 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 théorie l'informatique on suppose que la solution de tout problème qui a 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 le management. 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 d'é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. Information additionnelle 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 du système d'exploitation Microsoft Windows pourrait concevoir votre propre graphique interface utilisateur. 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. À 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 de 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 demandions l'exécution d'une procédure avec une expression telle que "Apply procedure DeactivateCrypton", la plupart des langages de programmation modernes permettent d'appeler une procédure simplement en spécifiant 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.
Opérateur de succursale
L'opérateur de branchement (branchement conditionnel) permet d'exécuter certaines commandes du programme en fonction de conditions logiques. Dans Visual Basic, l'opérateur de branche peut être utilisé sous deux formes : inline et block.
échange en ligne de travaux d'étudiants">
Exemple 1
Par exemple, Si a > b Alors max = a Sinon max = b.
Si plusieurs instructions doivent être exécutées, elles sont séparées par des deux-points.
Exemple 2
Par exemple, Si a > 0 Alors b = a + 1 : c = a\2.
La syntaxe du bloc est plus puissante, plus structurée et plus lisible.
Syntaxe de bloc :
Condition - Expression booléenne, qui peut prendre la valeur Vrai(vrai), Faux(faux) ou Nul, ce qui équivaut à Faux. Lorsqu'une instruction de branche de bloc est exécutée, la condition est vérifiée et, si elle est vraie, l'instruction qui suit l'instruction est exécutée. Puis. Si la condition n'est pas vraie, vérifiez condition2, passe derrière SinonSi. Lorsqu'une valeur vraie est trouvée, l'instruction true_statement2 est exécutée, ce qui suit Puis, après quoi le programme quitte Fin si(c'est-à-dire après SinonSi, le cas échéant, ne sont pas cochées). Si les vraies conditions de SinonSi introuvable, instruction_false_condition est exécutée.
Figure 3. Exemple de syntaxe de bloc. Author24 - échange en ligne de travaux d'étudiants
Sélectionner l'instruction
Énoncé de sélection de cas exécute certaines instructions en fonction de l'ensemble de valeurs de l'expression ou de la variable testée. Sélectionnez la syntaxe de l'instruction :
Figure 4. Syntaxe de l'instruction select. Author24 - échange en ligne de travaux d'étudiants
Une valeur est une variable ou une expression qui est testée par rapport à une ou plusieurs conditions. La liste des valeurs est spécifiée séparée par des virgules, la plage de valeurs est spécifiée à l'aide mot officiel Pour(par exemple, 5 à 9).
Exemple 3
Par le numéro du mois dans l'année, affiche un message indiquant à quelle période de l'année appartient le mois spécifié.
>> 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 un tel programme, montré 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.
Il ressemble beaucoup à boucle while et diffère seulement en ce qu'il 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.
Chapitre 6. STRUCTURES DE CONTRÔLE Instruction d'affectation Instruction simples et composées Opérateur conditionnel Instruction à choix multiples Instruction de boucle avec précondition Instruction de boucle avec postcondition Instruction de boucle avec paramètre Instruction de saut inconditionnel et procédures
2 Chap. 6. STRUCTURES DE CONTRÔLE Opérateur d'affectation Un opérateur est une construction de langage de programmation qui sert à définir une action ou une séquence d'actions dans un programme sur des données. L'ensemble des opérateurs de programme implémente l'algorithme qui y est intégré. Tout opérateur implique une action. Le processus de "pousser" une valeur dans une variable est appelé affectation (la première affectation est appelée initialisation). L'affectation est effectuée à l'aide d'une construction spéciale - opérateur d'affectation : identificateur de variable := := expression Var W,H : Integer ; Commencer W := 23 ; H== 17; L :=L*H ; finir.
3 Chap. 6. STRUCTURES DE CONTRÔLE Instructions simples et composées Deux instructions consécutives doivent être séparées par un point-virgule (signifiant la fin de l'instruction) : a:= 11; b := une * une ; Ecrire(a,b); Une instruction composée est une séquence d'instructions traitées comme une seule instruction. Formé à l'aide des mots réservés begin et end (opérateurs parenthèses). Un opérateur dans un programme est une seule phrase indivisible qui effectue une action. Une instruction simple ne contient pas d'autres instructions (instruction d'affectation, appel de procédure, ...). commencer un:= 11 ; b := une * une ; Écrire(a, b) fin ;
5 puis commencer X := X + 5 ; Y:= 1 fin sinon Y:= -1 ; L'opérateur conditionnel est utilisé pour programmer des branches, c'est-à-dire situations où il devient nécessaire sous certaines conditions d'exécuter " title="4 Ch. 6. STRUCTURES DE CONTROLE Instruction conditionnelle si K > 5 alors commence X:= X + 5; Y:= 1 et sinon Y:= - 1 ; L'opérateur conditionnel est utilisé pour programmer des branches, c'est-à-dire des situations où il devient nécessaire sous certaines conditions d'exécuter" class="link_thumb"> 4 !} 4 Chap. 6. STRUCTURES DE CONTRÔLE Énoncé conditionnel si K > 5 alors commencer X:= X + 5; Y:= 1 fin sinon Y:= -1 ; L'opérateur conditionnel est utilisé pour programmer des branches, c'est-à-dire situations où il devient nécessaire sous certaines conditions d'effectuer diverses actions. L'instruction conditionnelle a la structure : if expression logique then instruction else instruction Une seule instruction est autorisée par branche. 5 puis commencer X := X + 5 ; Y:= 1 fin sinon Y:= -1 ; L'opérateur conditionnel est utilisé pour programmer des branches, c'est-à-dire situations où il devient nécessaire sous certaines conditions d'exécuter "> 5 then begin X:= X + 5; Y:= 1 end else Y:= -1; L'opérateur conditionnel est utilisé pour programmer des branches, c'est-à-dire des situations où le besoin s'en fait sentir quand effectuer différentes actions sous certaines conditions. L'instruction conditionnelle a la structure suivante : if logical expression then statement else statement Une seule instruction est autorisée par branche."> 5 then begin X:= X + 5; Y:= 1 fin sinon Y:= -1 ; L'opérateur conditionnel est utilisé pour programmer des branches, c'est-à-dire situations où il devient nécessaire sous certaines conditions d'exécuter " title="4 Ch. 6. STRUCTURES DE CONTROLE Instruction conditionnelle si K > 5 alors commence X:= X + 5; Y:= 1 et sinon Y:= - 1 ; L'opérateur conditionnel est utilisé pour programmer des branches, c'est-à-dire des situations où il devient nécessaire sous certaines conditions d'exécuter"> title="4 Chap. 6. STRUCTURES DE CONTRÔLE Énoncé conditionnel si K > 5 alors commencer X:= X + 5; Y:= 1 fin sinon Y:= -1 ; L'opérateur conditionnel est utilisé pour programmer des branches, c'est-à-dire situations où il devient nécessaire, sous certaines conditions, d'effectuer"> !}
6 Chap. 6. STRUCTURES DE CONTRÔLE Opérateur à choix multiples L'opérateur de choix est utilisé pour implémenter plusieurs options alternatives d'actions, chacune correspondant à ses propres valeurs d'un paramètre. expression de cas d'instructions constante/plage else : instruction end ; La valeur et doit également être l'un des types ordinaux (autre que LongInt). Selon la valeur, l'instruction qui est précédée d'une constante de sélection égale à la valeur calculée est sélectionnée (alternativement, les instructions après le else). Les valeurs constantes doivent être uniques dans chaque ensemble, c'est-à-dire ils ne peuvent apparaître que dans une seule variante.
7 Chap. 6. STRUCTURES DE COMMANDE cas I de (I : Mot) 1 : X := X +1 ; 2.3 : X : = X +2 ; 4..9 : commencer Ecrire(X) ; X:= X + 3 (m.b. ";") fin (m.b. ";") sinon X:= X * X; Writeln(X) (m.b. ";") end ;
8 Chap. 6. STRUCTURES DE CONTRÔLE Cycle instruction "While" (avec précondition) tandis que l'expression conditionnelle do instruction (corps de la boucle) après le mot de service do sera exécutée cycliquement jusqu'à ce que la condition logique soit remplie, c'est-à-dire alors que la valeur est True. Pour qu'une boucle ait une chance de se terminer, le contenu de son corps doit affecter l'état de la boucle. La condition doit être constituée d'expressions valides et de valeurs définies avant la première exécution du corps de la boucle. VarF,N : Entier Long;(calcul 10 Begin F:= 1; N:= 1; while N !}
9 Chap. 6. STRUCTURES DE CONTROLE Instruction de boucle "Before" (avec postcondition) Les instructions entre les mots repeat et until forment le corps de la boucle. Si vrai, alors la boucle se termine. Boucle "While" - "lorsque la condition est vraie, exécute les instructions du corps." Boucle "Avant" - "exécute le corps de la boucle jusqu'à ce que la condition devienne vraie" ; répéter jusqu'à Faux ; répéter l'opérateur t jusqu'à l'expression conditionnelle ;
10 Chap. 6. STRUCTURES DE COMMANDE Un opérateur de boucle avec un paramètre (boucle sur un compteur) est une variable de type ordinal, les valeurs et doivent également appartenir au même type. La valeur évolue dans l'ordre croissant (en utilisant le mot réservé to) ou décroissant (downto) de valeur en valeur avec un pas constant égal à l'intervalle entre les deux valeurs les plus proches dans le type auquel elle se réfère (par types entiers- c'est 1, pour un caractère - d'un caractère à l'autre en augmentant le code de 1, etc.). les boucles for autorisent l'imbrication si aucune des boucles imbriquées n'utilise ou ne modifie les variables - paramètres boucles extérieures. Permet d'organiser des boucles "strictes" qui doivent être effectuées un certain nombre de fois. for r loop parameter:= expression 1 to expression 2 do downto instruction
12 Chap. 6. STRUCTURES DE CONTRÔLE Opérateur de saut inconditionnel Une étiquette peut apparaître n'importe où dans le programme entre les opérateurs et est séparée du second opérateur par deux-points ":". La portée des opérateurs de saut inconditionnel est strictement localisée. Les transitions sur l'instruction goto entre les procédures, ainsi qu'entre le bloc principal et la procédure, sont interdites. L'opérateur de branche inconditionnel transfère le contrôle d'exécution à l'endroit du programme indiqué par l'étiquette (c'est "superflu" du point de vue de la théorie de la programmation structurée). goto label Label Entier non signé ; ID d'étiquette, diagrammes de syntaxe et : LabelL1, L2 ; Début... aller à L1 ;... L1 : aller à L2 ;... L2 : Fin.
13 Chap. 6. STRUCTURES DE CONTRÔLE Procédures de saut inconditionnel Procédures de transfert de contrôle non structurel lors du travail avec des structures cycliques: Pause - met en œuvre une sortie d'un cycle de tout type; Continuer - passe à l'itération suivante de la boucle, en ignorant les instructions restantes jusqu'à la fin du corps de la boucle. Les procédures Exit et Halt sont spécifiquement conçues pour quitter des blocs de programme (procédures, fonctions, bloc de programme principal). Halt() quitte le programme en retournant système opérateur code de sortie spécifié. Quitter quitte inconditionnellement le sous-programme. Si la procédure est utilisée dans le bloc principal, elle est effectuée de la même manière que Halt.
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.
