Cours la condition: if – else – switch/case – opérateur ternaire, tutoriel & guide de travaux pratiques C/C++ en pdf.

Les valeurs clefs et les types nullable

Il existe des valeurs qui sont représentées seulement par des mots clefs. Ces mots clefs sont null, true et false. Pour pouvoir attribuer la valeur null à une variable (de type valeur) on utilise une structure qui contient un booléen et la valeur de type défini(le mot structure est défini partie 2.4). Ce booléen est appelé HasValue. Lorsque sa valeur est à « true » le nullable a une valeur, quand il est à false la variable vaut null.
Cet exemple vous montre les deux méthodes pour faire un nullable.
C#
uint? a = 2;
System.Nullable<uint> b = 15;
b = null;
a += b; // a = null + 2 c’est à dire a = null b = 12;
System.Console.WriteLine(b.ToString()+ »-*-« +a.ToString()+ »-*-« +(a??b).ToString()); System.Console.ReadKey();
Retour Console
Si l’on suffixe le type valeur d’un « ? » on obtient ce type mais nullable. On peut aussi mettre explicitement comme type de la variable nullable comme fait pour la variable b (Pour mieux comprendre l’utilité des chevrons qui dans se contexte ne veulent évidement pas dire « supérieur à », vous pourrez voir les classes génériques dans le chapitre traitant de l’instanciation). Ces variables sont susceptibles de contenir null qui correspond à « néant », « rien » (dans certains cas d’utilisation « non défini »). L’intérêt d’avoir une valeur null est le plus souvent pour mentionner que ce n’est pas défini.
L’autre utilisation de null est la des-allocation de mémoire. Dans le cas ou la variable est de type référence, si lui attribue null (exemple : « variable = null ; ») l’adresse stockée par le pointeur dans la pile sera mise à 0. Lorsque le Garbage Collector contrôlera dans le tas la variable, vu que rien ne pointe dessus elle sera supprimée.
Le Cast
Le cast est un moyen d’utiliser une variable qui n’est pas du type à utiliser pour le calcul. C’est à dire le cast permet de retourner une valeur du type attendu à partir de la variable. Ainsi on pourra par exemple caster un int en long pour utiliser une variable n’ayant pas les même limites de dépassement. Il y a deux moyens pour essayer de changer le type d’un objet, un évite les erreurs quand on n’est pas sur que l’objet puisse être casté et l’autre retype ou renvoie une erreur ou une valeur aberrante (pour comprendre quand on a une erreur ou une valeur aberrante regardez la partie sur checked/unchecked).
Le mot clef « as » doit caster vers un type nullable ou référence (voir partie 2.7). Si la variable est du type requis ou « compatible », as retourne la valeur typée. Au cas contraire il retournera null. Le « as » est traduit avec d’autres opérateurs dans l’exemple. Pour rappel, l’opérateur « ?? » sert à retourner une autre valeur si le premier élément est null, il est parfois utilisé avec as pour avoir un retour en cas d’impossibilité de cast différent de null.
Le cast classique consiste à imposer à une variable de changer de type, si ce changement de type ne fonctionne pas une exception est levée.
C#
int a = int.MaxValue;
long b = long.MaxValue;
long c = 15;
// cast implicite object o = c;
// cast explicite necessaire
a = (int)b; //lève une overflowexeption si les dépassements sont contrôlés
// cast implicite
b = a; //fonctionne
// usage de as et de l’opérateur ?? b = (o as long?) ?? 0 ;
// équivau à l’instruction:
b = ((o is long?) ? ((long?) o) : ((long?)null) ) ?? 0;
// l’opérateur ternaire sera détaillé dans la partie qui suit.
// ici, seuls « long » et « long? » fonctionnent pour le type de c
Console.WriteLine(b);
System.Console.ReadKey();

La condition: if – else – switch/case – opérateur ternaire

Le mot clef if (en français « si ») permet l’exécution conditionnelle de code. La condition soumise à if doit retourner un Booleen (True ou False), nous utiliserons souvent ici des opérateurs de test. Ensuite nous passons la procédure à exécuter si la condition est vraie entre accolades.
Souvent, et c’est vrai avec beaucoup de mots clefs, quand les accolades ne paraissent pas à la suite de la condition, le mot clef s’appliquera uniquement sur l’instruction qui suit.
Le mot clef else (sinon) est toujours précédé d’au moins un if. else comme if est suivi de code entre accolades. Ce code sera utilisé seulement si la dernière instruction if n’a pas eu à exécuter le bloc. Si l’on doit procéder à une série de test ou un seul doit être exécuté, vous verrez une suite du genre « if, *else if, else if…+, else », seule la procédure associée de la première condition vraie sera exécutée.
Le mot clef switch permet seulement de contrôler différentes valeurs que peut prendre une variable ou expression et d’agir en fonction. Les propositions ne peuvent pas être des variables, il ne peut pas y en voir 2 identiques, tous les types de valeurs ne peuvent y être utilisés et pour ce qui est des performances le switch est la moins optimisée des 3 solutions. Néanmoins certains développeurs trouvent sa syntaxe plus lisible et plus pratique que l’imbrication de « if ».
La syntaxe de l’opérateur ternaire est la suivante : « (booléen) ? retourSiVrai : retourSiFaux ». On peut bien évidemment en imbriquer plusieurs pour cumuler plusieurs conditions. Mais il faut noter que l’opérateur ternaire permet un retour conditionnel et non pas une exécution conditionnelle, c’est-à-dire qu’il ne peut rien exécuté et qu’il se place dans des expressions comme une valeur.
C#
int a;
string b;
System.Console.WriteLine(« Entrez 2 »);
a = int.Parse(System.Console.ReadLine());
/* int.Parse prend le texte entré par l’utilisateur (Readline())
* et en retourne la valeur indiquée si ce texte contien un nombre.
*/
// Méthode if/else if (a == 2)
{
a = a; // a=a est une instruction inutile à titre d’exemple
b = « normal » ; // on peut mêtre plusieurs instructions
}
else if (a == 1 || a == 3)
b = « Pas loin »; // on peut se passer d’acollade pour une instruction seule
else // on aurai pu remplacer « else » par « if(a < 1 || a > 3 ) »
{
b = « bizarre »; // une instruction seule passe même avec les acollades
}
// Méthode switch/case switch (a)
{
case 2:// le switch saute à cette condition si a vaut 2 b = « Bien Joué ! »; // puis exécute ses instruction
break; // Le break fait sortir du switch
case 1: // en C# : pas de break = pas d’instructions
case 3: // le cas 1 vien exécuter les instructions du cas 3
b= »Pas loin »;
break; // donc on sort du switch
default: // default représente tous les autres cas
b = « bizarre »;
break;
}
// Méthode opérateur de retour conditionel
b= (a == 2) ? « normal » : (a == 1 || a == 3) ? « Pas loin » : »bizarre » ;
System.Console.WriteLine(b);
System.Console.ReadKey();
Cet extrait de code montre trois manières de faire la même chose, Le programme demande à l’utilisateur d’entrer une valeur qui est affecté dans « a ». A la fin on affiche la chaine de caractère
« b ». Entre trois façons pour mettre dans « b » :
• la chaine « Bien joué ! » si « a » est égal à 2
• « Pas loin » si « a » est égal à 1 ou 3
• « bizarre » si « a » ne répond à aucun de ces critères.
Comme expliqué antérieurement, on constate que suite au « if » il y a une condition elle-même suivie d’une ou plusieurs instructions. Dans le cas de l’exemple ci-dessus si « a » est égal à 2 « a==2 » retourne vrai ce qui engendre l’exécution de l’affectation de « Bien joué ! ». Lorsque l’on utilise le mot clef if juste après le « else » c’est pour faire une liste de test, le premier vrai sera le seul exécuté.
Le switch permet donc ici de tester les cas qui nous intéressent individuellement c’est-à-dire 1, 2 et 3. Vu que le cas 1 et le cas 3 ont le même traitement on peu les réunir. Le mot clef break doit être mis en fin d’exécution avant la nouvelle valeur du switch. Si vous voulez plus de renseignement sur le switch ou en cas de problèmes avec ce mot clef ou si vous voulez voir les différences entre le switch C et le switch C#, je vous recommande cet article francophone.
Imbriqué, l’opérateur ternaire n’est pas un cadeau pour ce qui est de la lisibilité. Pour rendre plus clair à l’œil, nous aurions pu mettre des parenthèses autour de la sous expression ternaire ou la mettre à la ligne. Vous avez néanmoins pu constater l’aspect pratique de cet opérateur qui est celui qui a eu la syntaxe la plus rapide, ça n’aurai pas été pour l’exemple, j’aurai certainement mis l’expression directement en argument de la méthode WriteLine sans passer par « b ». Bien qu’il puisse paraitre pratique et assez optimisé pour ce qui est des performances, l’opérateur ternaire va par son manque de lisibilité à l’encontre des principes des langages récents qui visent le confort de développement et la lisibilité. Il sera principalement utilisé en argument de fonction vu qu’on ne peut pas vraiment y mettre des exécutions conditionnelles.

Les boucles: while – do – for – goto

Les boucles font parti des fondamentaux de la logique de la programmation, notre prochain exemple ressemblera enfin à quelque chose vu que l’on aura vu après ça l’essentiel de la partie structure logique des instructions dans une procédure.
While
While (en français « tant que ») permet de faire une boucle conditionnelle, probablement le type de boucle que vous croiserez le plus avec les boucles for. Niveau structure il ressemble au if, il a une condition entre parenthèses et un block de code nécessairement entre accolade pour peu qu’il ait plusieurs instructions. Si la condition du while est vraie le block de code est exécuté, à la fin de cette exécution, le block est exécuté à nouveau si la condition et vrai et ce jusqu’à ce que ce ne soit plus le cas.

1 Introduction
1.1 Qu’est-ce qu’un langage de programmation
1.2 Pourquoi l’orienté objet
1.3 Un peu d’histoire
1.4 Un exemple
1.5 Gestion de la mémoire vive en .NET
2 La syntaxe procédurale : logique C/C++ appliquée en C#
2.1 Variables, opérateurs numérique et types.
2.1.1 Les types
2.1.2 Les opérateurs
2.1.3 Exemple de calculs et de déclaration de variable
2.1.4 Les chaines de caractères : quelques détails
2.1.5 Les valeurs clefs et les types nullable
2.1.6 Le Cast
2.2 La condition: if – else – switch/case – opérateur ternaire
2.3 Les boucles: while – do – for – goto
2.4 Array – enum – struct
2.4.1 foreach
2.5 Gestion des erreurs : try-catch – finally
2.6 Instructions préprocesseurs
2.7 Le code « unsafe » et « checked / unchecked »
3 L’orienté Objet en C#
3.1 Introduction
3.2 Using
3.3 Instanciation
3.3.1 L’attribut et le modificateur d’accès
3.4 La propriété
3.5 Static
3.6 Les méthodes
3.6.1 Retour sur Main
3.6.2 Constructeur / destructeur
3.6.3 La surcharge
3.6.4 Delegate
3.6.5 Les événements
3.6.6 Méthodes anonymes et Expressions lambda
3.6.7 Méthode d’extension.
3.6.8 Itérateurs
3.7 L’héritage, le polymorphisme et les interfaces
3.7.1 Introduction
3.7.2 Exemples d’héritage : les exceptions et throw
3.7.3 Redéfinition de méthodes et d’attributs
3.7.4 Les interfaces
3.7.5 Les attributs
4 Conclusion