Bonjour et bienvenue. Dans cette conférence, je veux parler de la déclaration de commutation.
C'est une alternative à une instruction
if, mais elle n'est généralement utilisée que dans des situations spécifiques.
Mais il a une bonne syntaxe sympa pour faire des répétitions dans votre instruction if.
Ainsi, l'opérateur conditionnel et les instructions if than
else facilitent l'écriture de programmes qui choisissent entre deux alternatives.
Il est très facile de poser des questions et de prendre des décisions.
Cependant, plusieurs fois,
un programme doit choisir l'une des nombreuses alternatives.
Et ce serait essentiellement
le if else if else if else if else if.
C'est compliqué car vous pouvez évidemment l'implémenter avec l'instruction if lorsque vous
avez plusieurs alternatives, mais vous
pourriez avoir une centaine de ifs. C'est donc fastidieux, c'est sujette à des erreurs, et
c'est vraiment juste une douleur dans les fesses. C'est comme écrire un tas de code standard.
Donc, l'alternative à cette syntaxe et tout ce que vous pouvez faire
dans le commutateur, vous pouvez le faire dans un if.
Mais c'est plus propre et plus facile à faire et c'est en fait beaucoup plus efficace aussi.
Ainsi, lorsque la valeur d'une variable est comparée avec succès à différentes valeurs,
utilisez l'instruction switch.
Et ce que cela signifie si vous avez une instruction if et que vous avez ensuite une instruction else if, else if,
else if, else if, else if, else if, utilisez l'instruction switch.
Maintenant, si ces expressions booléennes sont un peu plus compliquées.
Vous ne pouvez pas utiliser une instruction switch. Vous ne pouvez
utiliser une instruction switch que lorsque vous comparez à une valeur, comme une constante.
L'expression ne peut pas être si compliquée.
Mais il est beaucoup plus pratique et très efficace d'utiliser l'instruction switch, et la plupart
des langages ont également cette construction. Et voyez c'est très joli. La seule chose que vous
remarquez que de nombreux langages seront construits à partir de c.
Si vous avez programmé avant, vous
allez voir et vous familiariser avec beaucoup de
ces constructions parce qu'elles sont à l'origine sorties dans c ou be, le langage avant.
Voici donc la syntaxe d'une instruction switch. Vous avez le mot-clé switch.
Et puis à l'intérieur du commutateur, vous avez ces parenthèses gauche
et droite, qui est l'expression. Cela ressemble donc à l'instruction if au
début, sauf qu'au lieu du mot-clé if, vous avez le mot-clé switch.
Vous avez alors le crochet gauche.
Les crochets de gauche sont obligatoires. Ce support gauche démarre le corps de l'interrupteur.
Et vous voyez le support droit de fin tout en bas, qui termine le corps de l'interrupteur.
L'autre chose qui est importante ici est le cas de ces mots-clés.
Case est en fait comme
l'instruction if elle-même. Donc, switch va
en fait regarder une expression, pas
si elle est nécessairement vraie ou fausse.
Le commutateur pourrait simplement regarder une variable ou quelque chose.
Et puis il va évaluer cette variable dans les instructions case.
Donc, si la valeur 1 est égale à l'expression,
si la valeur n est égale à l'expression.
Mais vous pouvez voir cela comme
si le commutateur se trouve au niveau supérieur et que les cas sont
chacun une instruction if, comparant les valeurs aux expressions du commutateur.
Les cas sont donc également des mots-clés. Vous remarquez également les deux points après le cas.
Donc vous avez le cas et ensuite vous avez votre valeur.
Et puis à l'intérieur, vous pouvez avoir plusieurs instructions de programme.
Et puis à la fin, vous avez un mot-clé break. C'est un autre mot-clé. Il y a donc
trois mots-clés ici, en fait quatre. Il y a le mot-clé switch, le mot-clé case, le mot-clé
break, puis la valeur par défaut en bas.
Ce sont donc les choses importantes à remarquer. Nous allons passer par un
exemple détaillé, mais vous pouvez avoir différents cas. Et encore une fois, c'est faire comme un if else, if else, if else, else if.
Donc, si la valeur un est une expression égale, exécutez le code.
Sinon, si la valeur deux est égale
à l'expression, évaluez-la. Sinon, si la valeur trois est égale à l'expression, évaluez-la.
Sinon, si la valeur n est égale à l'expression, exécutez le code à l'intérieur de ce bloc.
Et le bloc pour les cas commence par les deux points et se termine par la pause.
Et si vous n'avez pas cette pause là-bas,
elle tombera dans les autres cas. Nous allons en reparler.
Et puis la dernière chose importante ici est ce mot-clé par défaut. C'est essentiellement le else, else
if, else if, else if et alors else en bas.
Donc, cela est défini si aucun des autres cas ne correspond à l'expression.
Parlons donc de certains de ces détails que j'ai mentionnés.
L'expression entre parenthèses est comparée avec succès aux valeurs.
Encore une
fois, si nous revenons à la syntaxe, l'expression est comparée à toutes les valeurs.
Et si cela équivaut à l'une des valeurs, vous exécutez le code à l'intérieur de cette valeur.
Les observations doivent être des constantes simples ou des expressions constantes, des
expressions qui s'évaluent en une constante.
Vous pouvez donc activer x plus y car
si x est égal à 5, cela ne fera qu'activer 10 et comparer les valeurs à 10.
Mais généralement, vous activez une variable égale à une sorte de nombre.
Si un cas est trouvé dont la valeur est égale à la valeur de l'expression,
alors les instructions qui suivent le cas sont exécutées.
Lorsque plusieurs instructions sont incluses, elles n'ont pas besoin d'être fermées entre accolades.
Cela signifie simplement que lorsque
plusieurs instructions sont incluses, il n'y a
pas d'accolades requises pour les instructions case.
N'oubliez pas que pour l'instruction if, nous devrons toujours avoir
ces accolades, ce n'est pas le cas. Vous pouvez simplement les mettre une ligne après l'autre, la clé est la pause.
L'instruction break signale la fin du cas particulier
et provoque la fin de l'exécution de l'instruction,
elle saute.
Si vous n'avez pas la pause là-bas, le prochain cas tombera.
Vous voulez donc inclure la fin de l'instruction break de chaque cas. Lorsque vous n'incluez pas de pauses, cela signifie généralement qu'il
y a un bogue ou quelque chose du genre.
La seule raison pour laquelle vous souhaitez inclure une interruption est si vous avez plusieurs conditions
pour lesquelles vous vouliez exécuter du code. Donc, si vous aviez plusieurs cas,
en disant essentiellement si l'expression était
ce cas, ce cas ou ce cas, alors faites
la même chose,
alors vous supprimeriez les pauses.
Soyez donc prudent avec les ruptures car les ruptures peuvent causer
des problèmes, que certains blocs soient exécutés ou non dans le cas suivant.
Le cas optionnel spécial appelé par défaut est exécuté si la valeur
de l'expression ne correspond à aucun des cas. C'est la même chose qu'une chute, sinon cela se
produit si aucun des cas n'est vrai.
Voici donc un bel exemple où nous créons un commutateur pour évaluer une énumération.
Dans ce cas, nous avons un type enum appelé jour de la semaine, qui
est juste spécifié par tous les jours de la semaine.
Et puis nous avons créé une variable de type enum jour de la semaine et nous l'avons définie sur
Monday, puis nous l'activons aujourd'hui.
Donc, en fonction de la valeur d'aujourd'hui, de la variable,
l'une des instructions case va être exécutée.
Si aujourd'hui est égal à dimanche, il sera imprimé
aujourd'hui, dimanche, puis sautera.
Si aujourd'hui est égal à lundi, il sera imprimé aujourd'hui lundi et sautera.
S'il n'est égal à aucun d'entre
eux, il ira au cas par défaut. Passons donc en revue cet exemple dans des blocs de code.
Ici, nous avons notre exemple de code. Et vous allez voir cela parce qu'aujourd'hui
est égal à lundi, le cas
lundi sera évalué et vous allez voir la sortie aujourd'hui est lundi.
Alors allons-y, construisons ce code et exécutons-le. Et c'est ce que nous allons voir,
aujourd'hui c'est lundi.
Parce que ce qui se passe ici, ce sera le lundi. Vous mettez cette expression
que vous souhaitez évaluer la variable aujourd'hui, puis l'évalue.
Les éléments clés à retenir ici sont que vous
avez un crochet pour commencer l'instruction switch à la ligne 16 dans un crochet
de fin pour terminer le nom du commutateur à la ligne 29.
Vous pouvez avoir plusieurs lignes à l'intérieur de chaque instruction case sans utiliser de crochets.
Voyons maintenant ce qui se passe si
nous supprimons l'instruction break après lundi.
Parce que rappelez-vous, la pause sautera tout de suite hors du boîtier. Mais si nous le
supprimons, ce qui va se passer,
c'est qu'il va tomber jusqu'à mardi et vous allez voir les
deux printfs exécutés pour le lundi d'aujourd'hui et mardi aujourd'hui.
Alors maintenant, lorsque nous exécutons le
programme, nous voyons qu'aujourd'hui c'est lundi, aujourd'hui c'est mardi.
C'est l'importance de la déclaration break.
La pause saute.
Cela pourrait donc être utile si vous vouliez la même sortie pour lundi et mardi.
Ainsi, par exemple, vous verrez parfois des
instructions case comme celle-ci, case Tuesday, car vous voulez la même sortie
et peu importe à quoi la variable est égale.
Donc, vous pouvez voir des choses comme ça, mais lorsque vous avez des instructions de
cas distinctes qui ont une exécution différente, vous devez y ajouter cette pause.
Nous ne regardons donc que dimanche, lundi et mardi.
Que se passe-t-il si nous définissons la valeur d'aujourd'hui égale à
dimanche, car aucun cas ne correspondra à cela.
Eh bien, ce qui va se passer, c'est qu'il passera par la valeur par défaut et qu'il imprimera n'importe quoi.
Alors essayons à nouveau de l'exécuter.
Et nous voyons qu'aujourd'hui, c'est dimanche.
Désolé, définissez-le sur la mauvaise variable. Je veux le régler sur,
disons simplement, mercredi. Nous avons eu un cas pour dimanche.
Alors maintenant, nous allons voir qu'il imprime réellement n'importe quoi parce qu'il ne
correspond à aucun des cas.
Donc, tout ce que vous avez à faire pour switch est vraiment de mémoriser la syntaxe.
L'expression entre parenthèses c'est ce que vous allez évaluer.
Les cas doivent correspondre à l'expression. Donc, généralement, vous faites des variables, c'est pourquoi
il doit s'agir de constantes ou d'expressions qui s'évaluent à une valeur constante spécifique.
Et puis vous avez des cas pour chaque chose, puis un par défaut pour tous les cas, et n'oubliez pas les pauses.
Revenons en arrière et parlons un peu plus et un autre exemple de la construction
de commutateur avec des cas.
Dans cet exemple suivant, c'est un peu différent.
Ce que nous faisons ici, c'est que nous obtenons des données de l'utilisateur, puis nous les activons.
Donc, dans cet exemple de notre fonction principale, il commence par
créer quelques flottants, puis il crée un opérateur de caractère, puis il demande à l'utilisateur
de saisir une valeur, un opérateur et une valeur deux.
Et il utilise des spécificateurs de format pour distinguer, et ils ont tous une adresse d'esperluette.
En fonction du caractère que vous entrez pour l'opérateur, qu'il s'agisse d'un signe plus moins ou une étoile, c'est
ce que vous souhaitez inclure dans votre boîtier de commutation.
Donc, si l'utilisateur a entré un
plus, donc vous voyez dans la colonne suivante ici, la construction de commutateur, il active l'opérateur.
Il va comparer la valeur de l'opérateur, la valeur de l'opérateur variable à chacune
de ces instructions de cas. Et vous remarquerez que ces déclarations
de cas sont entourées de guillemets simples, car nous comparons des caractères.
Ainsi, vous pouvez comparer des
nombres, des variables à des valeurs des constantes spécifiques ou des caractères à des constantes spécifiques.
Et puis à l'intérieur de chaque déclaration de cas, nous imprimons un format spécifique.
Valeur un plus valeur deux, valeur un moins valeur deux.
Nous effectuons actuellement des calculs dans notre impression.
Et là encore, vous voyez ces déclarations de rupture importantes,
celles-ci sautent, et elles sont nécessaires si vous ne voulez pas tomber dans l'un des autres cas.
Vous remarquez également que dans cette dernière instruction case où la barre oblique est le diviseur, nous
avons une instruction if.
Nous n'avons pas de crochets autour du
cas car nous pouvons avoir plusieurs instructions dans chaque cas sans crochets.
Donc, dans le dernier cas, nous disons que si la valeur deux est égale à 0,
nous faisons une petite vérification pour nous assurer de ne pas diviser par 0.
Et si nous ne divisons pas par 0, alors nous allons réellement effectuer notre division.
Et puis à la toute fin de cette affaire, nous avons une autre pause.
Notre cas par défaut indique que vous avez entré un opérateur que nous ne savons pas gérer.
Mais l'instruction switch est très efficace.
Il est très rapide d'écrire chaque fois que vous comparez
de nombreuses valeurs différentes à une variable spécifique et que vous souhaitez faire des choses différentes.
La dernière chose que je voulais mentionner était la déclaration de départ concernant la prise de décision.
Ce n'est pas une déclaration de
décision directe, il s'agit plutôt de passer à une ligne de code différente, en utilisant une
étiquette, mais elle est disponible en c, et c'est pourquoi je voulais le mentionner.
L'instruction go to comporte deux parties, le libellé et le mot clé go to.
Maintenant, pour ceux d'entre vous qui ont déjà
programmé en Fortran ou dans d'autres langages de base, vous allez probablement le reconnaître et
vous l'avez probablement beaucoup utilisé.
En arrivant maintenant à c, il n'est pas nécessaire
de l'utiliser vraiment. Il y a quelques cas
où j'ai vu que c'était assez utile, que j'expliquerai dans une seconde, mais pour aller, c'est sauter à un
code, et vous pouvez accéder à n'importe quelle ligne de code.
L'une des raisons pour lesquelles les gens n'aiment pas l'utiliser, car c'est très difficile à suivre.
Lorsque vous maintenez un programme et s'il est séquentiel, vous passez ligne par ligne,
si des instructions dans les boucles while.
C'est déjà assez grave lorsque vous avez les instructions if dans les boucles while.
Mais maintenant, si vous avez quelque chose où vous êtes fondamentalement à la ligne 27 de votre
code source et que vous allez passer à la ligne 800 sans autre raison que le mot-clé aller à, tout à
coup vous sautez une tonne de code, et c'est très difficile à maintenir et à suivre.
Donc les deux parties vers lesquelles aller et le nom de l'étiquette. L'étiquette est nommée selon la
même convention pour nommer une variable, les caractères alphanumériques, vous ne pouvez pas commencer par des
chiffres, vous pouvez commencer par des traits de soulignement.
vous pouvez commencer par des traits de soulignement.
Fondamentalement, vous utilisez simplement le mot-clé aller à et vous accédez à un identifiant,
la deuxième partie. La deuxième partie est une étiquette quelque part.
Donc, pour accéder à cette ligne de code, vous devez étiqueter cette ligne de code.
Il doit y avoir une déclaration qui dit la deuxième partie.
Je vais maintenant vous montrer un exemple de cela, mais vous ne devriez vraiment
jamais l'utiliser à cause des problèmes liés à la maintenance.
Cependant, je voulais le mentionner si vous avez déjà programmé et que vous avez l'habitude de l'utiliser.
En c, vous n'avez pas vraiment besoin de l'utiliser autant.
Il y a un cas d'utilisation que j'ai vu qui pourrait être utile.
Je travaillais l'autre jour avec un collègue programmeur, et
il avait un tas de boucles imbriquées
ou d'instructions if imbriquées.
Mais les boucles sont probablement le meilleur exemple. Boucles, rappelez-vous, répétez le code. Il avait beaucoup de boucles imbriquées.
Et à la boucle imbriquée très intérieure, comme la cinquième, il
voulait sauter hors de toutes les boucles parce qu'il avait une condition.
Et donc il avait l'habitude d'aller à pour sauter hors de toutes ces boucles.
Maintenant, l'autre façon de sauter hors des boucles consiste à utiliser le
mot-clé frein, mais le frein ne sortira que du plus intérieur.
Donc, il n'y avait vraiment pas de moyen efficace sans qu'il définisse
un tas d'indicateurs et ait un tas d'instructions if pour quitter chaque boucle,
alors il avait l'habitude d'y aller. Et c'était un cas que je trouvais assez
utile car cela réduisait la quantité de code que vous deviez écrire et c'était assez clair sur ce qui se passait.
Vous sautiez juste de toutes les boucles imbriquées parce que
vous remplissiez une certaine condition.
Et c'est un cas. Mais pour la plupart, vous n'avez pas vraiment besoin d'y
aller et pour les raisons que j'ai mentionnées, c'est très problématique, il est difficile de suivre le code lorsque vous sautez partout.
Mais le go to est exactement comme vous l'utilisez comme vous l'utilisez dans d'autres langues.
Vous avez un mot-clé d'accès avec le nom de l'étiquette.
Et ce qui se passera dans votre code, c'est que vous passerez à cette ligne de code avec l'étiquette.
Vous pouvez donc ignorer toutes sortes de codes.
Donc, dans cet exemple ici, nous avons une étiquette appelée top, et elle
a un deux-points. C'est comme ça que vous savez que c'est une étiquette.
Et top a quelques déclarations. Et tout en bas de
cela, vous avez une déclaration if. Et vous dites que si le caractère est égal à y, allez en haut.
Encore une fois, vous voyez comment vous pouvez simplement sauter partout dans votre code et cela le rend très difficile à suivre.
Donc, ne l'utilisez pas fondamentalement, à moins que vous n'ayez beaucoup, beaucoup, beaucoup de boucles imbriquées et que vous
vouliez sauter hors de toutes les boucles. Merci.