Structuré les opérateurs - Il s'agit de constructions construites selon certaines règles d'autres opérateurs. Les déclarations structurées comprennent :
Opérateur composé
Opérateur conditionnel
Opérateurs de sélection
Instructions de boucle
La déclaration with
1. Opérateur composé
Composite opérateur est un groupe d'un nombre arbitraire d'instructions quelconques, séparées les unes des autres par un point-virgule et délimitées par les crochets d'opérateur début et fin.
Format d'instruction composée :
commencer<Оператор1>; ... ; <ОператорN>;
Quel que soit le nombre d'énoncés qu'il contient, un énoncé composé est perçu comme un tout. Les utilisations les plus courantes de l'opérateur composé concernent les instructions conditionnelles et les instructions de boucle.
Les opérateurs composés peuvent être imbriqués les uns dans les autres et il n'y a aucune restriction quant à la profondeur d'imbrication des opérateurs composés.
2. Opérateur conditionnel
Conditionnel opérateur garantit que certaines déclarations sont exécutées ou non en fonction de certaines conditions remplies.
Format d'instruction conditionnelle :
Si
La condition est une expression booléenne. L'opérateur fonctionne comme suit : si la condition est vraie (a la valeur True), alors l'opérateur 1 est exécuté, sinon l'opérateur 2 est exécuté. Les deux déclarations peuvent être composées.
Une instruction conditionnelle peut être écrite sous forme abrégée lorsque le mot else et l'opérateur2 qui la suivent sont manquants.
Pour organiser les branches dans trois directions ou plus, vous pouvez utiliser plusieurs instructions conditionnelles imbriquées les unes dans les autres. De plus, chacun des autres correspond au alors qui le précède immédiatement. En raison d'erreurs possibles, il convient d'éviter une imbrication importante d'instructions conditionnelles les unes dans les autres.
3.Opérateur de sélection
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 déclaration 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 relevé :
cas<Выражение-селектор>de
<Список1> : <Оператор1>;
<СписокN> : <ОператорN>
Expression du sélecteur doit être de type ordinal. Chaque option est une liste de constantes séparées par deux points de l'opérateur associé à cette option. La liste des constantes de sélection se compose d'un nombre arbitraire de valeurs et de plages séparées par des virgules. Les limites de plage sont écrites sous forme de deux constantes séparées par le séparateur « .. ». 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 calculée.
2. Les options sont analysées séquentiellement pour voir si la valeur du sélecteur correspond aux constantes et aux valeurs des plages de la liste correspondante.
3. Si cette recherche réussit pour l'option suivante, alors l'opérateur de cette option est exécuté. Après cela, l'exécution de l'instruction select se termine.
4. Si toutes les vérifications échouent, l'instruction après le mot else (le cas échéant) est exécutée.
Exemple. Opérateur de sélection
casNuméroJour de
1..5 : strDay:= "Jour ouvrable" ;
6..7 : strDay:= "Jour de congé"
sinon strDay:="";
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 correspondante.
Dans le programme le plus simple, les instructions sont exécutées séquentiellement, c'est-à-dire exactement une fois et dans l'ordre dans lequel ils apparaissent dans le texte du programme. Cependant, dans les programmes réels, les instructions ne peuvent être répétées ou exécutées que sous certaines conditions. Les instructions de contrôle sont utilisées pour créer des programmes avec une structure non linéaire.
Les opérateurs de contrôle comprennent les opérateurs suivants :
Opérateurs de succursales :
l'opérateur conditionnel – if else – implémente les structures algorithmiques ALTERNATIVE et CHOICE (voir Annexe 1) ;
l'opérateur de sélection – switch – implémente partiellement la structure algorithmique de SELECTION (voir Annexe 1) ;
boucle avec précondition – while – implémente la structure algorithmique de BOUCLE AVEC PRÉCONDITION (voir Annexe 1) ;
boucle avec postcondition – do while – implémente la structure algorithmique de LOOP WITH POSTCONDITION (voir Annexe 1) ;
une boucle avec le paramètre – for – implémente la structure algorithmique de PARAMETRIC LOOP (voir Annexe 1).
Opérateurs de boucle :
Opérateur conditionnel (siautre)
L'opérateur conditionnel if est utilisé pour diviser le processus de calcul en deux directions ; il implémente ainsi la structure algorithmique ALTERNATIVE dont le schéma fonctionnel ressemble à ceci :
Si<Условие>vrai, alors vrai<Оператор 1>, autrement exécuté<Оператор 2>.
Un exemple d'utilisation d'un opérateur conditionnel pour diviser le processus de calcul en deux directions :
// Calculer le module y= |x|
si(x< 0) { y= -x; }
L'instruction if est également utilisée pour implémenter la structure algorithmique SELECT (voir le schéma fonctionnel ci-dessous) lorsqu'il n'est pas possible d'utiliser l'instruction de sélection switch (nous y reviendrons plus tard).
Utilisation de l'opérateur catch pour implémenter la structure algorithmique CHOICE :
Un exemple d'utilisation d'un opérateur conditionnel pour implémenter la structure algorithmique CHOICE :
// Calculer y= sign(x) - moyen plus simple à implémenter
si(x< 0) { y= -1; }
si(x == 0) ( y= 0; )
si(x > 0) ( y= 1; )
// Calculer y= sign(x) est un moyen plus efficace d'implémenter
si(x< 0) { y= -1; }
sinon si(x == 0) ( y= 0; )
sinon si(x > 0) ( y= 1; )
Opérateur de sélection (changer) + opérateur d'interruption (casser)
L'opérateur de commutation (sélection) est destiné à diviser le processus de calcul dans plusieurs directions. Cet opérateur implémente la structure algorithmique SELECTION. Son utilité est toutefois limitée, car il ne peut pas fixer de conditions arbitraires. Les conditions dans une instruction switch ont la structure suivante<Выражение> == <Константа>.
Format de l'opérateur :
changer(<Выражение>)
cas<Константа 1>:
<Оператор 1>
cas<Константа 2>:
<Оператор 2>
cas<Константа M>:
<Оператор M>
<Оператор M+1>
Si<Выражение>prend la valeur égale<Константа 1>, alors c'est accompli<Оператор 1>; Si<Выражение>prend la valeur égale<Константа 2>, alors c'est accompli<Оператор 2>etc. Si<Выражение>prend une valeur différente des constantes spécifiées, alors<Оператор M+1>.
Un exemple d'utilisation de l'opérateur select :
// Analyse la réponse de l'utilisateur
scanf("%s", &Réponse);
printf("\nVous avez appuyé sur 1");
printf("\nVous avez appuyé sur 2");
L'instruction break interrompt l'exécution de l'instruction switch. S'il n'y était pas, toutes les instructions à l'intérieur du commutateur seraient exécutées séquentiellement les unes après les autres. Par exemple, comme ceci :
// Analyse la réponse de l'utilisateur
scanf("%s", &Réponse);
printf("\nVous avez appuyé sur 1");
printf("\nVous avez appuyé sur 2");
printf("\nVous avez appuyé sur quelque chose de mal");
Lorsque l'utilisateur saisit le caractère « 2 », deux messages apparaîtront à l'écran :
"Vous avez appuyé sur 2"
"Vous avez appuyé sur quelque chose de mal"
Opérateur de boucle avec condition préalable (alors que)
L'opérateur est utilisé pour organiser plusieurs calculs répétés qui ne peuvent pas être exécutés une seule fois. L'opérateur while implémente la structure algorithmique d'une BOUCLE AVEC PRECONDITION dont le schéma fonctionnel est donné ci-dessous. Cette structure algorithmique est utilisée lorsque le nombre d'itérations (répétitions) est inconnu à l'avance et qu'il peut n'y avoir aucune répétition.
Format de l'opérateur :
alors que(<Условие>)
<Оператор>
C'est d'abord vérifié<Условие>. Si<Условие>vrai, alors vrai<Оператор>jusqu'à<Условие>ne deviendra pas faux. Si<Условие>devient faux, le contrôle est transféré à l'opérateur suite à la boucle.<Условие>– c’est la condition pour continuer le cycle,<Оператор>– c’est le corps de la boucle (action répétée + action pour sortir de la boucle).
Commentaire.<Оператор>ne peut être exécuté ne serait-ce qu'une seule fois si<Условие>initialement faux.
Un exemple d'utilisation d'un opérateur avec une précondition :
char String= « Ceci est un exemple » ;
Compte = 0 ; // Préparation
while(String !='\0') // condition de continuation
( Count++; ) // corps de la boucle (action répétitive +
Dans cet exemple, la boucle ne s'exécutera pas une seule fois si la chaîne est vide.
Regardons un autre exemple qui utilise l'instruction while, mais il est plus correct d'utiliser l'instruction do while :
// Entrez une lettre russe
char Lettre russe ;
scanf("%c", &LettreRusse); // Préparation
while((Lettre russe< ‘A’) ||
(Lettre russe > 'I')) // condition de continuation
( scanf("%c", & RussianLetter); ) // corps de la boucle (action répétitive + // action pour sortir de la boucle)
Opérateur de boucle avec postcondition (fairealors que)
L'opérateur permet d'organiser plusieurs calculs répétés qui sont effectués au moins une fois. L'opérateur do while implémente la structure algorithmique d'une BOUCLE AVEC POSTCONDITION dont le schéma fonctionnel est donné ci-dessous. Cette structure algorithmique est utilisée lorsque le nombre d'itérations est inconnu à l'avance, mais qu'au moins une itération est toujours effectuée (par exemple, si des données sont saisies dans une boucle).
Format de l'opérateur :
<Оператор>
alors que(<Условие>);
Fonctionne en premier<Оператор>, puis vérifié<Условие>. Si<Условие>vrai, puis s'exécute à nouveau<Оператор>. Cela continue jusqu'à<Условие>ne deviendra pas faux.
Commentaire.<Оператор>toujours exécuté au moins une fois.
Un exemple d'utilisation d'une boucle avec une postcondition :
// Demande à l'utilisateur un nombre de 0 à 10
// pas de préparation
( scanf("%d", &Number); ) // corps de la boucle (action répétitive +
// action pour sortir de la boucle)
while((Nombre< 0)||(Number >dix)); // condition de continuation
L'exemple utilise une boucle do while car Le numéro est d'abord saisi puis vérifié.
Veuillez noter que l'instruction while est suivie d'un point-virgule ;.
Opérateur de boucle avec paramètre (pour)
L'opérateur est utilisé pour organiser des calculs répétés à plusieurs reprises et est essentiellement similaire à la boucle while, mais a une notation plus compacte. L'opérateur for implémente la structure algorithmique PARAMETRIC LOOP dont les schémas fonctionnels sont donnés ci-dessous. Cette structure algorithmique est utilisée lorsque le nombre d’itérations est connu à l’avance.
|
|
|
Format de l'opérateur :
pour(<Оператор инициализации>; <Условие>; <Оператор модификации>)
<Оператор>
Fonctionne en premier<Оператор инициализации>et est vérifié<Условие>. Si<Условие>vrai, alors vrai<Оператор>. Puis il exécute<Оператор модификации>et j'ai vérifié à nouveau<Условие>. Si<Условие>vrai, alors vrai<Оператор>etc. Le cycle se termine lorsque<Условие>devient faux.
Commentaire. La boucle for, comme la boucle while, ne peut pas être exécutée une seule fois.
Un exemple d'utilisation d'une boucle avec un paramètre :
y = 1 ; // Préparation
pour(je= 1; je<= n; i++) // оператор инициал.; условие; оператор модификации
( y= y*i; ) // corps de la boucle (action répétitive)
Dans cet exemple, avant même l'exécution de la boucle, on sait que la variable i doit changer entre 1 et n.
Voyons maintenant comment le même problème est résolu à l'aide d'une boucle while :
// Calculez la factorielle y = n !
y = 1 ; // Préparation
je= 1 ; // préparation (opérateur d'initialisation)
alors que je<= n) // условие продолжения
y=y*i; // répétition de l'action
je++; // action pour sortir de la boucle (opérateur de modification)
Cet exemple montre que l'utilisation d'une boucle while complique le code du programme, et donc il est préférable d'utiliser une boucle for lorsque le nombre d'itérations à effectuer est connu à l'avance.
Les instructions if, if-else et switch sont les moyens les plus importants pour 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 instructions décrites ci-dessous sont généralement moins souvent prises en compte car leur utilisation trop fréquente rend un programme moins lisible, augmente le risque d'erreurs et rend sa modification plus difficile. Niklaus Wirth a défini la programmation structurée comme une programmation sans goto.instruction de pause
L'instruction break est utilisée pour quitter l'instruction while , do , for , switch qui la contient directement. Le contrôle est transféré à l'opérateur qui suit l'opérateur à partir duquel la sortie a été effectuée. L'instruction break a la forme
while((ch=getchar()) != EOF) /* le caractère ch=getchar() est lu. S'il ne correspond pas à EOF, le corps de l'instruction while est exécuté */ ( if(ch=="\n") break; putchar(ch); )
La boucle s'arrête complètement dès qu'un caractère de nouvelle ligne est rencontré lors de la saisie.
Continuer l'opérateur
L'instruction continue est utilisée pour ignorer le reste de l'itération d'exécution de la boucle qui la contient directement. Si les conditions de la boucle permettent une nouvelle itération, alors celle-ci est exécutée, sinon la boucle se termine. L'instruction continue a la forme suivante :
while((ch=getchar()) != EOF) /* le caractère ch=getchar() est lu. S'il ne correspond pas à EOF, le corps de l'instruction while est exécuté */ ( if(ch=="\n") continue; putchar(ch); )
La version continue ignore simplement les caractères de nouvelle ligne et quitte la boucle uniquement lorsque l'indicateur EOF est lu.
aller à la déclaration
L'instruction goto est conçue pour transférer sans condition le contrôle à une instruction portant une étiquette spécifiée. Il a la forme suivante :
aller à l'étiquette ;
Kernighan et Ritchie considèrent l'instruction goto comme « extrêmement mauvaise » et suggèrent de l'utiliser le moins possible. Voici un exemple d'entrée d'opérateur :
Pour que cette instruction s'exécute correctement, il doit exister 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 opérateurs goto , break , continue , return , alors lorsque vous utilisez goto, avancez dans le code et non vers l'arrière.
Il est préférable de ne pas utiliser l'instruction break pour quitter prématurément une boucle ; il est utile de l'utiliser dans une instruction switch.
Il n'est pas conseillé d'utiliser l'opérateur continue pour modifier la logique de boucle.
Pourquoi il n'est pas conseillé d'utiliser des fonctions avec de nombreuses instructions return. 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 comportant de nombreuses instructions return sont plus difficiles à lire que celles qui n'ont qu'une seule instruction return à la fin du corps de la fonction.
Opérateurs de boucle Les opérateurs de boucle sont utilisés pour organiser des calculs répétés. Pour organiser une boucle, vous avez besoin d'une variable appelée paramètre de boucle ou variable de contrôle de boucle. Tout cycle est constitué : de réglages initiaux ou d'un bloc d'initialisation des paramètres de cycle ; les corps de boucle, c'est-à-dire les instructions exécutées plusieurs fois ; bloc de modification des paramètres de cycle ; vérifier la condition de sortie de la boucle, qui peut être placée soit avant le corps de la boucle, alors on parle de boucle avec une précondition soit après le corps...
Partagez votre travail sur les réseaux sociaux
Si cette œuvre ne vous convient pas, en bas de page se trouve une liste d'œuvres similaires. Vous pouvez également utiliser le bouton de recherche
Thème 2 Déclarations de contrôle
2.1 Constructions de programmation structurée de base
DANS théorie de la programmationil a été prouvé qu'un programme permettant de résoudre un problème de toute complexité peut être composé de seulement trois structures appelées suivi, branchement et boucle. Elles sont appelées conceptions de baseprogrammation structurée.
En suivant est une construction qui représente l'exécution séquentielle de deux ou plusieurs opérateurs (simples ou composés).
Ramification spécifie l'exécution de l'une ou l'autre instruction en fonction de la réalisation d'une condition.
Faire du vélo spécifie l'exécution multiple de l'instruction.
La particularité des structures de base est que chacune d’elles n’a qu’une seule entrée et une seule sortie, les structures peuvent donc être imbriquées les unes dans les autres de n’importe quelle manière.
Figure 2.1 Constructions de programmation structurée de base
Le but de l’utilisation de constructions de base est d’obtenir un programme avec une structure simple. Un tel programme est facile à lire, à déboguer et, si nécessaire, à y apporter des modifications.
Toute expression se terminant par un point-virgule est traitée comme une instruction dont l'exécution consiste à évaluer l'expression.
2.2 Opérations relationnelles et logiques
Opérations relationnelles(<, <=, >, >=, ==, !=) comparez le premier opérande avec seconde. Opérandes peut être de type arithmétique ou de pointeurs. Le résultat de l'opération est la valeur vrai ou faux . Les opérations de comparaison d’égalité et d’inégalité ont une priorité inférieure aux autres opérations de comparaison. Par exemple: x >=0, y != 10, z == 0.
ATTENTION! Notez la différence entre l'opération de test d'égalité (== ), dont le résultat est vrai ou faux , et l'opération d'affectation (= ), dont le résultat est la valeur attribuée à l'opérande de gauche.
Opérations logiques(&& , || , ^ ). Opérandes opérateurs logiques ET (&& ), OU (|| ), EXCLUSIF OU (^ ) doit être d'un type pouvant être converti en type bool , avec les opérandes en une seule opération, il peut y avoir différents types. Le résultat de l'opération est vrai ou faux .
Résultat de l'opération le ET logique est vrai seulement si les deux opérandes sont valides vrai . Résultat de l'opération OU logique est vrai , si au moins un des opérandes a une valeur vrai . Résultat de l'opérationOU EXCLUSIF logique est vrai , si l'un des opérandes a une valeur vrai , et le deuxième faux . Négation logique ( !) donne la valeur du résultat false si l'opérande est vrai, et vrai si l'opérande est faux. Opérande peut être de type arithmétique. Dans ce cas c'est faitconversion implicite taper booléen . Les opérations logiques sont effectuées de gauche à droite. Si la valeur du premier opérande est suffisante pour déterminer le résultat de l'opération, le deuxième l'opérande n'est pas évalué.
Tableau des résultats d'exploitation ET, OU, EXCLUSIF OU, NON
(Opérandes A et B)
|
UN B |
Un || B |
A ^ B |
|||
Exemples d'expressions avec des opérations logiques :
x > 0 && y<=10
(un< -1 && b >0) || c != 100
Fonctionnement conditionnel(? :). C'est le seul dans Ternaire C++ opération (comporte trois opérandes), son format :
opérande_1 ? opérande_2 : opérande_3
Opérandes sont calculés de gauche à droite. Le résultat du premier opérande doit être d'un type pouvant être converti en bouffon . Si le résultat est vrai , alors le résultat de l'exécution de l'intégralité de l'opération conditionnelle sera la valeur du deuxième opérande, sinon du troisième opérande. Leurs types peuvent être différents.
Exemple : exigeons qu'une valeur entière soit augmentée de 1 si sa valeur ne dépasse pas n , sinon il prenait la valeur 1. Cela peut être écrit en utilisant une seule ligne de code :
je = (je< n) ? i + 1: 1;
2.3 Opérateurs de succursales. Conditionnel si instruction
Conditionnel si instructionest utilisé pour diviser le processus de calcul en deux directions. Diagramme d'algorithme L’opérateur est illustré à la figure 2.1. Format de l'opérateur :
si (expression) instruction_1 ; [sinon opérateur_2;]
Tout d’abord, une expression est évaluée, qui peut être de type arithmétique ou pointeur. S'il n'est pas égal à zéro, c'est à dire équivaut à vrai , alors la première instruction est exécutée, sinon la seconde est exécutée. Après cela, le contrôle est transféré à l’instruction suivant le conditionnel. Il se peut qu'une des branches soit manquante.
Si plusieurs instructions doivent être exécutées dans une branche, elles doivent être placées dans un bloc. Un bloc peut contenir n'importe quelle instruction, y compris des descriptions et d'autres instructions conditionnelles.
Exemples:
|
|
si un< 0) b = 1; |
|
|
si un< b && (a >ré || une == 0)) B++ ; autre (b*= une; une = 0;) |
|
|
si un< b) si un< c ) M = une ; autre M = c; autre Si(b< c ) M = b ; autre m = c ; |
Dans l'exemple 1 branche manquante autre . Cette conception est appelée « passe-opérateur » car affectation soit exécuté, soit ignoré selon que la condition est remplie ou non.
Si vous devez vérifier plusieurs conditions, elles sont combinées avec les signesopérations logiques. Par exemple, l'expression dans l'exemple 2 sera vrai si la condition a est simultanément satisfaite< b и одно из условий в скобках. Если опустить внутренние скобки, будет выполнено сначала логическое И, а потом ИЛИ.
Opérateur dans l'exemple 3 calcule la plus petite valeur de trois variables.
Par syntaxe d'opérateur si ses branches ne doivent pas contenir plus d'une instruction. S'il y en a plus, ils doivent alors être combinés en un bloc à l'aide de accolades ou en utilisant opérations sur les virgules (,).
Exemple. Un coup de feu est tiré sur la cible indiquée dans Graphique 3.2. Déterminez le nombre de points.
Figure 3.2 Cible
#inclure
int main()
flotter x, y ;
col int ;
Printf("\n Entrez les coordonnées du tir ");
Scanf("%f", &x);
Scanf("%f", &y);
Si (x * x + y * y< 1)
Kol = 2 ;
Autre
Si (x*x + y*y< 4)
kol = 1 ;
autre
kol = 0 ;
printf("\nPoints : %d", kol);
2.4 Opérateurs de succursales. Opérateur de sélection multiple changer
Instruction de commutationconçu pour diviser le processus de calcul dans plusieurs directions. Format de l'opérateur :
changer (expression)
Cas constant_expression_1 : instructions 1;
Cas constant_expression_2 : instructions 2 ;
...
Cas constant_expression_n : instructions n ;
L'exécution de la déclaration commence parévaluation d'expression(ce doit être un entier ), puis le contrôle est transféré cas -opérateurs d'étiquettes marqués d'une expression constante dont la valeur coïncide avec celle calculée, après quoi toutes les autres branches sont exécutées séquentiellement si la sortie est Le commutateur n’est pas explicitement spécifié.
Toutes les expressions constantes doivent avoir des valeurs différentes, mais être identiquestype entier. Plusieurs marques peuvent apparaître à la suite. S'il n'y a pas de correspondance, les instructions situées après le mot sont exécutées défaut (et en son absence, le contrôle est transféré au suivant changer d'opérateur).
Si dans l'un des cas -étiquettes opérateur manquant casser , alors les opérateurs du suivant seront également exécutés cas -label et ainsi de suite jusqu'à ce que l'opérateur soit rencontré quelque part casser.
Exemple (le programme implémente une simple calculatrice en 4 étapes) :
#inclure
int main()
int a, b, res;
char op;
printf("\n Saisissez le 1er opérande : ");
scanf("%d", &a);
printf("\n Entrez le signe de l'opération : ");
scanf("%c", &op);
printf("\n Saisissez le 2ème opérande : ");
scanf("%d", &b);
bool f = vrai ;
Commutateur (op)
Cas "+" : res = a + b ; casser;
Cas "-" : res = a - b ; casser;
Cas "*": res = a * b; casser;
Cas "/" : res = a / b ; casser;
par défaut : printf ("\nOpération inconnue"); f = faux ;
si(f)
printf("\n Résultat : %d", res);
Sortie de commutation généralement effectué à l'aide d'opérateurs pause ou retour.
2.5 Instructions de boucle
Instructions de boucle sont utilisés pour organiser des calculs répétés à plusieurs reprises.
Pour organiser une boucle, vous avez besoin d'une variable appelée paramètre de boucle ou variable de contrôle de boucle. Tout cycle comprend :
- paramètres initiaux ou bloc d'initialisation des paramètres de boucle;
- corps de boucle , c'est-à-dire les opérateurs exécutés plusieurs fois ;
- bloc de modification des paramètres de cycle ;
- vérifications des conditions de sortie de la boucle, qui peut être placée soit avant corps de boucle (puis ils parlent d'un cycle avec une précondition), ou après le corps de la boucle (boucle avec une postcondition).
Figure 3.3 Deux types de cycles
Un passage de la boucle s'appelle itération . Paramètres de boucle entiers qui changent d'un nombre entier à chaque fois les itérations sont appelées compteurs de boucles.
Vous ne pouvez pas transférer le contrôle de l’extérieur vers l’intérieur d’une boucle. La sortie de la boucle est possible aussi bien lorsque la condition de sortie est remplie que par les opérateurs pause, retour ou transition inconditionnelle aller à.
2.6 Boucle avec précondition (while)
Boucle avec précondition implémente le diagramme d'algorithme
instruction while (expression);
Par exemple:
L'expression définit la condition de répétition corps de boucle , représenté par un opérateur simple ou composé. Si l'expression n'est pas 0 (vrai), l'instruction de boucle est exécutée et l'expression est à nouveau évaluée. Si l'expression est évaluée à 0 (faux) lors du premier test, la boucle ne sera pas exécutée une seule fois. Le type de l'expression doit être arithmétique ou réductible.
valeurs de fonction y=x 2 +1 dans la plage saisie) :
#inclure
int main()
flotteur Xn, Xk, Dx ;
flotter X = Xn ; //paramètres du cycle initial
Tandis que (X<= Xk) //проверка условия выхода
Printf("\n %5.2f %5.2f", X, X*X + 1); // corps
X + = Dx ; //modification
2.7 Boucle avec postcondition (do while)
Boucle avec postcondition implémente le diagramme d'algorithme donné ci-dessous et ressemble à :
faire une déclaration pendant l'expression ;
Tout d'abord, un simple ouopérateur composé, constituant le corps de la boucle, puis l'expression est évaluée. Si ce n'est pas 0 (vrai), le corps de la boucle est exécuté à nouveau, et ainsi de suite, jusqu'à ce que l'expression soit évaluée à 0 (faux) ou que quelque chose soit exécuté dans le corps de la boucle.opérateur de transfert de contrôle. Le type de l'expression doit être arithmétique ou réductible.
Exemple (le programme vérifie l'entrée) :
#inclure
int main()
réponse en caractères ;
printf("\nAchetez un éléphant !");
scanf("% c", &réponse);
while (réponse != "y");
2.8 pour la boucle
pour la boucle implémente le diagramme d'algorithme donné ci-dessous et a la forme :
pour (bloc d'initialisation ; bloc de vérification de condition ; bloc de modification)
Corps en boucle ;
Exemple:
Bloc d'initialisationutilisé pour déclarer et attribuer des valeurs initiales aux quantités utilisées dans la boucle. Vous pouvez écrire plusieurs déclarations dans cette partie, séparées par des virgules.
Bloc de contrôle d'étatdéfinit la condition d'exécution de la boucle : si elle n'est pas égale à 0 (vrai), la boucle est exécutée.
Bloc de modificationeffectué après chaque itérations cycle et est généralement utilisé pour modifier les paramètres du cycle. Dans la partie modification, vous pouvez écrire plusieurs instructions séparées par des virgules.
Simple ou composé opérateur représente corps de boucle . Toute partie de l'opérateur pour peuvent être omis (mais les points-virgules doivent être laissés en place !). Vous pouvez utiliser l'opérateur virgule (évaluation séquentielle) dans n'importe quelle partie, par exemple :
pour (int je = 1, s = 0; je<= 100; i++)
S + = je; // somme de nombres de 1 à 100
Exemple (le programme imprime un tableauvaleurs de fonction y=x2 +1 dans la plage saisie) :
#inclure
int main()
flotteur Xn, Xk, Dx ;
printf("Entrez la plage et l'incrément de l'argument : ");
scanf("%f%f%f", &Xn, &Xk, &Dx);
Pour (float X = Xn; X<= Xk; X += Dx)
Printf("\n %5.2f %5.2f", X, X*X + 1);
2.9 Boucles imbriquées
Chacun des opérateurs de boucle peut être imbriqué dans n’importe quel autre dans n’importe quel ordre. La profondeur d'imbrication des boucles n'est pas limitée. Il est déterminé uniquement par l'algorithme du problème à résoudre.
Ci-dessous un exemple de boucles imbriquées pour
Ce fragment de programme fonctionne comme suit. Pour une valeur de paramètre de boucle externe je (par exemple, je = 1 ) paramètre de boucle interne j varie dans la plage allant de la valeur minimale à la valeur maximale (de 1 à M ). Ce n'est qu'après que le paramètre je augmente de un. Ainsi, le corps de la boucle sera exécuté N * M fois.
D'autres variantes de boucles imbriquées fonctionnent de la même manière : le paramètre de la boucle externe change lentement et celui de la boucle interne change rapidement. Il est recommandé de les maîtriser vous-même. Pour ce faire, le diagramme d'algorithme de boucle interne doit être inséré entièrement à la place du bloc de corps de boucle.
2.10 Opérateurs de transfert de contrôle
En C++ Il existe cinq opérateurs qui modifient l'ordre naturel des calculs :
- instruction de sortie de boucle et coupure d'interrupteur ;
- opérateur de sautà la prochaine itération de la boucle, continuez ;
- opérateur de retour de fonction retour ;
- opérateur transition inconditionnelle aller à ;
- opérateur de lancement d'exception lancer .
Saut de l'instruction de sortie utilisé pour une réalisation immédiate instruction de boucle ou de commutation . L'exécution est transférée à l'opérateur suivant après celle terminée.
Regardons son utilisation à l'aide d'un exempleboucle itérative ouverte pour . En utilisant l'exemple du calcul de la somme des nombres de 1 à 100.
int je = 1, somme = 0 ;
pour (; ;)
Si (i > 100) pause ;
somme += je ;
je++;
Opérateur pour passer à l'itération suivante la boucle continue ignore toutes les instructions restantes jusqu'à la fin corps de boucle , et transfère le contrôle pour modifier les paramètres de la boucle (dans le cas d'une boucle pour ) et le début du suivant itérations
Considérons son utilisation à l'aide de l'exemple du calcul de la somme 1 / x si x varie dans la plage [-5, 5].
#inclure
int main()
float X, Somme = 0 ;
pour (X = -5; X<= 5; X++)
Si(X == 0)
Continuer;
Somme = Somme + 1 / X ;
Printf("\n Somme = %f", Somme);
Instruction de retour de fonction retour termine l'exécution d'une fonction et transfère le contrôle au point où elle a été appelée. Nous l'examinerons ainsi que ses fonctions dans la rubrique correspondante.
Opérateur de saut inconditionnel goto a le format :
aller à l'étiquette ;
Le corps d’une même fonction doit contenir exactement une construction du formulaire :
étiquette : opérateur ;
aller à la déclaration transfère le contrôle à l’opérateur marqué.Étiquette c'est un identifiant régulier,portéequelle est la fonction dans le corps de laquelle cela se produit.
Usage opérateur de saut inconditionneljustifié dans deux cas :
- sortie forcée du texte du programme à partir de plusieursboucles imbriquéesou des commutateurs ;
- transition de plusieurs endroits dans une fonction à un seul (par exemple, si vous devez toujours effectuer une action avant de quitter une fonction).
Dans d’autres cas, il existe des moyens plus adaptés pour enregistrer n’importe quel algorithme.
Situation exceptionnelle(ou juste une exception ) est généré soit par le programmeur à l'aide de l'opérateur lancer , ou le runtime lui-même. Cela se produit lorsqu'une erreur se produit lors de l'exécution du programme, telle qu'une division par zéro ou débordement . Mécanisme gestion des exceptions, mis en œuvre dans C++ , vous permet de répondre à de telles erreurs et ainsi d'éviter les plantages du programme. On en parlera dans un autre sujet.
D'autres ouvrages similaires qui pourraient vous intéresser.vshm> |
|||
| 2784. | Déclarations conditionnelles et de sélection | 16 Ko | |
| Opérateur de condition Si. Par conséquent, vous pouvez déjà écrire les opérateurs d'affectation suivants : Koren:=Sqrtxy; Module :=bsxy. Pour implémenter de tels sauts conditionnels dans le langage Pascal, les opérateurs If et Else sont utilisés, ainsi que l'opérateur de saut inconditionnel Goto. Regardons l'instruction If. | |||
| 2750. | Opérateurs d'écriture et WriteLn | 12,34 Ko | |
| Écrire en anglais L'opérateur WriteLn effectue la même action, mais puisqu'il a également la terminaison Ln en anglais. Vue générale : Ecrire une liste d'expressions WriteLn une liste d'expressions Les procédures Write et WriteLn permettent non seulement d'afficher le résultat, mais également d'afficher divers messages ou requêtes. | |||
| 6706. | Langage de requêtes structurées - SQL : historique, standards, opérateurs de base du langage | 12,1 Ko | |
| Le langage de requête structuré SQL est basé sur le calcul relationnel avec des tuples variables. Le langage SQL est conçu pour effectuer des opérations sur les tables, créer, supprimer, modifier la structure et sur les données des tables, sélectionner, modifier, ajouter et supprimer, ainsi que certaines opérations associées. SQL est un langage non procédural et ne contient pas d'instructions de contrôle pour organiser les routines, les entrées, les sorties, etc. | |||
Opérations et opérateurs du langage de programmation C. Exemples de programmes.
Structures de contrôle et constructions de base des langages de programmation
Un programme situé dans la mémoire de l'ordinateur occupe une certaine zone de mémoire au moment de son exécution. A chaque instant, l'état du programme est caractérisé par deux types d'informations :
L'état de certaines cellules mémoire, que nous comprenons comme des variables ;
Le point actif du programme, c'est-à-dire la commande du programme en cours d'exécution.
Par conséquent, on peut distinguer deux grandes classes d’actions qu’un système informatique peut effectuer :
Actions qui allouent une zone mémoire pour les variables du programme (descriptions).
Actions qui modifient le point d'exécution du programme (opérateurs, instructions, constructions).
Divers ensembles d'actions de la deuxième classe sont également appelés structures de contrôle.
Généralement, les instructions d'un programme sont exécutées les unes après les autres dans l'ordre dans lequel elles sont écrites. C'est ce qu'on appelle l'exécution séquentielle. Diverses instructions C, dont nous parlerons sous peu, donnent au programmeur la possibilité d'indiquer que la prochaine instruction à exécuter peut être différente de la suivante dans la séquence. C’est ce qu’on appelle le transfert de contrôle.
Au cours des années 1960, il est devenu évident que l’utilisation incontrôlée du transfert de contrôle était à l’origine de la plupart des difficultés rencontrées par les équipes de développement logiciel. La faute a été imputée à l'instruction goto, qui permet au programmeur de transférer le contrôle d'un programme vers l'une des très nombreuses adresses possibles. Le concept de programmation dite structurée est devenu presque synonyme d’« élimination de l’instruction goto ».
Les recherches de Bohm et Jacopini ont montré que la programmation est possible sans aucune instruction goto. Changer le style de programmation en « programmation sans goto » est devenu une devise historique pour les programmeurs. Mais ce n’est que dans les années 1970 que de grands cercles de programmeurs professionnels ont commencé à prendre au sérieux la programmation structurée. Les résultats ont été impressionnants, puisque les équipes de développement de logiciels ont signalé une réduction du temps de développement, une livraison plus fréquente des systèmes à temps et la réalisation des projets dans les limites du budget. La clé du succès réside simplement dans le fait que les programmes créés à l’aide de techniques de programmation structurée sont plus compréhensibles, plus faciles à déboguer et à modifier et, surtout, plus susceptibles d’être écrits sans erreurs.
Les travaux de Bohm et Jacopini en 1966 ont montré que tous les programmes peuvent être écrits en utilisant seulement trois structures de contrôle, à savoir la structure séquentielle, la structure de sélection et la structure de répétition. Ce résultat a été établi par Bohm et Jacopini en 1966 en prouvant que tout programme peut être converti en un programme équivalent constitué uniquement de ces structures et de leurs combinaisons. La structure séquentielle est essentiellement intégrée au langage C. Sauf indication contraire, l'ordinateur exécute automatiquement les instructions C les unes après les autres dans l'ordre dans lequel elles sont écrites.
Ainsi, un programme permettant de résoudre un problème de toute complexité peut être composé de trois structures, appelées suivi (chaîne), branchement et boucle. Chacune de ces structures de contrôle est implémentée dans un langage de programmation par un ensemble de constructions correspondantes.
Les structures de gestion comprennent :
· structure suivante ;
· structure de branchement ;