module_3
Dr. N
v.1 8-04-2025
Table des matières
I - Chaînes de caractères et tableaux en Csharp 3
1. Chaînes de caractères ....................................................................................................... 3
1.1. Déclaration et initialisation ........................................................................................................................ 3
1.2. Opérations ............................................................................................................................................................ 3
1.3. Longueur ............................................................................................................................................................... 3
1.4. Extraction de caractères ............................................................................................................................ 4
1.5. Extraction de sous-chaı̂ nes ...................................................................................................................... 4
1.6. Chaı̂ nes modifiables ..................................................................................................................................... 4
2. Tableaux ..................................................................................................................................... 5
2.1. Définitions ............................................................................................................................................................. 5
2.2. Déclaration .......................................................................................................................................................... 5
2.3. Initialisation ........................................................................................................................................................6
2.4. Accès aux éléments ......................................................................................................................................6
2.5. Exemples ..............................................................................................................................................................6
2.6. L’instruction foreach ....................................................................................................................................8
2
I Chaînes de caractères et
tableaux en Csharp
1. Chaînes de caractères
En Csharp le type char » de données représente un caractère Unicode 16 bits et est
utilisé pour stocker un seul caractère. Un chaine de caratère
« String» peut considérer comme une version améliorée du type char, car il permet
de stocker du texte, c'est-à-dire plusieurs caractères au lieu d'un seul. En C#, ce type
de données est immutable : après la création d'une chaîne de caractères, celle-ci ne
peut plus être modifiée. Si vous utilisez des méthodes susceptibles de modifier une
chaîne, une nouvelle chaîne est en réalité renvoyée, tandis que l'originale reste
inchangée.
exemple :
Etant donné le programme dont l’exécution est tracée ci dessous :
1- Saisissez une phrase :
Les framboises sont perchees sur le tabouret de mon grand-pere.
2-Vous avez saisi :
Les framboises sont perchees sur le tabouret de mon grand-pere.
Cette phrase commence par une majuscule.
Cette phrase se termine par un point.
1.1. Déclaration et initialisation
Une chaı̂ ne se déclare de la sorte :
1 string < nom_chaine > = " valeur initiale " ;
Par exemple, on déclare une chaine c contenant ”nabucodonosor” de la sorte :
1 string c = " nabuchodonosor " ;
1.2. Opérations
Concaténation
La concaténation de deux chaı̂ nes est la juxtaposition des caractères qui les
composent. L’opérateur utilisé pour ce faire est +.
Par exemple :
1 string a = " nabucho " ;
2 string b = " donosor " ;
3 string c = a + b;
1.3. Longueur
La longueur d’une chaı̂ ne s (i.e. le nombre de caractères qu’elle contient d’obtient
avec l’attribut. Length. Par exemple,
1 [Link] ("La longueur de " + s + " est " + [Link] + ".");
3
Chaînes de caractères et tableaux en Csharp
1.4. Extraction de caractères
On extrait le i-ème caractère d’une chaı̂ ne s avec l’instruction s[i] (attention les
caractères sont indicés à partir de 0). Par exemple,
1 string s = " nabuchodonosor " ;
2 char c = s [1];
3 [Link] ("Le deuxième caractère de " + s + " est " + c + "." );
1.5. Extraction de sous-chaı̂ nes
On extrait de s une sous-chaı̂ ne de j caractères à partir du caractère d’indice i en
utilisant [Link](i, j).
Par exemple,
1 string s = " nabuchodonosor " ;
2 string s2 = [Link] (4 , 7);
résultat :
s2 contient alors chodono.
1.6. Chaı̂ nes modifiables
Le problème se posant avec les chaı̂ nes en c# est qu’elle ne sont pas modifiables. Le
type StringBuilder permet de créer des chaı̂ nes modifiables.
Pour utilisez des StringBuilder, vous devez ajouter using [Link] ; au début de
votre code source.
Déclaration
La syntaxe permettant de créer une chaı̂ ne vide est
1 StringBuilder s = new StringBuilder (n);
où n est le nombre maximal de caractères que pourra contenir la chaı̂ ne.
Vous avez aussi la possibilité de recopier une string dans une StringBuilder en
procédant de la sorte :
1 StringBuilder sb = new StringBuilder (s);
Insertion
Vous pouvez insérer un caractère dans une StringBuilder s en utilisant l’instruction
[Link](i, a). Les caractères se trouvant après l’indice i dans s sont décalés d’une
position vers la droite et a est placé à l’indice i.
Modification
Vous pouvez remplacer le caractère d’indice i dans s par a avec l’instruction
1 s[i] = a.
Il faut bien entendu qu’il y ait déjà un caractère à cet indice dans s, sinon le
programme plante...
Conversions
Pour effectuer des conversions entre string et StringBuilder, inutile d’effectuer des
casts, ça ne fonctionnera pas.
— On convertit s de type string vers StringBuilder avec
1 new StringBuilder(s)
— et on convertit sb de type StringBuilder vers string avec
1 [Link]().
4
Chaînes de caractères et tableaux en Csharp
2. Tableaux
En utilisant un type existant, le langage permet de créer des tableaux. Un tableau
peut être vu comme une liste, un vecteur ou une matrice d’éléments du même type.
Chaque case ou cellule d’un tableau stocke un élément du type donné.
exemple de problème de tableau :
Saisissez dix valeurs :
1:4
2:7
3 : 34
4:1
5 : 88
6 : 22
7 : 74
8 : 19
9:3
10 : 51
Saisissez une valeur :
22
22 est la 6-eme valeur saisie.
Comment programmer cela sans utiliser 10 variables pour stocker les dix premières
valeurs saisies ?
2.1. Définitions
Une tableau est un regroupement de variables de même type, il est identifié par un
nom. Chacune des variables du tableau est numérotée, ce numéro s’appelle un
indice. Chaque variable du tableau est donc caractérisée par le nom du tableau et
son indice.
Si par exemple, T est un tableau de 10 variables, alors chacune d’elles sera numérotée
et il sera possible de la retrouver en utilisant simultanément le nom du tableau et
l’indice de la variable. Les différentes variables de T porteront des numéros de 0 à 9, et
nous appellerons chacune de ces variables un élément de T .
Une variable n’étant pas un tableau est appelée variable scalaire, un tableau par
opposition à une variable scalaire est une variable non scalaire.
2.2. Déclaration
Comme les variables d’un tableau doivent être de même type, il convient de préciser
ce type au moment de la délaration du tableau. De même, on précise lors de la
déclaration du tableau le nombre de variables qu’il contient. La syntaxe est :
< type >[] < nomdutableau > = new < type >[ < taille >];
Par exemple,
1 int [] T = new int [4];
déclare un tableau T contenant 4 variables de type int.
5
Chaînes de caractères et tableaux en Csharp
Attention ! <type>[] <nomdutableau> n’est pas un tableau ! C’est une variable
contenant un tableau. Cela signifie que tant que vous ne lui avez pas affecté new
<type>[<taille>], vous ne pouvez pas l’utiliser.
2.3. Initialisation
Il est possible d’initialiser les éléments d’un tableau à la déclaration, on fait cela
comme pour des variables scalaires :
< type > = < valeur d initialisation >;
La seule chose qui change est la façon d’écrire la valeur d’initialisation, on ecrit entre
accolades tous les éléments du tableau, on les dispose par ordre d’indice croissant en
les séparant par des virgules. La syntaxe générale de la valeur d’initialisation est donc :
< type >[] = new < type >[ < taille >]{ < valeur_0 > , < valeur_1 > , ... , < valeur_n
Par exemple, on crée un tableau contenant les 5 premiers nombres impairs de la
sorte :
1 int [] T = new int [5]{1 , 3 , 5 , 7 , 9};
Lorsqu’un tableau est initialisé à la déclaration, il est même possible d’omettre sa
taille :
1 int [] T = new int []{1 , 3 , 5 , 7 , 9};
... voire une partie de sa déclaration :
1 int [] T = {1 , 3 , 5 , 7 , 9};
2.4. Accès aux éléments
Les éléments d’un tableau à n éléments sont indicés de 0 à n − 1. On note T[i]
l’élément d’indice i du tableau T. Les cinq éléments du tableau de l’exemple ci-avant
sont donc notés T[0], T[1], T[2], T[3]
et T[4].
2.5. Exemples
Nous pouvons maintenant mettre en place le programme du début du cours. Il est
nécessaire de stocker 10 valeurs de type entier, nous allons donc déclarer un tableau
e de la sorte :
1 int [] e = new int [10];
La déclaration ci-dessus est celle d’un tableau de 10 int appelé e. Il convient ensuite
d’effectuer les saisies des 10 valeurs. On peut par exemple procéder de la sorte :
1 [Link] ( " Saisissez dix valeurs : \ n " );
2 [Link] ( " 1 : " );
3 e[0] = [Link] ( [Link] ());
4 [Link] (" 2 : ");
5 e[1] = [Link] ( [Link] ());
6 [Link] ( " 3 : " );
7 e[2] = [Link] ( [Link] ());
8 [Link] (" 4 : ");
9 e[3] = [Link] ( [Link] ());
10 [Link] (" 5 : ");
11 e[4] = [Link] ( [Link] ());
12 [Link] (" 6 : ");
13 e[5] = [Link] ( [Link] ());
14 [Link] (" 7 : ");
15 e[6] = [Link] ( [Link] ());
16 [Link] (" 8 : ");
17 e[7] = [Link] ( Console . ReadLine ());
6
Chaînes de caractères et tableaux en Csharp
18 [Link] (" 9 : ");
19 e[8] = [Link] ( Console . ReadLine ());
20 [Link] (" 10 : ");
21 e [9] = i n t . Parse ( Console . ReadLine ());
Les divers copier/coller nécessaires pour rédiger un tel code sont d’une laideur à
proscrire. Nous procéderons plus élégamment en faisant une boucle :
1 [Link] (" Saisissez dix valeurs : ");
2 for ( int i = 0 ; i < 10 ; i ++)
3{
4 [Link] ( i +1 + " : " );
5 e[i] = [Link]( [Link] ());
6}
Ce type de boucle s’appelle un parcours de tableau. En règle générale on utilise des
boucles pour manier les tableaux, celles-ci permettent d’effectuer un traitement sur
chaque élément d’un tableau. Ensuite, il faut saisir une valeur à rechercher dans le
tableau :
1 [Link] (" Saisissez une valeur : ");
2 t = [Link] ([Link] ());
Nous allons maintenant rechercher la valeur t dans le tableau e. Considérons pour ce
faire la boucle suivante :
1 i = 0;
2 while ( e [ i ] != t )
3 i ++;
Cette boucle parcourt le tableau jusqu’à trouver un élément de e qui ait la même
valeur que t.
Le problème qui pourrait se poser est que si t ne se trouve pas dans le tableau e, alors
la boucle pourrait ne pas s’arrêter. Si i prend des valeurs strictement plus grandes que
9, alors il se produira ce que l’on appelle un débordement d’indice. Vous devez
toujours veiller à ce qu’il ne se produise pas de débordement d’indice ! Nous allons
donc faire en sorte que la boucle s’arrête si i prend des valeurs strictement
supérieures à 9.
1 i = 0;
2 while ( i < 10 && e [ i ] != t )
3 i ++;
Il existe donc deux façons de sortir de la boucle :
— En cas de débordement d’indice, la condition i < 10 ne sera pas vérifiée. Une fois
sorti de la boucle, i aura la valeur 10.
— Dans le cas où t se trouve dans le tableau à l’indice i, alors la condition e[i] != t ne
sera pas vérifiée et on sortira de la boucle. Un fois sorti de la boucle, i aura comme
valeur l’indice de l’élément de e qui est égal à t, donc une valeur comprise entre 0 et
9.
On identifie donc la façon dont on est sorti de la boucle en testant la valeur de i :
1 if ( i == 10)
2 [Link] ( t + " ne fait pas partie des dix valeurs saisies . " );
3 else
4 [Link] ( t + " est la " + ( i + 1) + " - eme valeur saisie . " );
Si (i == 10), alors nous sommes sorti de la boucle parce que l’élément saisi par
l’utilisateur ne trouve pas dans le tableau. Dans le cas contraire, t est la i+1-ème valeur
saisie par l’utilisateur. On additionne 1 à l’indice parce que l’utilisateur ne sait pas que
dans le tableau les éléments sont indicés à partir de 0.
7
Chaînes de caractères et tableaux en Csharp
Récapitulons :
1
2 using System ;
3 namespace TPTableaux
4{
5 class MainClass
6 {
7 public static void Main(string[] args)
8 {
9 int[] e = new int[10];
10 int i;
11
12 [Link]("Saisissez 10 valeurs : ");
13 for (i = 0; i < 10; i++)
14 {
15 [Link](i + 1 + " : ");
16 e[i] = [Link]([Link]());
17 }
18
19 [Link]("Saisissez une valeur : ");
20 int t = [Link]([Link]());
21
22 i = 0;
23 while (i < 10 && e[i] != t)
24 i++;
25
26 if (i == 10)
27 [Link](t + " ne fait pas partie des dix valeurs.");
28 else
29 [Link](t + " est la " + (i + 1) + "-ème valeur.");
30 }
31 }
32 }
2.6. L’instruction foreach
Il est possible de parcourir un tableau de façon séquentielle et en lecture seule grâce
à l’instruction foreach.
foreach ( < type > < variable > i n < tableau >)
< instructions >
Cette instruction affecte à <variable> pour chaque itération de la boucle un élément
de <tableau>.
On remarque au passage que le <type> doit être celui des éléments de <tableau>. Par
exemple, le programme suivant affiche les quatre premières lettres de l’alphabet :
1 char [] t = { ’a ’ , ’b ’ , ’c ’ , ’d ’};
2 foreach ( char c int )
3 [Link] ( c );