Concepts de base de la POO

Lien de téléchargement PDF

1.1 De la programmation classique vers la programmation orientée objet
La programmation classique telle que étudiée au travers des langages C, Pascal… définie un
programme comme étant un ensemble de données sur lesquelles agissent des procédures et
des fonctions.
Les données constituent la partie passive du programme. Les procédures et les fonctions
constituent la partie active.
Programmer dans ce cas revenait à :
– définir un certain nombre de variables (structures, tableaux…)
– écrire des procédures pour les manipuler sans associer explicitement les unes aux
autres.
Exécuter un programme se réduit alors à appeler ces procédures dans un ordre décrit par le
séquençage des instructions et en leur fournissant les données nécessaires à
l’accomplissement de leurs tâches.
Dans cette approche données et procédure sont traitées indépendamment les unes des autres
sans tenir compte des relations étroites qui les unissent.
Les questions qu’on peut poser dans ce cas :
1. Cette séparation (données, procédures) est elle utile ?
2. Pourquoi privilégier les procédures sur les données (Que veut-on faire ?) ?
3. Pourquoi ne pas considérer que les programmes sont avant tout des ensembles
objets informatiques caractérisés par les opérations qu’ils connaissent ?
Les langages objets sont nés pour répondre à ces questions. Ils sont fondés sur la connaissance
d’une seule catégorie d’entités informatiques : les objets.
Un objet incorpore des aspects statiques et dynamiques au sein d’une même notion.
Avec les objets ce sont les données qui deviennent prépondérantes. On répond tout d’abord à
la question « De quoi parle-t-on ? »
Un programme est constitué d’un ensemble d’objets chacun disposant d’une partie procédures
et d’une partie données. Les objets interagissent par envoie de messages.

Chapitre extrait du cours de Mlle Sghair Imène 1

1.2 Définitions
1.2.1 POO
La POO est une méthode d’implémentation dans laquelle les programmes sont organisés sous
formes de collections coopératives d’objets, dont chacun représente une instance d’une classe
quelconque et dont toutes les classes sont membres d’une hiérarchie de classes unis à travers
des relations d’héritage.
1.2.2 Algorithmique Objet
Dans l’approche orienté objet un algorithme sera essentiellement vu comme un ensemble
d’objets
auxquels l’utilisateur envoie des messages et qui s’en envoient pendent le fonctionnement.
Ces objets seront toujours pour l’utilisateur des boites noires et qui contiendront des variables
locales, inconnues de l’environnement, et qui ne s’y intéressera d’ailleurs pas. Le seul moyen
d’accéder à ces objets sera l’envoie des messages qu’ils sont capables de comprendre.
Rq : La spécification d’un système dans l’approche OO va s’axer principalement sur la
détermination des objets à manipuler. Une fois cette étape réalisé le concepteur n’aura plus
qu’à réaliser les fonctions de haut niveau qui s’appuient sur les objets et les familles d’objets
définis.
1.2.3 Objet et classe
Un objet est une entité logicielle :
– Ayant une identité
– Capable de sauvegarder un état c’est-à-dire un ensemble d’information dans des variables
internes.
– Répondant à des messages précis en déclenchant des activations internes appropriés qui
changent l’état de l’objet. Ces opérations sont appelées méthodes. Ce sont des fonctions liées
à des objets et qui précisent le comportement de ces objets.
1.2.4 Attributs
Les attributs d’un objet sont l’ensemble des informations se présentant sous forme de variable
et permettant de représenter l’état de l’objet.
1.2.5 Message
Un message est une demande d’activation d’une méthode envoyé à un objet.
1.2.6 Méthodes
Une méthode est une fonction ou procédure liée à un objet qui est déclenchée à la réception
d’un message particulier : la méthode déclenchée correspond strictement au message reçu. La

Chapitre extrait du cours de Mlle Sghair Imène 2

liste des méthodes définies au sein d’un objet constitue l’interface de l’objet pour l’utilisateur
: ce sont les messages que l’objet peut comprendre si on les lui envoie et dont la réception
déclenche les méthodes correspondantes.

1.2.7 Signature
La signature d’une méthode représente la précision de son nom, du type de ses arguments et
du type de donnée retournée.
1.3 Concept de base de la POO
La POO se base sur les notions clés suivantes :
– Encapsulation
– Abstraction
– Classe et objets
– Héritage
– Polymorphisme
1.3.1 Encapsulation
L’encapsulation est le faite qu’un objet renferme ses propres attributs et ses méthodes. Les détails de
l’implémentation d’un objet sont masqués aux autres objets du système à objets. On dit qu’il ya
encapsulation de données et du comportement des objets.
On précise trois modes d’accès aux attributs d’un objet.
– Le mode public avec lequel les attributs seront accessibles directement par l’objet lui-même ou par
d’autres objets. Il s’agit du niveau le plus bas de protection.
– Le mode private avec lequel les attributs de l’objet seront inaccessibles à partir d’autres objets :
seules les méthodes de l’objet pourront y accéder. Il s’agit du niveau le plus fort de protection.
– Le mode protected : cette technique de protection est étroitement associée à la notion d’héritage
(suite du cours).
1.3.2 Abstraction
C’est le faite de se concentrer sur les caractéristiques importantes d’un objet selon le point de vue de
l’observateur.
L’abstraction est un principe qui consiste à ignorer certains aspects d’un sujets qui ne sont pas
importants pour le problème dans le but de se concentrer sur ceux qui le sont.
Exemple : Dans la classe « Voiture », la propriété « couleur » dans la gestion d’un parking ne nous
intéresse pas. Donc, il n’est pas judicieux de la mentionner. (On en fait abstraction).

1.3.3 Classes, objets, instances
Une classe est un ensemble d’objets qui ont en commun :

Chapitre extrait du cours de Mlle Sghair Imène 3

– les mêmes méthodes
– les mêmes types d’attributs

Classe = attributs + méthodes + instanciations

Une instance d’une classe est un objet particulier d’une classe qui peut activer les méthodes de
la classe et qui a des valeurs particulières de ses attributs.
On définit l’objet comme l’instance d’une classe. La classe représente pour l’objet ce que
représente le type pour la variable. Un objet est caractérisé par :
o Son identité (OID) : valeur unique et invariante qui caractérise l’objet
o Son comportement : qui est défini à travers les méthodes applicables à cet objet et qui
o caractérisent sa façon d’agir et de réagir dans son environnement.
o Son état : qui constitue l’ensemble des valeurs des attributs de cet objet.
Une classe est un type abstrait qui encapsule données et traitement. C’est une sorte de moule
qui permet ensuite de créer autant d’instances qu’on veut. Ces instances seront des objets de la
classe auxquelles on pourra effectivement envoyer des messages qui activeront les méthodes
correspondantes.

1.3.4 Héritage
La notion d’héritage est une relation entre différentes classes permettant de définir une nouvelle classe
en se basant sur les classes existantes. On parle d’héritage simple lorsqu’une classe fille ne possède
qu’une classe mère.
On parle d’héritage multiple lorsqu’une classe fille possède plusieurs classes mères.

Chapitre extrait du cours de Mlle Sghair Imène 4

———————————————————————————————–

1.3.5 Polymorphisme
Le terme polymorphisme issu du grec signifie la faculté de prendre plusieurs formes.
Une entité est polymorphe si à l’exécution elle peut se référer à des instances de classe différentes.
Une entité est polymorphe si à l’exécution elle peut se référer à des instances de classe différentes.
Exemples :

————————————————————————————–

Le polymorphisme est un mécanisme qui permet à une sous classe de redéfinir une méthode dont elle
a hérité tout en gardant la même signature de la méthode.

Chapitre extrait du cours de Mlle Sghair Imène 5

Chapitre 2 : Eléments syntaxiques du langage C#

C# est un langage fortement typé, c’est-à-dire que toutes les opérations sur des variables sont
effectuées en tenant compte de leur type, afin de maintenir l’intégrité des données affectées à ces
variables. Pour allouer de la mémoire à une variable, on crée une instruction avec d’une part le type et
d’autre part le nom de la variable.
2.1 Les types
Les types présentés dans le tableau suivant, à l’exception du type « string » sont stockés par valeur.
Classe Alias Octets Valeurs codées
System.SByte sbyte 1 ‐128 à 127
System.Byte byte 1 0 à 255
System.Int16 short 2 ‐32768 à 32767
System.Int32 int 4 ‐2147483648 à 2147483647
System.Uint32 uint 4 0 à 4294967295
System.Int64 long 8 ‐9223372036854775808 à 9223372036854775807
System.Single float 4 ‐3,4E+38 à 3,4E+38
System.Double double 8 ‐1,79E+308 à 1,79E+308
System.Decimal decimal 16 ‐7,9E+29 à 7,9E+29
System.Char char 2 Caractère Unicode (UTF‐16)
System.Boolean bool 4 Valeur true ou false
System.String string * Chaîne de caractères
C# supporte deux sortes de types:
Les types valeur qui incluent les types simples (char, int..), les types enum (énumérations) et
les types struct (structures)
Les types référence qui incluent les types class (classes), interface (interfaces), delegate
(délégués) et array (tableaux)
Une variable de type valeur contient directement les données, alors qu’une variable de type référence
ne contient que la référence à un objet (un peu comme le ferait un pointeur).
Lors de l’utilisation de constantes littérales un suffixe peut être utilisé. Voici quelques exemples
montrant comment spécifier des valeurs littérales:
object o = null;
string s = « bonjour »;
sbyte val = 24;
short val = 24;
int val = 24;
long val1 = 24; | long val2 = 54L;
byte val1 = 24;
ushort val1 = 24;
uint val1 = 24; | uint val2 = 54U;
float val = 1.45F;
double val1 = 1.45; |double val2 = 3.23D;
2.2 Les opérateurs
Pour traiter la variable on utilise des opérateurs. Voici les opérateurs dans leur ordre de priorité (on
pourra utiliser des parenthèses pour redéfinir les priorités comme en mathématique.) :

Extrait de : « C# : L’essentiel en concentré », « APPRENTISSAGE DU LANGAGE C# »,… 6

Opérateur C# Signification
Opérateurs de Calculs Ces opérateurs permettent de faire des calculs
* Multiplication.
/ Division.
% Modulo.
+ Addition.
‐ Soustraction.
Operateurs de Tests Ces opérateurs permettent de retourner des booléens (vrai ou faux)
Is Teste le type d’un objet
< Inférieur à.
> Supérieur à.
<=,>= Inférieur ou égal, supérieur ou égal.
!= Différent de.
== Est égal à
Les opérateurs de
Logique

Ces opérateurs traitent des variables et en retournent une.

&& ET logique (vrai si tous les membres sont vrai)
|| OU logique (vrai si au moins un des membres est vrai)
?? Retourne l’opérande de gauche si non‐null ou bien celui de droite.
Cond ? var1 : var2 Renvoie var1 si cond est vrai ou alors var2
Les opérateurs
d’Attribution

Ces opérateurs permettent d’attribuer une valeur à une variable
= Attribution (permet de donner une valeur à une variable).
+=, ‐=,*=,/=,%=,&=,|= Permet de contracter la variable de l’opérateur et de l’attribution

Exemple : a += b ↔ a = a + b

Incrémentation Ces opérateurs réattribuent à une variable sa valeur modifiée.
++ Ajoute 1 à la valeur.
Exemple : i ++ ↔ i = i + 1

‐‐ Enlève 1 à la valeur i ‐ ‐ ↔ i = i – 1

Exemples :
int a; //on déclare a de type int
int b = 5; // on déclare b et on lui attribue la valeur 5
a = 0; // on attribu la valeur 0 dans a
System.Console.WriteLine(« a=\t »+a.ToString()+ »\n b=\t » + b.ToString()
+ « \n »);
La méthode ToString() appliquée à un int x, « x.ToString() » retourne une chaine de texte contenant sa
valeur.
L’opérateur « + » entre des string les concatènes en les mettant à la suite.
« \n » et « \t » sont des caractères spéciaux
a += a + ++b; // b=b+1; a=a+a+b;
System.Console.WriteLine(« a=\t »+a.ToString()+ »\nb=\t » + b.ToString()
+ « \n »);
a /= b; // a=a/b
a -= 2*b++*a; // a=a-2*b*a; b+=1;
System.Console.WriteLine(« a=\t »+a.ToString()+ »\nb=\t » + b.ToString()
+ « \n »); System.Console.ReadKey(); // attend que l’utilisateur appuie
sur
une touche Retour
Æ Console: a= 0
b= 5
a= 6

Extrait de : « C# : L’essentiel en concentré », « APPRENTISSAGE DU LANGAGE C# »,… 7

b= 6
a= -11
b= 7
2.3 Les chaînes de caractères
En C#, tout ce qui est entre guillemets est considéré comme une chaîne.
string MyString = « Une chaine »;
Soit :
string MyString = « 5 » + « 5 »;
int MyInteger = 5 + 5;
les valeurs des variables sont les suivantes :
My Integer est =10 car 5+5=10.
Alors que la chaine MyString = “55”.
Quand on ajoute une chaine à une autre, la deuxième est simplement “collée” à la première.
2.3.1 Comparaison de deux caractères
Soient deux caractères C1 et C2. Il est possible de les comparer avec les opérateurs <, <=, ==, !=, >,
>=
Ce sont alors leurs codes ASCII, qui sont des nombres, qui sont alors comparés. On rappelle que selon
l’ordre ASCII on a les relations suivantes :
espace < .. < ‘0’ < ‘1’ < .. < ‘9’ < .. < ‘A’ < ‘B’ < .. < ‘Z’ < .. < ‘a’ < ‘b’ < .. <‘z’
2.3.2 Comparaison de deux chaînes de caractères
Elles sont comparées caractère par caractère. La première inégalité rencontrée entre deux caractères
induit une inégalité de même sens sur les chaînes.
Exemples :
Soit à comparer les chaînes « Chat » et « Chien »
« Chat » « Chien » Æ ‘C’ = ‘C’ , ‘h’ = ‘h’ , ‘a’ < ‘i’ Æ « Chat » < « Chien ».
Soit à comparer les chaînes « Chat » et « Chaton ». Il y a égalité tout le temps jusqu’à épuisement de la
chaîne « Chat »Æ la chaîne épuisée est déclarée la plus « petite ». On a donc la relation « Chat » <
« Chaton ».
2.3.3 Fonctions de comparaisons de deux chaînes
On peut utiliser ici les opérateurs relationnels <, <=, ==, !=, >, >= ou des méthodes de la classe String
:
String chaine1, chaine2;
chaine1=…;
chaine2=…;
int i=chaine1.CompareTo(chaine2);
boolean egal=chaine1.Equals(chaine2)
Ci-dessus, la variable i aura la valeur : 0 si les deux chaînes sont égales, 1 si chaîne n°1 > chaîne n°2
et -1 si chaîne n°1 < chaîne n°2
La variable egal aura la valeur true si les deux chaînes sont égales.
2.3.4 La déspécialisation
Pour les strings il existe des caractères spéciaux dont celui du retour à la ligne et de la tabulation.
Voici quelques caractères spéciaux :
\n, \r : retour à la ligne
\t : tabulation (pratique pour les alignements verticaux)
\\ : permet d’afficher un antislash
\ » : permet d’afficher un guillemet
\xXX ou « XX »est une valeur hexadécimale de deux caractères (chacun entre 0 et F) : permet
d’afficher un caractère par son code hexa.
Extrait de : « C# : L’essentiel en concentré », « APPRENTISSAGE DU LANGAGE C# »,… 8

Si nous ne voulons pas bénéficier du support de ces caractères et avoir une chaîne non interprétée, il
suffit de précéder la chaîne par un @, ces chaînes peuvent contenir de réels retours à la ligne. Ces
chaînes peuvent vent être appelées « chaîne Verbatim ».
2.4 Conversion de types
Si Nous prenons l’exemple suivant:
byte val1 = 12;
byte val2 = 20;
int total;
total = val1 + val2;
Console.WriteLine (total);
Sa compilation provoque un message du genre: « Cannot implicitely convert type ‘int’ to ‘byte' ». En
effet, le résultat du calcul est un int et non un byte. Pour placer le résultat dans une variable de type
byte il faut le reconvertir en byte.
Une conversion de type peut se faire explicitement ou implicitement.
2.4.1 Conversions implicites
La conversion entre deux types peut s’effectuer de manière automatique (implicite) seulement si elle
n’affecte pas la valeur convertie. Reprenons l’exemple précédent, mais avec la variable total de type
long:
byte val1 = 12;
byte val2 = 20;
long total;
total = val1 + val2;
Console.WriteLine (total);
Cette fois le compilateur ne génère aucun message d’erreur.
En effet, le schéma suivant donne les diverses possibilités de conversions implicites prises en charge
par C#:

2.4.2 Conversions explicites
Pour les conversions qui ne peuvent se faire implicitement, on a la possibilité d’utiliser le transtypage
(cast), c’est-à-dire une conversion explicite. En voici quelques exemples:
de int en short
de float en int
d’un type numérique en char
etc
Il convient d’être prudent avec l’utilisation du transtypage, car cette opération force le compilateur à
effectuer une conversion d’où un risque d’altération des données. Voici un exemple typique de
transtypage:

Extrait de : « C# : L’essentiel en concentré », « APPRENTISSAGE DU LANGAGE C# »,… 9

long tot = 20000;
int k = (int)tot;
La conversion de long en int n’affecte pas la valeur 20000, car elle peut être contenue dans une
variable de type int. En revanche le code qui suit peut causer des problèmes:
long tot = 3000000000;
int k = (int)tot;
car la variable k contient la valeur -1294967296, ce qui est manifestement faux et résulte de la
troncation de 8 bytes à 4 bytes avec « mauvaise » prise en compte du bit de signe.
2.4.3 Conversions entre nombres et chaînes
Une conversion courante en programmation concerne les nombres et les chaînes de caractères. Le fait
que la classe Object implémente une méthode ToString, qui a été remplacée dans tous les type .NET
prédéfinis, permet d’obtenir une représentation littérale de l’objet:
int k = 12;
string s = k.ToString();
Pour effectuer la transformation inverse, c’est-à-dire passer d’une chaîne de caractères à un nombre il
est possible d’utiliser la méthode Parse, offerte par tous les types prédéfinis:
string s = « 120 »;
int k =int.Parse(s);
Console.WriteLine (k);
Il faut cependant remarquer que Parse() peut provoquer une erreur, et lever une exception qu’il faut
traiter, si la conversion n’est pas faisable.
2.4.4 Boxing (emboîtage) et unboxing (désemboîtage)
Tous les types, même les types simples prédéfinis, dérivent du type Object. Cela permet de travailler
avec des valeurs littérales comme s’il s’agissait d’objets:
string s = 12.ToString();
Le boxing peut être vu comme un transtypage d’un type valeur à un type référence. Dans l’exemple
précédent le boxing est effectué de manière implicite, mais on peut également le faire de façon
explicite comme dans:
int k = 30;
object obj = k; // boxing en int
Le unboxing concerne l’opération inverse dans laquelle un type référence est transtypé en type valeur.
int k = 30;
object obj = k; // boxing d’un int en objet
int j = (int)obj; // unboxing pour revenir à un int
2.5 Expressions booléennes
Les opérateurs utilisables sont AND (&&) OR(||) NOT (!). Le résultat d’une expression booléenne est
un booléen.
priorités des opérateurs :
1. !
2. &&
3. ||
int fin;
int x;
fin= x>2 && x<4;
2.6 Les tableaux
Nous pouvons créer des tableaux de n’importe quel objet.
La déclaration est similaire à celle des objets :
byte[] MyArray;
Le code ci-dessus crée une “référence” à un objet de type “tableau d’octets”. C’est pour

Extrait de : « C# : L’essentiel en concentré », « APPRENTISSAGE DU LANGAGE C# »,… 10

l’instant une simple référence et il ne contient aucun objet, il est “null”.
Pour créer l’objet, nous utilisons le mot-clé “new” et devons préciser la taille de notre tableau.
Exemple:
byte[] MyArray;
MyArray = new byte[10];
Nous avons créé un tableau d’octets avec 10 éléments dedans. Ce tableau est référencé par “MyArray”.
Nous pouvons maintenant lire/écrire n’importe laquelle des 10 valeurs dans le tableau simplement en
indiquant l’index de la valeur désirée.
MyArray[0] = 123; // first index
MyArray[9] = 99; // last index
MyArray[10] = 1; //…ERROR!!
En effet, les index débutent à 0. Donc pour un tableau de 10 éléments, les index vont de 0 à 9. L’accès
à l’index 10 ne fonctionnera pas et génèrera une exception.
Nous pouvons assigner des valeurs aux éléments du tableau lors de sa déclaration.
L’exemple suivant va stocker les nombre de 1 à 10 dans les index de 0 à 9 :
byte[] MyArray = new byte[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Pour copier un tableau, nous utilisons la classe Array comme suit :
byte[] MyArray1 = new byte[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
byte[] MyArray2 = new byte[10];
Array.Copy(MyArray1, MyArray2, 5);// Copie de 5 éléments seulement
Une propriété importante et très utile d’un tableau est sa propriété Length. Nous pouvons l’utiliser
pour déterminer le nombre d’éléments qu’il contient.
byte[] MyArray1 = new byte[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
byte[] MyArray2 = new byte[10];
Array.Copy(MyArray1, MyArray2, MyArray1.Length);//Copie tout le tableau

2.7 Ecriture sur écran
Il existe différentes instructions d’écriture à l’écran :
Console.Out.WriteLine(expression)
Console.WriteLine(expression)
Console.Error.WriteLine (expression)
où expression est tout type de donnée qui puisse être converti en chaîne de caractères pour être affiché
à l’écran. La classe System.Console donne accès aux opérations d’écriture écran (Write, WriteLine). La
classe Console a deux propriétés Out et Error :
Console.WriteLine() est équivalent à Console.Out.WriteLine() et écrit sur le flux Out
associé habituellement à l’écran.
Console.Error.WriteLine() écrit sur le flux Error, habituellement associé lui aussi l’écran.
Les flux Out et Error sont associés par défaut l’écran. Mais ils peuvent être redirigés vers des fichiers
texte au moment de l’exécution du programme.
2.8 Lecture de données tapées au clavier
Le flux de données provenant du clavier est désigné par l’objet Console.In de type StreamReader. Ce
type d’objets permet de lire une ligne de texte avec la méthode ReadLine :
String ligne=Console.In.readLine();
La ligne tapée au clavier est rangée dans la variable ligne et peut ensuite être exploitée par le
programme.Le flux In peut être redirigé vers un fichier comme les flux Out et Error.
Exemple d’entrées-sorties
Voici un court programme d’illustration des opérations d’entrées-sorties clavier/écran :
using System;
public class io1{
public static void Main (){
// écriture sur le flux Out
object obj=new object();
Extrait de : « C# : L’essentiel en concentré », « APPRENTISSAGE DU LANGAGE C# »,… 11

Console.Out.WriteLine(«  »+obj);
// écriture sur le flux Error
int i=10;
Console.Error.WriteLine(« i= »+i);
// lecture d’une ligne saisie au clavier
Console.Out.Write(« Tapez une ligne : « );
string ligne=Console.In.ReadLine();
Console.Out.WriteLine(« ligne= »+ligne);
}//fin main
}//fin classe
et les résultats de l’exécution :
System.Object
i=10
Tapez une ligne : je suis là
ligne=je suis là
Les instructions
object obj=new object();
Console.Out.WriteLine(«  »+obj);
ont pour but de montrer que n’importe quel objet peut faire l’objet d’un affichage.
2.9 Les instructions de contrôle du déroulement du programme
2.9.1 Arrêt
La méthode Exit définie dans la classe Environment permet d’arrêter l’exécution d’un programme.
Syntaxe : void Exit(int status)
Elle arrête processus en cours et rend la valeur status au processus père
exit provoque la fin du processus en cours et rend la main au processus appelant. La valeur de status
peut être utilisée par celui-ci.
Environment.Exit(0);
arrêtera l’exécution du programme avec une valeur d’état à 0.
2.9.2 Structure de choix simple
syntaxe : if (condition) {actions_condition_vraie;} else {actions_condition_fausse;}
la condition est entourée de parenthèses.
chaque action est terminée par point-virgule.
les accolades ne sont pas terminées par point-virgule.
les accolades ne sont nécessaires que s’il y a plus d’une action.
la clause else peut être absente.
Il n’y a pas de clause then.
Exemple
if (x>0) { nx=nx+1;sx=sx+x;} else dx=dx-x;
On peut imbriquer les structures de choix :
if(condition1)
if (condition2)
{……}
else //condition2
{……}
else //condition1
{…….}
Exemple :
public static void Main()
{ int n=0;
if(n>1)
if(n>6) Console.Out.WriteLine (« >6 »);
else; // else du if(n>6) : rien à faire

Extrait de : « C# : L’essentiel en concentré », « APPRENTISSAGE DU LANGAGE C# »,… 12

else Console.Out.WriteLine (« <=1 »); // else du if(n>1)
}
Ici nous voulions mettre un else au if(n>1) et pas de else au if(n>6). Nous sommes obligés de
mettre un else au if(n>6), dans lequel il n’y a aucune instruction car un else se rapporte toujours au if
le plus proche.
.
2.9.3 Structure de cas
La syntaxe est la suivante :
switch(expression) {
case v1:
actions1;
break;
case v2:
actions2;
break;
. .. .. .. .. ..
default:
actions_sinon;
break;
}
La valeur de l’expression de contrôle, ne peut être qu’un entier.
l’expression de contrôle est entourée de parenthèses.
la clause default peut être absente.
les valeurs vi sont des valeurs possibles de l’expression. Si l’expression a pour valeur vi , les
actions derrière la clause case vi sont
exécutées.
l’instruction break fait sortir de la structure de cas. Si elle est absente à la fin du bloc d’instructions
de la valeur vi, le compilateur
signale une erreur.
Exemple :
int choix=0; bool erreur=false;
switch(choix){
case 0: Environment.Exit(0);
case 1: M1();break;
case 2: M2();break;
default: erreur=true;break;
}
2.10 Structure de répétition
2.10.1 Nombre de répétitions connu
Structure for
La syntaxe est la suivante :
for (i=id;i<=if if;i=i+ip){
actions;
}
les 3 arguments du for sont à l’intérieur d’une parenthèse et séparés par des points-virgules.
chaque action du for est terminée par un point-virgule.
l’accolade n’est nécessaire que s’il y a plus d’une action.
l’accolade n’est pas suivie de point-virgule.
L’équivalent algorithmique est la structure pour :
pour i variant de ideb à ifin avec un pas de ipa
actions
finpour
qu’on peut traduire par une structure tantque :
i =ideb

Extrait de : « C# : L’essentiel en concentré », « APPRENTISSAGE DU LANGAGE C# »,… 13

tantque i<=ifin
actions
i+ipa
fintantque
Structure foreach
La syntaxe est la suivante :
for foreach (type variable in expression){
instructions;
}
expression est une collection d’objets. La collection d’objets que nous connaissons déjà est le
tableau
type est le type des objets de la collection. Pour un tableau, ce serait le type des éléments du
tableau
variable est une variable locale à la boucle qui va prendre successivement pour valeur, toutes
les valeurs de la collection.
Exemple :
string[] amis=new string[]{« paul », »hélène », »jacques », »sylvie »};
foreach(string nom in amis){
Console.Out.WriteLine(nom);
}
afficherait :
paul
hélène
jacques
sylvie
2.10.2 Nombre de répétitions inconnues
Structure tantque (while)
while while(condition){
actions;
}
On boucle tant que la condition est vérifiée. La boucle peut ne jamais être exécutée.
la condition est entourée de parenthèses.
chaque action est terminée par point-virgule.
l’accolade n’est nécessaire que s’il y a plus d’une action.
l’accolade n’est pas suivie de point-virgule.
La structure algorithmique correspondante est la structure tantque :
tantque condition
actions
fintantque
Structure répéter jusqu’à (do while)
La syntaxe est la suivante :
do{
instructions;
}while while(condition);
On boucle jusqu’à ce que la condition devienne fausse ou tant que la condition est vraie. Ici la boucle
est faite au moins une fois.
notes
la condition est entourée de parenthèses.
chaque action est terminée par point-virgule.
l’accolade n’est nécessaire que s’il y a plus d’une action.
l’accolade n’est pas suivie de point-virgule.
La structure algorithmique correspondante est la structure répéter … jusqu’à :
répéter
actions
jusqu’à condition

Extrait de : « C# : L’essentiel en concentré », « APPRENTISSAGE DU LANGAGE C# »,… 14

Structure pour générale (for)
La syntaxe est la suivante :
for for(instructions_départ;condition;instructions_fin_boucle){
instructions;
}
On boucle tant que la condition est vraie (évaluée avant chaque tour de boucle). Instructions_départ
sont effectuées avant d’entrer dans la boucle pour la première fois. Instructions_fin_boucle sont
exécutées après chaque tour de boucle.
les différentes instructions dans instructions_depart et instructions_fin_boucle sont séparées
par des virgules.
La structure algorithmique correspondante est la suivante :
instructions_départ
tantque condition
actions
instructions_fin_boucle
fintantque
Exemples
Les programmes suivants calculent tous la somme des n premiers nombres entiers.
for for(i=1, somme=0;i<=n;i=i+1)
somme=somme+a[i];
for (i=1, somme=0;i<=n;somme=somme+a[i], i=i+1);
i=1;somme=0;
while(i<=n)
{ somme+=i; i++; }
i=1; somme=0;
do somme+=i++;
while (i<=n);
2.10.3 Instructions de gestion de boucle
break fait sortir de la boucle for, while, do … while.
continue fait passer à l’itération suivante des boucles for, while, do … while