Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

Document du 12/12/02 - Retrouvez la version la plus récente sur http://www.up.u

Document du 12/12/02 - Retrouvez la version la plus récente sur http://www.up.univ-mrs.fr/wcpp/lecons.htm Centre Informatique pour les Lettres et les Sciences Humaines C++ : Leçon 4 Structures de contrôle 1 - Expressions et opérateurs booléens ...................................................................................2 Opérateurs de comparaison...................................................................................... 2 Opérateurs logiques ................................................................................................. 2 Expressions booléennes complexes ........................................................................... 3 2 - Conditions ........................................................................................................................4 Exécution conditionnelle simple................................................................................ 4 Exécution alternative................................................................................................ 4 Expression alternative .............................................................................................. 5 Exécution à choix multiple ....................................................................................... 5 3 - Itérations ..........................................................................................................................6 La boucle while() ................................................................................................... 6 La boucle do … while(); ........................................................................................ 7 La boucle for( ; ; ).............................................................................................. 7 Conversion des structures itératives les unes en les autres........................................ 8 4 - Bon, c'est gentil tout ça, mais ça fait déjà 8 pages. Qu'est-ce que je dois vraiment en retenir ?............................................................................................................................9 5 - J'ai rien compris, est-ce que quelqu'un d'autre pourrait m'expliquer ça un peu plus clairement ? ......................................................................................................................9 6 - Pré-requis de la Leçon 5 ....................................................................................................9 C++ - Leçon 4 Structures de contrôle 2/9 J-L Péris - 12/12/02 Maintenant que nous savons définir des variables et des fonctions, il serait peut-être temps d'enrichir un peu notre répertoire d'instructions, de façon à pouvoir écrire des programmes effectuant des traitements un peu moins élémentaires ! Un des outils qui nous fait le plus défaut (au point, d'ailleurs, que le TD 03 ait exigé que nous anticipions sur le cours) est la possibilité d'influer sur le déroulement de l'exécution du programme. La règle générale d'exécution séquentielle (les instructions sont exécutées les unes après les autres, dans l'ordre dans lequel elles apparaissent dans le programme) peut être remise en cause par deux types de structures de contrôle : les unes permettent de décider si un bloc d'instructions doit ou non être exécuté (c'est ce qu'on appelle l'exécution conditionnelle), alors que les autres permettent de spécifier qu'un bloc d'instructions doit être exécuté plusieurs fois de suite (c'est ce qu'on appelle l'exécution itérative ou, plus simplement, une boucle). Ces deux types de structure de contrôle nécessitent l'évaluation d'expressions booléennes ou, en d'autres termes, exigent qu'on exprime des conditions dont le processeur pourra déterminer si elles sont ou non remplies au moment de l'exécution de la ligne de code qui les contient. Il nous faut donc commencer par apprendre à exprimer de telles conditions. 1 - Expressions et opérateurs booléens La façon la plus simple d'exprimer une condition est sans doute une expression procédant à la comparaison directe de deux termes, mais il est également possible d'effectuer des opérations logiques sur des valeurs booléennes. Opérateurs de comparaison Opérateur Signification == égal à != non égal à différent de < inférieur à <= inférieur ou égal à > supérieur à Le langage C++ propose six opérateurs dyadiques1 permettant d'effectuer différentes comparaisons directes. Leur syntaxe est identique : expressionUn opérateur expressionDeux Une expression ainsi formée a pour valeur true si la relation spécifiée par l'opérateur est vérifiée, false dans le cas contraire. Les opérateurs disponibles sont donnés par le tableau ci-contre. >= supérieur ou égal à //exemples de calculs booléens utilisant les opérateurs de comparaison bool v1, v2; //a et b sont des variables numériques supposées précédemment définies v1 = (a < b); //true si le contenu de a est plus petit que celui de b v2 = (a != b); //true si les deux variables ont des valeurs différentes Attention à ne pas confondre l'opérateur de test d'égalité avec l'opérateur d'affectation : comme les expressions bâties avec l'opérateur d'affectation ont une valeur (cf. Leçon 3) et que les valeurs numériques peuvent être converties automatiquement en valeurs booléennes (cf. Leçon 2), le compilateur n'émettra aucune objection s'il rencontre une séquence telle que : //a et b sont des variables numériques supposées précédemment définies bool v = (a = b); //ne serait-ce pas plutôt : bool v = (a == b) ? Dans cet exemple, la variable v prend la valeur false si b contient 0, et true sinon. Il n'est pas certain que ce soit là ce que l'auteur du programme avait en tête… Opérateurs logiques Tout comme les opérateurs arithmétiques conduisent à des résultats numériques par combinaison de données numériques, les opérateurs logiques conduisent à des résultats booléens par combinaison de données booléennes. C++ propose deux opérateurs logiques dyadiques (ET et OU) et un opérateur logique monadique (NON). Le OU inclusif, noté ||, produit des expressions qui sont vraies dès lors que l'un des opérandes est vrai (ou, autrement dit, qui ne sont fausses que si les opérandes sont tous les deux faux). 1 Un opérateur est dit dyadique lorsqu'il suppose la présence de deux opérandes pour former une expression valide. Il arrive parfois qu'un tel opérateur soit qualifié de binaire, mais ce terme présente une certaine ambiguïté (cf. Annexe 5). Un opérateur ne nécessitant qu'un opérande pour former une expression valide est dit monadique (ou unaire), alors qu'un opérateur exigeant trois opérandes sera toujours dit ternaire (par crainte des mafias chinoises ?). C++ - Leçon 4 Structures de contrôle 3/9 J-L Péris - 12/12/02 //exemple de calcul booléen utilisant le OU logique inclusif bool v1; //(a et b sont des variables numériques supposées précédemment définies) v1 = (a > b) || (a == b); //équivaut à v1 = (a >= b); Le caractère | a pour code ASCII 124. Si vous avez du mal à le trouver sur votre clavier, souvenez-vous que Windows permet de saisir n'importe quel caractère en tapant son code ASCII sur le pavé numérique pendant que la touche Alt est maintenue enfoncée. Il est aussi possible (cf. Annexe 1) d'utiliser le mot or (ou, en anglais) en lieu et place du symbole ||. Il n'existe pas d'opérateur OU exclusif en C++. Si vous avez besoin du OU exclusif, c'est à dire d'une expression qui soit vraie lorsqu'une et une seule de deux expressions logiques est vraie, utilisez simplement (expression1) != (expression2). En effet, comme il n'existe que deux valeurs booléennes, la seule situation ou les deux expressions ont des valeurs différentes est celle où l'une est vraie alors que l'autre est fausse. Le ET logique, noté &&, produit des expressions qui ne sont vraies que lorsque les opérandes sont tous deux vrais (ou, autrement dit, qui sont fausses dès lors que l'un des opérandes est faux). //exemple de calcul booléen utilisant le ET logique bool v1; //(a et b sont des variables numériques supposées précédemment définies) v1 = (a > 3) && (b < a); Dans une expression formée avec && ou ||, le second opérande n'est évalué que lorsque la valeur du premier ne permet pas, à elle seule, de déterminer la valeur de l'expression. Ainsi, dans le cas de (a != 0 && (b/a) > c) si a vaut 0, l'expression est fausse de toutes façons et la sous-expression(b/a) n'est pas évaluée, ce qui évite l'erreur d'exécution que causerait la tentative de division par 0. La négation logique, notée !, produit des expressions qui sont vraies lorsque l'opérande est faux (ou, autrement dit, qui sont fausses lorsque l'opérande est vrai). //exemple de calcul booléen utilisant la négation bool v1; //(a et b sont des variables numériques supposées précédemment définies) v1 = !(a > b); //équivaut à v1 = (a <= b); L'usage du point d'exclamation pour exprimer la négation explique pourquoi l'opérateur de comparaison "différent de" est noté != et non <>, comme dans d'autres langages : c'est une allusion à la possibilité de le lire comme signifiant "non égal". Expressions booléennes complexes Etant donné que la combinaison de deux expressions booléennes à l'aide d'un opérateur logique est elle-même une expression booléenne, il est possible d'enchaîner plusieurs opérations logiques, comme par exemple dans l'expression suivante : (a == 3 || a == 27 || a == 42) //vraie si a contient l'une des 3 valeurs Il est toutefois conseillé de limiter strictement ce genre d'expressions aux cas où un même opérateur logique intervient plusieurs fois. En effet, lorsqu'une expression fait intervenir à la fois des OU et des ET (sans même parler de la négation), il se pose un problème d'ordre d'évaluation et l'expérience montre que le risque d'erreur humaine (lors de l'écriture ou de la relecture du programme) croit d'une façon tout à fait disproportionnée en regard des avantages que l'on avait initialement cru voir dans cette façon de s'exprimer. Même lorsqu'un seul opérateur logique est impliqué, l'usage d'expressions complexes pose souvent des problèmes aux débutants. Une erreur classique est d'oublier que les opérateurs de comparaisons sont dyadiques et d'essayer d'exprimer la condition précédente en écrivant : (a == 3 || 27 || 42) //vraie quelle que soit la valeur de a ! Comme les valeurs numériques sont, en cas de besoin, automatiquement converties en valeurs booléennes (cf. Leçon 2), l'expression ci-dessus est syntaxiquement correcte et le compilateur ne signalera aucun problème. (Puisque 27 est non nul, il sera convertit en true et l'expression, où il figure comme opérande d'un OU, sera donc vraie quelle que soit la valeur des autres opérandes.) C++ - Leçon 4 Structures de contrôle 4/9 J-L Péris - 12/12/02 Lorsque la situation exige des calculs logiques un peu complexes, il est souvent uploads/s3/ 04-structures-de-controle.pdf