C#: Les instructions

C#: Les instructions

C#: Les instructions
 


C#: Les instructions

Introduction

    Introduction

  • Un programme se compose d’une suite d’instructions. Au moment de l’exécution, ces instructions sont exécutées les unes après les autres, dans l’ordre dans lequel elles figurent dans le programme, de gauche à droite et de haut en bas.
  • Une instruction peut être constituée d’une ligne unique de code qui se termine par un point-virgule, ou d’une série d’instructions sur une ligne dans un bloc.
  • Un bloc d’instructions est placé entre accolades {} et peut contenir des blocs imbriqués ou un autre bloc imbriqué.
  • Une variable déclarée dans un bloc est qualifiée de variable locale. La portée d’une variable locale s’étend de sa déclaration jusqu’à l’accolade fermante qui délimite la fin de son bloc.
  • Dans C#, vous ne pouvez pas déclarer un nom de variable identique dans un bloc interne et externe.
Par exemple, le code suivant n’est pas autorisé :
  • Vous pouvez toutefois déclarer des variables portant le même nom dans des blocs adjacents. Les blocs adjacents sont délimités par le même bloc parent et sont imbriqués au même niveau.
Exemple de déclaration autorisée
  • Le langage C# est un langage de programmation structuré offrant des structures de contrôle :
    une sélection (alternative), une répétition (boucle) et un appel de méthode.
  • La sélection permet d’exécuter ou non un bloc d’instructions selon une condition qui est vraie ou fausse.
  • La répétition permet de répéter un bloc d’instructions un certain nombre de fois.
  • L’appel de méthode permet de diriger le contrôle de l’exécution vers une autre section du code. Une fois la méthode terminée, le contrôle revient à l’instruction qui suit l’appel de cette méthode.
Les instructions de sélection

    Les instructions de sélection

  • Les instructions if et switch sont des instructions conditionnelles (également appelées instructions de
    sélection). Ces instructions prennent des décisions en fonction de la valeur des expressions et
    exécutent des instructions de manière sélective en fonction de ces décisions.
  • Les instructions de sélection permettent de se brancher à différentes sections de code, en fonction d’une ou plusieurs conditions spécifiées.
  • Une instruction de sélection fait en sorte que le contrôle du programme soit transféré à un flux spécifique selon si une certaine condition est true ou non.
  • Les mots clés suivants sont utilisés dans des instructions de sélection :

  1. if-else
    • Syntaxe:

    • Une instruction if identifie l’instruction à exécuter en fonction de la valeur d’une expression Boolean. Dans l’exemple suivant, la variable Booleanresult est définie sur true puis archivé dans l’instruction if.
    • L’instruction if peut être associée à une clause else facultative, comme illustré ci-dessous :
    • L’instruction else if permet de traiter les instructions if en cascade.
    • L’instructions else if permet un nombre indéfini de branchements. Cependant, les instructions contrôlées par une instruction if en cascade étant mutuellement exclusives, une seule instruction de l’ensemble de constructions else if sera exécutée.

      Exercice_apcpedagogie08

      • Ecrire un programme C # qui accepte deux nombres saisie par l’utilisateur.
      • Si l’utilisateur à pressé l’une des touches numériques (0-9), le programme affiche le nombre qui est pressé
      • Si non le programme affichera “Touche non autorisée”.
      • Si l’utilisateur à saisie les deux nombres le programme affichera :.
        • Le premier nombre est égal au deuxième nombre.
        • Le premier nombre est inférieure au deuxième nombre.
        • Le premier nombre est supérieure au deuxième nombre.
      • Solution


      Exercice_ValeurAbsolue

      • Ecrire un programme C# servant à calculer la valeur absolue d’un nombre réel x à partir de la définition de la valeur absolue ci-dessous.
      • La valeur absolue d’un nombre réel x est le nombre réel |x| :
        |x| = x , si x>=0
        |x| = -x si x < 0.


  2. switch
  3. Syntaxe

    • L’instruction switch est une séquence de contrôle qui sélectionne une section switch à exécuter dans une liste de candidats.
    • L’instruction switch offre une méthode de traitement des conditions complexes plus élégante que les
      instructions if imbriquées.
    • Chaque section switch contient un ou plusieurs noms de cas suivis d’une ou de plusieurs instructions.
    • Elle se compose de plusieurs blocs de case, chaque bloc spécifiant une
      constante unique et une étiquette case associée.
    • Un bloc switch peut contenir des déclarations. La portée d’une variable locale ou d’une constante
      déclarée dans un bloc switch s’étend depuis sa déclaration jusqu’à la fin du bloc switch.
    • L’exemple suivant montre une instruction switch simple qui a trois sections switch. Chaque section switch a un nom de cas, tel que case 1 et une liste de deux instructions.
    • L’instruction switch transfère le contrôle à la section switch dont l’étiquette case correspond à la valeur de l’expression switch (caseSwitch dans l’exemple).
    • Si aucun nom de cas ne contient de valeur correspondante, le contrôle est transféré vers la section default, s’il y en a une. S’il n’y a aucune section default, aucune action n’est effectuée et le contrôle est transféré à l’extérieur de l’instruction switch.
    • Dans l’exemple précédent, les instructions dans la première section commutateur sont exécutées car case 1 correspond à la valeur caseSwitch.
    • L’instruction switch évalue uniquement les types d’expressions suivants : tous les entiers, char, enum et string. Vous pouvez toutefois évaluer d’autres types d’expressions à l’aide de l’instruction switch du moment qu’il existe précisément une conversion implicite définie par l’utilisateur du type non autorisé vers les types autorisés.
    • Exercices d’applications

      Exercice_apcpedagogie02

      • Ecrire un programme C # pour détecter les touches pressées par l’utilisateur.
      • Si l’utilisateur presse l’une des touches numériques (0-9), le programme affiche le nombre qui est pressé
      • Si non le programme affichera “Touche non autorisée”.

      Solution

       

      Exercice_apcpedagogie04

      • Ecrire un programme C # qui permet à l’utilisateur de choisir la bonne réponse d’une question.
      • Quelle est la bonne façon de déclarer une variable pour stocker une valeur entière en C #?
        • a: 1x int = 10;
        • b: int x = 10;
        • c: float x = 10.0f;
        • d: string x=”10″;
      • Choisissez la lettre de réponse juste:

      Solution

       

      Exercice Instructions switch 003

      • Ecrire un programme C # qui permet à l’utilisateur de saisir une lettre, et le programme vérifie si c’est bien une lettre de l’alphabet en premier temps puis il teste si la lettre saisie est la première d’un grade en deuxième lieu.
      • le programme affiche le grade suivant le tableau suivant:
        • e: Excellent;
        • t: Trés bien;
        • b: Bien;
        • m: Mauvais;
        • p:Passable;
        • l:la Moyenne;
        • a:non Admis;
        • s:Succès;
      • Grade non trouvé:

      Solution


  4. switch. . .case
    • L’instruction switch . . .case est une sélection à n branches.
    • Elle est utilisée dans le cas où l’on doit vérifier si une variable ou une expression est égale à des valeurs déterminées.
    • Les instructions à effectuer sont indiquées pour chacune des valeurs (case) de la variable ou de l’expression.
    • Le switch est un raccourci d’écriture d’un if imbriqué dont les conditions sont des comparaisons d’égalité sur la même variable ou expression.
    • Il peut y avoir un nombre quelconque d’étiquettes case.
    • Les étiquettes case ne peuvent pas avoir la même valeur.
    • L’instruction de saut break est nécessaire après chaque bloc.
    • Les étiquettes case sont exécutées dans l’ordre. Placer le cas qui se produit le plus souvent au début.
    • S’il n’y a pas d’étiquette default, le contrôle est transféré à l’extérieur du switch.
    • Il est possible d’empiler les étiquettes case. Voir les cas “Très Petit” et “Petit” dans l’exemple #1 ci-dessous.
    • Dans l’exemple si-dessous la comparaison est effectuée avec la variable choix Grandeur de type string.
    Dans l’exemple suivante la comparaison est effectuée avec la variable choix de type int.

    Dans l’exemple suivante la comparaison est effectuée avec la variable cote de type char.

Les instructions d’itération

  • Les instructions d’itération font exécuter des instructions incorporées un certain nombre de fois, selon les critères de terminaison des boucles.
  • Ces instructions sont exécutées dans l’ordre, sauf quand une instruction de saut est rencontrée.
  • Les mots clés suivants sont utilisés dans des instructions d’itération :

  • do
  • for
  • foreach
  • in
  • while

  1. L’instruction while
  2. Syntaxe

        • L’instruction de répétition while sert à exécuter un bloc d’instructions, un nombre de fois non connu.
        • En programmation, la boucle while, francisée en boucle tant que, est une structure de contrôle permettant d’exécuter un ensemble d’instructions de façon répétée sur la base d’une condition booléenne.
        • La boucle while peut être considérée comme une répétition de l’instruction if.
        • Une déclaration de boucle while en C # exécute à plusieurs reprises une déclaration cible tant qu’une condition donnée est vraie.

    C#: Les instructions

        • Parmi les instructions d’itération, while est la plus simple à utiliser. Elle exécute une instruction incorporée tant que l’expression booléenne est vraie.
        • L’instruction while répète une instruction ou un bloc
          d’instructions jusqu’à ce qu’une expression spécifique corresponde à la valeur false.
        • Une boucle while peut être terminée lorsqu’une instruction break, goto, return, ou throw transfère le contrôle à l’extérieur de la boucle.
        • Pour transmettre le contrôle à la prochaine itération sans sortir de la boucle, utilisez l’instruction continue.
        • Pour cet image, un point clé de la boucle while est que la boucle pourrait jamais fonctionner .
        • Lorsque la condition est testé et le résultat est faux , le corps de la boucle est ignorée et la première déclaration après la boucle while est exécutée.

      Une instruction while s’exécute comme suit :

          1. L’expression booléenne qui contrôle l’instruction while est évaluée.
          2. Si l’expression booléenne a la valeur true, l’instruction incorporée est exécutée. À la fin de cette
            exécution, le contrôle repasse implicitement au début de l’instruction while et l’expression booléenne
            est de nouveau analysée.
          3. Si l’expression booléenne a la valeur false, le contrôle est transféré à la fin de l’instruction while.
            Par conséquent, le programme ré-exécute l’instruction incorporée tant que l’expression booléenne a la valeur true.
        • L’expression booléenne étant testée au début de la boucle while, il est possible que l’instruction incorporée ne soit jamais exécutée.
      • Exemple:

        Extraire les chiffres d’un nombre.

      • Exemple:Lors de la lecture dans un fichier texte, le nombre de lignes à lire n’est pas connu.
        La boucle while doit être utilisée.
            • La boucle for est un cas particulier de la boucle while.
            • Lorsqu’un compteur contrôle le nombre de répétitions, la boucle for est utilisée.
      • Exemple: Afficher 5 fois le mot allo.

    Exercice d’application:

    Exercice_apcpedagogie013

    • créer un mini-jeu “Le nombre mystère”sur console c# qui répond aux conditions suivants.
      • Un nombre est tiré hasard entre 0 et 100 (les deux inclus : [0; 100]).
      • On demande au joueur d’entrer un nombre.
      • Si ce n’est pas un nombre entre 0 et 100, on indique qu’il y a une erreur.Sinon, on compare avec le nombre tiré au sort :
      • Soit c’est le même, alors le jeu est terminé.
      • soit le nombre entré ne convient pas et il faut indiquer au joueur si le bon nombre est inférieur ou supérieur au nombre mystère.

    Solution

    Exerciceinstruction While 001
    • Ecrire un programme qui affiche la table de multiplication des entiers inférieur ou égaux à 10.
    • Utiliser deux boucles whiles

    Solution

  3. L’instruction do
      • L’instruction do est toujours accompagnée d’une instruction while.
      • L’instruction de répétition do … while sert à exécuter un bloc d’instructions, un nombre de fois inconnu.
      • Cependant, le bloc d’instructions est toujours exécuté au moins une fois car la condition est placée après le bloc d’instructions.
      • La boucle do … while est souvent utilisée lorsqu’il faut valider des données.
      • Elle est similaire à l’instruction while, à cette différence près que l’analyse de l’expression booléenne qui détermine la poursuite ou la sortie de la boucle s’effectue en fin de boucle, et non pas au début. Cela signifie que, contrairement à une instruction while qui est exécutée zéro ou plusieurs fois, une instruction do est exécutée une au moins fois.
        Syntaxe :

      • Les instructions sont exécutées une fois avant que l’expression booléenne soit vérifiée.
      • C’est la principale différence avec la boucle while.
      • Si l’expression booléenne est évaluée à true, les instructions sont exécutées à nouveau.
      • À la fin l’exécution du bloc d’instructions, l’expression booléenne est vérifiée.
      • Dès qu’elle est évaluée à false, le contrôle passe à l’instruction suivant la boucle.
      • Si la condition n’est jamais évaluée à false, c’est une boucle infinie.
      • Exemple : Afficher les nombres de 0 à 4.

    Exercice instruction Do While 001
    • Ecrire un programme c# qui vous permet de calculer la moyenne d’un nombre de notes, inconnu qu départ.
    • Faite saisir au clavier des notes entre 0 et 20 (une note incorrecte ne sera pas prise en compte)
    • A chaque note saisie ,demandez à l’utilisateur s’il souhaite continuer (réponse dans un caractère : O ou n)
    • Afficher sur la console la moyenne des notes saisie

    Solution

  4. L’instruction for
          • L’instruction for, aussi appelée boucle compteur, sert à exécuter un bloc d’instructions, un nombre déterminé de fois.
          • La variable utilisée pour le nombre de fois est appelée un compteur et est de type int.
          • La boucle for permet de répéter un certain nombre de fois des instructions

      Syntaxe


          //Clarifications:

              • initialisation:assigne une valeur à la variable compteur
              • condition:vérification de la condition : tant qu’elle est vraie, la boucle continue
              • instructions:exécution si la condition est vraie
              • incrémentation/décrémentation:augmentation ou diminution de la variable compteur avant de vérifier à nouveau la condition.

              Exemple:Écrire 5 fois le mot “apcpedagogie.com” sur des lignes différentes(retour à la ligne).

                  • Comme dans toutes les instructions de répétition, la condition d’un bloc for doit être une expression
                    booléenne qui tient lieu de condition de poursuite de la boucle et non pas de condition de fin.
                  • Il existe une petite différence entre les instructions while et for : la portée d’une variable déclarée dans le code d’initialisation d’une instruction for est limitée au bloc for. Ainsi, l’exemple suivant génère une erreur de compilation :

                Surcharge :

    • L’instruction foreach
        • C# fournit l’instruction foreach, qui permet de parcourir chaque élément d’une collection sans recourir
          à une longue liste d’instructions.
        • L’instruction foreach est une structure de contrôle permettant de parcourir automatiquement une collection sans utiliser un compteur.Le bloc d’instructions est exécuté pour chacun des items de la collection : du premier au dernier item.
        • Plutôt que d’extraire explicitement chaque élément d’une collection avec une syntaxe spécifique à la collection, l’instruction foreach permet d’aborder le problème différemment.
        • Ce n’est plus l’instruction incorporée qui est apportée à la collection, c’est la collection qui est apportée à l’instruction incorporée.

      Syntaxe

      //Clarifications:

          • type :le type de l’élément contenu dans la collection
          • item :identificateur de variable locale utilisé comme nom associé à l’item courant
          • in:opérateur d’accès à chacun des items de la collection
          • Collection:nom de la collection à parcourir.
          • instructions:les instructions contenues dans la boucle peuvent modifier le contenu d’un item de la collection,mais il ne faut pas ajouter et supprimer d’items.

      Exemlpe:Compter le nombre de ‘c’ contenu dans une chaîne de caractère,”je lis mon cours dans apcpedagogie.com”.

       

      Exercice Instructions for 001

        Ecrire un programme en c# qui affiche les 31 jours du mois de Janvier à l’aide d’une boucle for.

      Solution

       

      Exercice Instructions for 002

      • Écrire un programme en c# qui affiche un calendrier pour une année entière.
      • Utilisez les deux méthodes Console.Write() et Console.WriteLine().
      • La représentation finale sera :
        • (1 jours du mois 1;2 jours du mois 1;3 jours du mois 1;…..
        • ————————–
        • (1 jours du mois 2;2 jours du mois 2;3 jours du mois 2;…..
        • ————————–
        • (1 jours du mois 3;2 jours du mois 3;3 jours du mois 3;…..

      Solution

Les instructions de saut

Les instructions de saut passent le contrôle sans condition.


jump-statement
break-statement
continue-statement
goto-statement
return-statement
throw-statement



C#: Les instructions

  1. break-statement
    • Une instruction break permet de sortir de la plus proche instruction switch, while, do, for ou foreach qui l’entoure.
    • Lorsque l’instruction break est rencontrée dans une boucle, la boucle est immédiatement arrêtée et le contrôle du programme reprend à la prochaine instruction qui suit la boucle.
    • Il peut être utilisé pour mettre fin à une affaire dans l’instruction switch.
    • Exemple:

  2. continue-statement
    • Une instruction continue Provoque la boucle pour passer le reste de son corps et immédiatement retester son état avant de réitérer.
    • Une instruction continue provoque une nouvelle itération de la plus proche instruction switch, while, do, for ou foreach qui l’entoure.
    • L’instruction continue en C # fonctionne un peu comme l’instruction break. Au lieu de forcer la fin, cependant, continuer les forces de la prochaine itération de la boucle de prendre place, sauter tout code entre les deux.
    • C#: Les instructions
      Exemple

  3. goto-statement
    • Goto transfère le contrôle à une étiquette nommée . Il peut être utilisé pour sortir d’une boucle imbriquée .
    • L’instruction goto est l’instruction de saut la plus primitive du langage C#. Elle permet de passer le contrôle d’exécution à une instruction marquée par une étiquette.
    • L’étiquette doit exister et sa portée doit s’étendre à l’instruction goto. Plusieurs instructions goto peuvent transférer le contrôle d’exécution vers la même étiquette.
    • La Déclaration Goto exige une étiquette pour identifier l’endroit où la branche doit être faite . Une étiquette est un nom de variable valide et doit être suivi par deux points (:) .
    • Une étiquette est placée immédiatement avant l’état où le contrôle doit être transféré .
    • L’ instruction goto peut transférer le contrôle à tout endroit dans un programme.
    • Exemple:

  4. return-statement
    • Dans ce chapitre , vous serez capable de :

      • Déclarer return en C #?
      • Connaitre la fonctionnalité de la déclaration de return?
      • Utiliser la déclaration de return dans la programmation?
    • L’instruction return termine l’ exécution de la méthode dans laquelle elle apparaît et renvoie le contrôle à la méthode d’appel.
    • Une déclaration de return est utilisé pour le retour de la valeur à l’appelant de la fonction appelée.
    • Il peut également renvoyer une valeur facultative. Si la méthode est un type de vide, l’instruction de retour peut être omis.

    Exemple:

  5. throw-statement
    • Dans ce chapitre , vous serez capable de :

      • Connaitre l’instruction throw en C #?
      • Connaitre la fonctionnalité de la déclaration de throw?
      • Utiliser la déclaration de throw en C #?
    • Pour lever une exception, le Runtime exécute une instruction throw et lève une exception définie par le système. L’exécution séquentielle normale du programme est interrompue immédiatement et le
      contrôle d’exécution est transféré sur le premier bloc catch capable de gérer l’exception, en fonction de
      sa classe.
    • Les exceptions sont utilisées pour indiquer qu’une erreur est survenue lors de l’exécution du programme.
    • Les objets d’exception qui décrivent une erreur sont créés puis jetés avec le Throw mot – clé.
    • La déclaration Throw est utilisée pour jeter exception dans un programme.
    • L’exception de projection est assurée par bloc catch.
    • L’instruction throw est utilisé pour signaler l’apparition d’une situation anormale (d’exception) au cours de l’exécution du programme.
    • Throw génère ou traduit des exceptions . En utilisant une instruction throw dans un bloc catch , nous pouvons changer l’exception résultant . Sinon, nous pouvons lancer une nouvelle exception . L’ instruction throw est polyvalent et essentiel.
    • Exemple:

      Lever vos propres exceptions

    • Vous pouvez recourir à l’instruction throw pour lever vos propres exceptions :
    • Dans cet exemple, l’instruction throw lève une exception définie par l’utilisateur,InvalidTimeException, si le temps analysé ne correspond pas à une valeur de temps correcte.
    • En règle générale, les exceptions sont créées avec une chaîne de message significatif en paramètre.
    • Ce message est affiché ou enregistré au moment où l’exception est détectée.
    • Il est également recommandé de lever une classe d’exceptions appropriée.
Exercices d’application

Exercice Terminologie

  • Quelles erreurs ont été commises dans chacun des groupes d’instructions suivants :



Exercice Rappel instructions
    Soit le petit programme suivant :

  • Écrire un programme réalisant exactement la même chose, en employant, à la place de l’instruction
  • for :
    • une instruction while,
    • une instruction do ... while.

Exercice_apcpedagogie11
  • Ecrire un programme en C# qui calcul le PGCD de deux entiers non nuls, à partir de la méthode d'Euclide.
  • Rappel de l'algorithme d'Euclide Le principe est: on soustrait un nombre de l'autre autant de fois qu'on peut et on regarde ce qui reste : cela revient à faire une division euclidienne.
  • Commençons par effectuer la division euclidienne du plus grand nombre par le plus petit.
  • Calculer le PGCD de 357 et 561 à l'aide de l'algorithme d'Euclide
  • Réponse:
      561÷357=on obtient 1 en quotient et 204 en reste.==========>561 = 357 x 1 + 204 Après, on continue : On divise le plus petit des deux nombres de la division précédente par le reste de cette division. 357÷204 on obtient 1 en quotient et 153 en reste.==========>357= 204 x 1 + 153 Après, on continue : 204÷153 on obtient 1 en quotient et 51 en reste.==========>204= 153 x 1 + 51 Après, on continue : 153÷51 on obtient 3 en quotient et 0 en reste.==========>153= 51 x 3 + 0 ======> Le dernier reste non nul est 51 donc PGCD (357 ; 561) = 51.
    On dit que deux nombres sont premiers entre eux s'ils n'ont aucun diviseur commun autre que 1, c'est-à-dire si leur PGCD est 1 !

Solution


Exercice_apcpedagogie12
  • Ecrire un programme en C# qui calcul le PGCD de deux entiers non nuls, à partir de la méthode dite algorithme des différences.
  • Rappel de l'algorithme des différences Le principe est: si un nombre est un diviseur de 2 nombres a et b, alors il est aussi un diviseur de leur différence a - b.
  • Commençons par par soustraire le plus grand nombre par le plus petit.
  • Calculer le PGCD de 36 et 60 à l'aide de l'algorithme des différences
  • Réponse:
      60-36=on obtient 24. Après, on continue : On continue en utilisant le résultat obtenu et le plus petit des 2 termes de la soustraction :. 36 - 24 = 12 24 - 12 = 12 12 - 12 = 0 on prend le résultat juste au-dessus du zéro, c'est le PGCD ! (dernier résultat non nul) ======> Le dernier reste non nul est 12 donc PGCD (60 ; 36) = 12.
    On dit que deux nombres sont premiers entre eux s'ils n'ont aucun diviseur commun autre que 1, c'est-à-dire si leur PGCD est 1 !

Solution


Exercice instructions 03

  • Ecrire un programme demandant a l'utilisateur de saisir:
    • Deux valeurs a et b, de type int ;
    • Un opérateur op de type char, vérifi ez qu'il s'agit de l'une des valeurs suivantes : +;-;*;/.
  • Affichez le résultat de l'opération a op b.

Solution


Contenu du chapitre :Les opérateurs et les instructions

  1. Les opérateurs
  2. Les instructions
  3. QCM

Sommaire du cours c#