Programma'on procédurale 1 / 71

Programma'on procédurale
Par'e 1 : les éléments syntaxiques de base
Contenu
1. Les variables
2. Les entrées/sor'es (en mode console)
3. Les opéra'ons
4. Les instruc'ons condi'onnelles
5. Les opéra'ons spécifiques
6. Op'misa'on
7. Exercices récapitula'fs

Pour pouvoir apporter des correc'ons et des évolu'ons à des applica'ons existantes, il faut être en mesure de
comprendre le code, donc de savoir coder.
Vous allez découvrir les bases de la programma'on à travers la présenta'on des éléments syntaxiques et une mise
en pra'que systéma'que.
Vous avez pu constater qu'il y a deux aspects à prendre en compte quand on écrit un programme :
— la logique à suivre (à quel moment il faut afficher, saisir, faire un test, une boucle…) qui est la même quel
que soit le langage de programma'on u'lisé ;
— la syntaxe du langage pour écrire le code correspondant à ceUe logique : ceUe fois, la syntaxe dépend du
langage.
Le plus important et le plus difficile est de trouver la logique du programme. C'est un peu comme résoudre un
casse-tête. Avec le temps et l'expérience, vous aurez des facilités à trouver ceUe logique. Voilà pourquoi il est
important de coder, de beaucoup coder. Mais ce qu'il faut retenir, c'est que la programma'on ne s'aborde pas du
tout comme un cours classique : le but n'est pas d'apprendre puis d'appliquer ce que vous avez appris. Il y a en
réalité peu de choses à apprendre : vous avez à connaître quelques briques (vous avez déjà vu les plus
importantes), vous devez maintenant apprendre à les assembler correctement. Et là, ce n'est que votre
raisonnement qui peut vous aider. Vous ne devez donc pas "apprendre" mais "comprendre" puis exploiter votre
raisonnement.
Voici une présenta'on détaillée des éléments syntaxiques, avec une mise en pra'que systéma'que.

1. Les variables
Un programme est une succession d'instruc'ons qui nécessitent très souvent la manipula'on de variables.
1A. La déclara,on des variables
But
Il est parfois nécessaire de mémoriser une informa'on pour pouvoir la réu'liser plus loin dans le programme.
Pour cela, il faut au préalable déclarer la variable (la case mémoire) qui va stocker l'informa'on.
Fonc+onnement
La déclara'on d'une variable se fait en lui donnant un nom et en précisant son type.
Rappelons que le nom de la variable est libre, choisi par le programmeur, mais en respectant certaines règles
: — ne pas commencer par un chiffre ; — ne pas contenir d'espace ;
— contenir uniquement des caractères alphabé'ques, éventuellement des chiffres et le caractère "_" ; — éviter
les caractères accentués (plusieurs langages n'apprécient pas).
Lors de la déclara'on en C#, le type doit précéder la ou les noms des variables.
Programma'on procédurale 2 / 71

Les types simples sont soient numériques (en'ers, réels…), soient caractères (un seul caractère ou une chaîne),
soient booléens (ne peut prendre que 2 valeurs : true ou false)
Cas d'erreurs
Lors de la déclara'on, une erreur peut survenir dans les cas suivants :
— type oublié ;
— type sans variable ;
— nom de variable incorrect.
Ces erreurs seront repérées et signalées par l'IDE.
Syntaxe C#
Voici les types simples que vous pouvez u'liser en C# (vous retrouvez ces types dans la plupart des langages) :
— byte : en'er entre 0 et 255
— short : en'er entre -32768 et 32767
— int : en'er entre -2147483648 et 2147483647
— long : en'er entre -9223372036854775808 et 9223372036854775807
— float : réel (nombre à virgule) entre -3,402823e38 et 3,402823e38
— double : réel (nombre à virgule) entre -1,79769313486232e308 et 1,79769313486232e308
— decimal : nombre décimal convenant par'culièrement aux calculs financiers (en raison de ses nombres
significa'fs après la virgule)
— char : un seul caractère
— string : une chaîne de caractères
— bool : une valeur booléenne (true ou false)

Exemples
Voici des exemples de déclara'ons en C# :

EXEMPLES
int valeur, essai, nbre; // variables de type entier char
reponse; // variable de type caractère (un seul caractère)
string message; // variable de type chaîne (0, 1 ou plusieurs
caractères)
bool trouve; // variable de type booléenne (true ou false)
float note; // variable de type réel

1B. L'affecta,on dans une variable

But
Une fois une variable déclarée, il est possible de lui affecter une valeur. CeUe affecta'on peut se faire au
moment de la déclara8on ou à tout autre moment dans le programme. Fonc+onnement
La valeur ou le contenu d'une variable qui se trouve à droite de l'affecta'on est transféré dans la variable qui se
trouve à gauche de l'affecta'on.
Si la variable qui reçoit la valeur contenait une autre valeur, celle-ci est écrasée (effacée) par la nouvelle valeur.
Cas d'erreurs
Lors de l'affecta'on, une erreur peut survenir dans les cas suivants :
— la variable qui se trouve à gauche de l'affecta'on (donc qui reçoit) n'est pas déclarée ;
— ce qui est à gauche de l'affecta'on n'est pas une variable ;
— la variable qui se trouve à droite de l'affecta'on n'est pas déclarée ;
Programma'on procédurale 3 / 71

— l'informa'on (variable ou valeur) qui se trouve à droite de l'affecta'on n'est pas du même type que la
variable qui se trouve à gauche (donc qui reçoit) et n'est pas transtypée. Ces erreurs seront repérées et signalées
par l'IDE.
Syntaxe C#
Voici la syntaxe de l'affecta'on en C# :
variable = valeur_ou_autre_variable ;
Exemples
Voici des exemples de déclara'ons en C# :

EXEMPLES
valeur = 25;
essai = 20;
nbre = 3;
reponse = 'N';
message = "Vous avez trouvé !";
message = "Vous avez trouvé en " + nbre + " fois !";
trouve = true;
trouve = (valeur == essai);
note = 15.5f; // f pour signaler que la valeur 15.5 est de type float

Il est aussi possible de déclarer et ini'aliser une variable en une ligne :

EXEMPLE
int nbre = 1;

Important :
— Une variable caractère reçoit une valeur entre apostrophes et non entre guillemets.
— Une variable chaîne reçoit une chaîne entre guillemets ou une autre variable chaîne ou une concaténa8on
de chaînes (si dans la concaténa8on, une variable numérique est u8lisée, elle est automa8quement
transformée en chaîne).
— Une variable booléenne reçoit une valeur booléenne (soit true, soit false sans guillemets, soit le résultat
d'un test).
— Une variable numérique à virgule peut recevoir une valeur en8ère ou une valeur à virgule (la virgule étant
notée sous la forme d'un point).
Il existe d'autres types plus complexes que vous aurez l'occasion de découvrir plus tard.
Programma'on procédurale 4 / 71

2. Les entrées/sor3es (en mode console)

Le but d'un programme est d'offrir un service à un u'lisateur. Pour cela il doit pouvoir recevoir des instruc8ons de
l'u'lisateur (par exemple à travers une saisie) et lui communiquer un résultat (par exemple en l'affichant à
l'écran).
Au niveau des entrées/sor'es, il y a une importante différence entre les applica8ons en "mode console", donc
non graphiques, et les applica8ons graphiques. Dans un premier temps, nous travaillons uniquement dans la
console, donc pour des applica'ons non graphiques.
2A. L'affichage
But À tout moment il est possible d'afficher une informa'on à
l'écran.
Fonc+onnement
L'informa'on à afficher peut être :
— une variable ;
— une valeur (une chaîne entre guillemets, une valeur numérique sans guillemets) : on parle alors de "valeur
en dur", donc qui s'affichera toujours en l'état à l'écran ;
— un calcul (à meUre entre parenthèses) entre des variables et/ou des valeurs ; — une
combinaison des 3 points précédents (en concaténant les informa'ons).
Cas d'erreurs
Lors de l'affichage, une erreur peut survenir dans les cas suivants :
— la ou les variables u'lisées ne sont pas déclarées ;
Programma'on procédurale 5 / 71

— la ou les variables u'lisées ne con'ennent pas encore de valeur (pas d'ini'alisa'on ou pas d'affecta'on au
préalable) ;
— la valeur en dur de type chaîne n'est pas mise entre guillemets ;
— la concaténa'on entre valeurs en dur et variables n'est pas correctement gérée (avec le signe + en C# et
dans la plupart des langages).
Ces erreurs seront repérées et signalées par l'IDE.
Syntaxe C#
En C#, l'affichage se fait avec la commande Console.Write (pour afficher sans faire de retour à la ligne) ou
Console.WriteLine (pour afficher un message et gérer juste après un retour à la ligne). Enfin,
Console.Clear() permet d'effacer l'écran. Pour pouvoir u'liser Console, il ne faut pas oublier d'intégrer la
bibliothèque System (using System).
Exemples
Voici des exemples d'affichage en C# (en reprenant les déclara'ons et affecta'ons précédentes) avec, en
commentaire, ce que l'on ob'ent à l'affichage :

EXEMPLES using
System; ...
Console.Write("Entrez un essai = "); // Entrez un essai =
Console.WriteLine(message); // Vous avez trouvé en 3 fois !
Console.WriteLine();
Console.WriteLine("valeur = " + valeur); // valeur = 25
Console.Write(30); // 30
Console.Write(valeur); // 25

Remarque : si vous ne meUez rien dans les parenthèses de Console.WriteLine(), alors un simple retour à la
ligne sera affiché.
Programma'on procédurale 6 / 71

— Exercice 1
Créez un nouveau projet sous Visual Studio (il est conseillé, à chaque nouveau projet, de lui donner
un nom qui permet de se rappeler de l'exercice correspondant, par exemple ici :
Exercice1).
Déclarez 3 variables : nom, prenom et age. Ini'alisez ces 3 variables avec les valeurs vous concernant.
Affichez ensuite un message qui doit ressembler à ceci (imaginons que vous vous appeliez Alain DUPONT
et que vous ayez 19 ans) :
Bonjour Alain DUPONT, vous avez 19 ans.
(Bien sûr, le prénom, nom et l'âge ne doivent pas être mis en dur dans la chaîne d'affichage, mais doivent
provenir du contenu des variables)

2B. La saisie
But Saisie au clavier d'une valeur et possibilité de mémorisa'on de ceUe valeur dans une
variable.
Fonc+onnement
Arrêt momentané de l'exécu'on du programme en aUendant la saisie.
Une fois la saisie faite et validée (ou non si c'est une saisie d'un caractère sans valida'on), transfert de
l'informa'on saisie dans la variable en mémoire si une affecta'on de la saisie est faite. Si la variable contenait déjà
une informa'on, elle est écrasée par la nouvelle informa'on saisie. Reprise de la suite de l'exécu'on du
programme.
Programma'on procédurale 7 / 71

Cas d'erreurs
Lors de la saisie, une erreur peut survenir dans les cas suivants :
— dans le cas d'une saisie avec valida'on (qui permet normalement de saisir une chaîne), si la variable qui reçoit
l'informa'on n'est pas de type chaîne (et que la saisie n'est pas transtypée). Par exemple, si la variable est de
type numérique ;
— dans le cas d'une saisie sans valida'on (qui permet normalement de saisir un seul caractère), si la variable
qui reçoit le caractère n'est pas de type caractère ;
— la variable n'est pas déclarée (en revanche elle n'a pas besoin d'être ini'alisée). Ces erreurs
seront repérées et signalées par l'IDE.
Certains langages u'lisent des ordres différents pour saisir des types différents, voire s'occupent du transtypage
sans avoir besoin de le préciser.
Syntaxe C#
En C#, la saisie se fait avec la commande Console.ReadLine() (pour lire une chaîne de caractères se terminant
par une valida'on) ou Console.ReadKey().KeyChar (pour lire un seul caractère sans avoir besoin de valider).
Pour pouvoir u8liser Console, il ne faut pas oublier d'intégrer la bibliothèque System (using System).
Exemples
Voici des exemples de saisie en C# (en reprenant les déclara'ons précédentes) :

EXEMPLES
message = Console.ReadLine();
essai = int.Parse(Console.ReadLine());
note = float.Parse(Console.ReadLine());
reponse = Console.ReadKey().KeyChar;
Programma'on procédurale 8 / 71

3. Les opéra3ons
Un programme doit pouvoir réaliser différentes opéra'ons arithmé'ques et logiques.
3A. Le calcul arithmé,que
But
Possibilité de réaliser des calculs arithmé'ques entre des variables numériques et/ou des valeurs numériques, et
affecta'on du résultat dans une variable (ou affichage direct du résultat).
Fonc+onnement
Dans le cas d'une affecta'on, le calcul qui se trouve à droite de l'affecta'on est évalué. Son résultat est transféré
dans la variable qui se trouve à gauche de l'affecta'on.
Si la variable qui reçoit le résultat du calcul contenait une autre valeur, celle-ci est écrasée pour laisser la place à la
nouvelle valeur.
Dans le cas d'un affichage direct, le calcul, mis entre parenthèses, est évalué avant l'affichage. Il peut être
concaténé à une chaîne.
Cas d'erreurs
Lors du calcul, une erreur peut survenir dans les cas suivants :
Programma'on procédurale 9 / 71

— la ou les variables u'lisées dans le calcul ne sont pas déclarées et/ou ne con'ennent pas de valeur ;
— la ou les variables u'lisées dans le calcul ne sont pas numériques ;
— le calcul demandé n'est mathéma'quement pas possible (division par 0...).
Dans le cas où le résultat du calcul est affecté dans une variable, il est possible de rencontrer aussi les erreurs
citées dans la par'e affecta'on.
Ces erreurs seront repérées et signalées par l'IDE (excepté la division par 0 qui provoquera une erreur lors de
l'exécu'on.
Opéra+ons arithmé+ques possibles
Voici les opéra'ons arithmé'ques possibles sur des variables et/ou valeurs numériques :
+ Addi'on

- Soustrac'on
* Mul'plica'on
/ Division
/ Division en'ère lorsque le résultat est transféré dans une variable type en'er Exemple : la division
en'ère de 14 par 3 donne 4

% Reste de la division (modulo)

Exemple : le reste de la division de 14 par 3 donne 2 car 4*3=12 et il manque 2 pour arriver à 14.
(14/3 = 4.66666… on ne garde que la par'e en'ère qui est bien 4).

() Parenthèses (permet de hiérarchiser les calculs, comme en mathéma'que).

Raccourcis d'écritures possibles en C# :
a=a+1 a++

a=a–1 a--

a=a+b a += b

a=a–b a -= b

a=a*b a *= b

a=a/b a /= b

Exemples en C#
Voici des exemples de calculs arithmé'ques en C# :
Programma'on procédurale 10 / 71

EXEMPLES
float note1, note2, moyenne;
int total, valeur, diviseur, result, reste;
note1 = 15.5f; /* f pour signaler que la valeur en dur est
float, d pour double, m pour decimal (rien pour les entiers) */
note2 = 8.5f;
moyenne = (note1 + note2) / 2; // moyenne contiendra 12
total = 25 * 2; // total contiendra 50
total = total + 2; // total contiendra alors 52
total += 2; // instruction similaire à la précédente (total vaut
54)
valeur = 14; diviseur = 3;
result = valeur / diviseur; /* result contiendra 4 : la division étant
transférée dans un entier, seule la partie entière est récupérée */
reste = valeur % diviseur; // reste contiendra 2
Programma'on procédurale 11 / 71

— Exercice 3
Créez un nouveau projet Exercice3.
Le programme doit permeUre la saisie d'une somme de notes (pour le moment on saisit directement la
somme, par exemple 125,5), ainsi que le nombre de notes (par exemple 8) et doit afficher la moyenne (si
les valeurs précédentes sont saisies, on devrait obtenir 15.6875).
AUen'on, la saisie d'un nombre à virgule se fait avec le séparateur configuré par votre système
d'exploita'on (s'il est configuré pour les normes françaises, il ne faut pas u'liser le point mais la virgule, et
il est inu'le d'ajouter la leUre f lors de la saisie).

— Exercice 4
Créez un nouveau projet Exercice4.
Le programme doit permeUre la saisie d'un prix HT, d'un taux de TVA et d'afficher le prix TTC équivalent.

3B. Les expressions logiques

But
Possibilité de réaliser des expressions logiques et u'lisa'on du résultat (true ou false) dans un test, ou affecta'on
du résultat dans une variable booléenne (ou affichage direct du résultat, neUement plus rare dans ce cas vu que le
résultat sera true ou false).
Fonc+onnement
Même principe que pour le calcul.
Cas d'erreurs
Lors de l'expression logique, une erreur peut survenir dans les cas suivants :
— la ou les variables u'lisées dans l'expression logique ne sont pas déclarées et/ou ne con'ennent pas de
valeur ;
— l'expression logique demandée n'est techniquement pas réalisable (incompa'bilité de types, opéra'ons
impossibles…).
Dans le cas où le résultat de l'expression logique est affecté dans une variable, la variable doit être de type
booléen.
Ces erreurs seront repérées et signalées par l'IDE.
Comparateurs mathéma+ques possibles et syntaxe en C#
Dans une expression logique, voici les comparateurs mathéma'ques possibles sur des variables et/ou valeurs
numériques, chaînes ou booléennes :
Opérateur C# Syntaxe Fonc8onnement
= == a == b Vrai si les 2 sont égaux
≠ != a != b Vrai si les 2 sont différents
> > a>b Vrai si a est strictement supérieur à b
Programma'on procédurale 12 / 71

< < a<b Vrai si a est strictement inférieur à b

≥ >= a >= b Vrai si a est supérieur ou égal à b
≤ <= a <= b Vrai si a est inférieur ou égal à b
Opéra+ons logiques possibles et syntaxe en C#
Dans une expression logique, voici les opéra'ons logiques possibles sur des variables et/ou valeurs booléennes (a
et b sont booléens ou con'ennent une expression logique résultat d'une comparaison mathéma'que) :
Opérateur C# Syntaxe Fonc8onnement
ET && a && b Vrai si a et b sont tous les 2 vrais Faux
dans les autres cas

OU || a || b Vrai si a est vrai ou b est vrai Faux

si les 2 sont faux

NON ! !a Vrai si a est faux Faux

si a est vrai

Exemples en C#
Voici les expressions logiques possibles sur des variables et/ou valeurs numériques ou booléennes (les chaînes
peuvent aussi être comparées par rapport à l'ordre alphabé'que, mais pas directement avec des signes de
comparaisons : on verra plus loin comment faire) :

EXEMPLES
bool trouve = (valeur==essai); /* les 2 variables sont comparées, si elles sont
égales, true est transféré dans la variable trouve, false dans le cas contraire
*/
int A = 3, B = 2, C = 5;
bool compare = (A > B && (A + B == C)); /* le test est vrai puisque A qui vaut 3
est supérieur à B qui vaut 2, et A+B est bien égal à C, donc la variable compare
va recevoir true */
Programma'on procédurale 13 / 71

4. Les instruc3ons condi3onnelles

Un programme doit pouvoir exécuter des instruc'ons sous condi'on (une ou plusieurs fois). Cela est possible à
travers les traitements alterna'fs ou itéra'fs.
4A. L'alterna,ve
But Exécu'on de traitements sous
condi'on.
Fonc+onnement
Une expression logique est évaluée (c'est la condi'on dans le "si" ou "if").
Si elle est vraie, un lot de traitements est exécuté (on parle de la par'e "alors" ou "then" de l'alterna've). Si elle
est fausse, un autre lot de traitements peut être exécuté (ceUe seconde par'e est op'onnelle : on parle de la
par'e "sinon" ou "else" de l'alterna've). Cas d'erreurs
Lors d'une alterna've, une erreur peut survenir dans les cas suivants :
— la condi'on n'est pas une expression logique valide (ne retourne pas un booléen) ;
— la par'e "then" ne con'ent pas de traitements ;
— il y a plusieurs par'es "then" ou plusieurs par'es "else" pour une seule condi'on ; — Il y a une
par'e "else" sans par'e "then".
Ces erreurs seront repérées et signalées par l'IDE. Syntaxe
C#
Voici les 2 syntaxes possibles en C# pour l'alterna've simple.
Programma'on procédurale 14 / 71

// Syntaxe ne contenant que le bloc 'then'

if (condition) {
// instructions exécutées si la condition est vraie
}
// Syntaxe contenant le bloc 'then' et le bloc 'else'
if (condition)
{
// instructions exécutées si la condition est vraie
} else
{
// instructions exécutées si la condition est fausse
}

Exemples
Voici des exemples d'alterna'ves :

EXEMPLES
Programma'on procédurale 15 / 71

float moyenne = 8.5f;

/* Dans l'exemple ci-dessous, la condition est fausse ('moyenne' n'est pas
supérieure ou égale à 10) donc seul le message "recalé" sera affiché */
if (moyenne >= 10
{
Console.WriteLine("accepté");
}
else
{
Console.WriteLine("recalé");
}
/* Dans l'exemple ci-dessous, la 1ère condition est encore fausse donc le bloc
'else' est exécuté. Ce bloc contient une nouvelle condition qui cette fois est
vraie ('moyenne' est bien supérieure ou égale à 8), donc le bloc 'then' de cette
nouvelle condition est exécuté, ce qui donne le message "rattrapage". Observez
les indentations (décalages du code à l'intérieur des blocs).
Remarquez aussi qu'il est possible d'imbriquer des alternatives. En fait, tout
peut être imbriqué en programmation.
Observez aussi le fait que quand on est dans le premier 'else', c'est que la
première condition est fausse ('moyenne' est inférieure à 10) donc il est
évidemment inutile de retester moyenne avec 10 : il suffit de le tester avec 8.
*/
if (moyenne >= 10)
{
Console.WriteLine("accepté");
}
else
{
if (moyenne >= 8)
{
Console.WriteLine( "rattrapage");
}
else
{
Console.WriteLine( "recalé");
}
}
Programma'on procédurale 16 / 71

— Exercice 5
Créez un nouveau projet Exercice5.
Le programme doit permeUre de saisir un âge et d'afficher "majeur" si la personne a au moins 18 ans,
"mineur" si elle n'a pas encore aUeint cet âge.
Dans le cas où la personne est mineure, il faudra aussi afficher un message qui précise dans combien
d'années la personne sera majeure.
Programma'on procédurale 17 / 71

— Exercice 6
Créez un nouveau projet Exercice6.
Le programme doit permeUre de saisir une moyenne et d'afficher la men'on correspondante ("très bien" à
par'r de 16, "bien" à par'r de 14, "assez bien" à par'r de 12, "passable" à par'r de 10, "recalé" en dessous
de 10).

Cas par+culier de l'alterna+ve mul+ple

Il existe une variante de l'alterna've qui permet à par'r d'une variable, de gérer plusieurs cas différents. Voici la
syntaxe :

EXEMPLE
switch (variable)
{
case valeur1:
// traitements exécutés si variable == valeur1
break;
case valeur2:
// traitements exécutés si variable == valeur2
break;
...
case valeurN:
// traitements exécutés si variable == valeurN
break;
default :
/* bloc 'else' optionnel : traitements exécutés si 'variable' différent de
toutes les valeurs précédentes */
break;
}

CeUe forme d'alterna've est intéressante pour tester une variable avec plusieurs valeurs dis'nctes et non des
plages de valeurs (par exemple, pour tester les différents choix d'un menu).
4B. L'itéra,on
But Possibilité de répéter plusieurs fois une séquence de
traitements.
Fonc+onnement
Une séquence de traitements est placée dans un bloc qui commence ou se termine par un test : suivant le résultat
du test, la séquence est répétée. Cas d'erreurs
Lors d'une itéra'on, une erreur peut survenir dans les cas suivants :
— la syntaxe de l'itéra'on n'est pas correcte ;
— le test n'est syntaxiquement pas correct (voir les erreurs possibles sur les expressions logiques et
mathéma'ques) ;
Ces erreurs seront repérées et signalées par l'IDE.
Il existe trois itéra'ons possibles : le choix doit se faire suivant les besoins.
Programma'on procédurale 18 / 71

Itéra+on indéterministe avec test en début de boucle

Syntaxe en C#

while (condition_pour_continuer_à_boucler)
{
// traitements qui seront répétés tant que la condition est vraie
}
Fonc8onnement
La condi'on est évaluée une première fois. Si elle est vraie, les traitements sont exécutés et le programme retourne
à la condi'on. À chaque tour de boucle, la condi'on est à nouveau évaluée et les traitements sont exécutés tant
que la condi'on est vraie. Lorsque la condi'on devient fausse, l'exécu'on du programme reprend après la boucle.
La condi'on étant testée dès le début de la boucle, le nombre d'itéra'ons peut aller de 0 à n fois : 0 fois si la
condi'on est fausse dès la première fois, n fois sans savoir à l'avance la valeur de n car cela dépend de l'évolu'on
des valeurs contenues dans la condi'on (d'où le fait que c'est une boucle indéterministe : on ne sait pas à l'avance
le nombre d'itéra'ons).
CeUe boucle est appelée la boucle "universelle" car toute itéra'on peut être représentée par ceUe boucle 'while'.
Vous verrez plus loin deux autres types de boucles qui sont plus spécifiques. Exemple
Voici un exemple :

EXEMPLE
int somme = 0, k = 1;
while (k <= 5)
{
somme = somme + k;
k++;
}
// en sortie de boucle, somme contient 1+2+3+4+5 = 15

Faisons la "trace" du programme (exécu'on pas-à-pas des instruc'ons et évolu'on du contenu des variables)
comme si nous nous me•ons à la place de l'ordinateur :
Ligne de commande k somme
int somme = 0, k = 1; 1 0
while (k <= 5) vrai
somme = somme + k; 0+1 = 1
k++; 1+1 = 2
while (k <= 5) vrai
somme = somme + k; 1+2 = 3
k++; 2+1 = 3
while (k <= 5) vrai
somme = somme + k; 3+3 = 6
Programma'on procédurale 19 / 71

k++; 3+1 = 4
while (k <= 5) vrai
somme = somme + k; 6+4 = 10
k++; 4+1 = 5
while (k <= 5) vrai
somme = somme + k; 10+5 = 15
k++; 5+1 = 6
while (k <= 5) faux
// sortie de boucle…
Vous remarquez qu'à chaque fois le test de la boucle est évalué et, tant qu'il est vrai, le contenu de la boucle est
exécuté. Lorsque 'k' aUeint la valeur 6, le test n'est plus correct et l'exécu'on du programme reprend après la
boucle.
Programma'on procédurale 20 / 71

— Exercice 7
Créez un nouveau projet Exercice7.
Le programme doit permeUre de saisir plusieurs prix en arrêtant la saisie avec 0 (ceUe informa'on sera
d'ailleurs précisée dans le message qui s'affiche à l'écran et qui précède la saisie). Au final, il faudra afficher
le total. AUen'on, on peut très bien saisir 0 dès le départ.
Programma'on procédurale 21 / 71

— Exercice 8
Créez un nouveau projet Exercice8.
Le programme doit faire la même chose que le précédent (saisie de prix et affichage du total) mais ceUe fois,
avant la saisie d'un prix, une ques'on est posée à l'u'lisateur : "Avez-vous un prix à saisir ? (O/N) ". La
réponse doit se faire en permeUant à l'u'lisateur de taper soit O soit N sans valider. S'il répond O, alors on lui
demande de saisir un prix. S'il répond N, alors le total des prix précédemment saisis s'affiche.

Itéra+on indéterministe avec test en fin de boucle

Syntaxe en C#

EXEMPLE
do
{
// traitements qui seront répétés tant que la condition est vraie
} while (condition_pour_continuer_à_boucler);

Fonc8onnement
CeUe fois, les traitements sont exécutés une première fois avant que la condi'on soit évaluée. Si elle est vraie, les
traitements sont à nouveau exécutés. Le fonc'onnement est donc similaire à l'itéra'on précédente excepté que le
test est en fin de boucle. Du coup le nombre d'itéra'ons va de 1 à n fois (les traitements sont au moins exécutés
une fois).
Ce type de boucle est idéal quand les traitements doivent être faits au moins une fois. Elle peut bien sûr aussi être
transformée en une boucle 'while' universelle.
Remarque : Dans certains langages, et aussi en pseudo-langage (en algorithmique), la condi'on est inversée et on
boucle "jusqu'à" ce que la condi'on soit vraie (une sorte de "do…un'l"). Ceci est dit à 'tre purement informa'f,
juste pour que vous ayez conscience qu'il peut exister des variantes. Exemple
Voici un exemple :

EXEMPLE
int somme = 0, k = 1; do
{
somme = somme + k;
k++;
} while (k<=5)
// en sortie de boucle, somme contient 1+2+3+4+5 = 15

Remarquez que l'exemple est le même que celui u'lisé précédemment pour illustrer la boucle 'while'. C'est
aussi pour vous montrer qu'il existe souvent plusieurs écritures différentes, qui fonc'onnent.
Programma'on procédurale 22 / 71

— Exercice 9
Créez un nouveau projet Exercice9.
Le programme doit permeUre de saisir une note en contrôlant que la valeur saisie est bien entre 0 et 20. La
saisie est redemandée jusqu'à ce qu'une note correcte soit saisie. Au final, il faudra afficher la note correcte
saisie.

— Exercice 10
Créez un nouveau projet Exercice10.
Le programme doit permeUre de saisir le sexe (sous forme H ou F) puis d'afficher "Bonjour madame" ou
"Bonjour monsieur". La saisie de H ou F doit être contrôlée (il faut redemander la saisie tant que l'u'lisateur
n'a pas tapé H ou F).

Itéra+on déterministe Syntaxe en

C# :
Programma'on procédurale 23 / 71

EXEMPLE
for (initialisation ; condition_pour_boucler ; opération_répétée) {
// traitements qui seront répétés tant que la condition est vraie
}

Fonc8onnement
La première ligne est composée de 3 par'es :
— ini'alisa'on : ceUe par'e n'est exécutée qu'une seule fois (on l'u'lise généralement pour ini'aliser une
variable qui sert de compteur de boucle ;
— condi'on_pour_boucler : comme dans les autres itéra'ons, ceUe condi'on est évaluée à chaque tour de
boucle (la sor'e de la boucle se fait quand la condi'on est fausse) ;
— opéra'on_répétée : à chaque tour de boucle, si la condi'on est vraie, ceUe opéra'on est faite après que les
traitements dans la boucle soient exécutés.
Compte tenu de la structure par'culière de ceUe itéra'on, elle pourrait très bien être indéterministe. Cependant,
elle est classiquement u'lisée comme boucle déterministe de la façon suivante :
— ini'alisa'on : une variable (compteur) est ini'alisée (généralement à une valeur de départ type 0 ou 1, ou
une valeur d'arrivée) ;
— condi'on_pour_boucler : le compteur est testé (le but étant de boucler tant que le compteur ne dépasse pas
une certaine valeur, ou au contraire ne passe pas en dessous d'une certaine valeur) ; — opéra'on_répétée : le
compteur est incrémenté (ou décrémenté).
Ce type de boucle est idéal quand on sait combien de fois il faut boucler. Elle peut bien sûr aussi être transformée
en une boucle 'while' universelle.
Exemple
Voici un exemple :

EXEMPLE int k,
somme=0;
for (k = 1; k <= 5; k++)
{
somme = somme + k;
}
// en sortie de boucle, somme contient 1+2+3+4+5 = 15

Remarquez que l'exemple est encore une fois le même. Effec'vement, l'exemple précédent se prête parfaitement
à ce type de boucle 'for' car on sait combien de fois il faut boucler. Observez aussi ceUe variante :

EXEMPLE
int somme=0;
Programma'on procédurale 24 / 71

for (int k = 1; k <= 5; k++)

{
somme = somme + k;
}
// en sortie de boucle, somme contient 1+2+3+4+5 = 15

Il est tout à fait possible de déclarer une variable au niveau d'un bloc, et non pour tout le programme. CeUe fois,
'k' n'est visible qu'au niveau de la boucle, ce qui nous convient parfaitement car k n'est u'le que dans la boucle.
CeUe nota'on est classiquement u'lisée pour les compteurs de boucle 'for' (comme c'est le cas ici pour 'k') mais
pas seulement, l'idée étant de toujours déclarer une variable au niveau le plus bas (dans le bloc où elle est
u'lisée).
On u'lise généralement juste une leUre pour nommer un compteur (i, j, k…) mais ce n'est absolument pas une
obliga'on. La variable 'somme', en revanche, n'aurait pas pu être déclarée dans la boucle car elle doit être
ini'alisée à 0 avant la boucle. La variable 'k' n'a pas besoin d'être ini'alisée avant la boucle car elle est ini'alisée
dès le début de boucle (au niveau du 'for').
Programma'on procédurale 25 / 71

—
Voici un extrait de code. Sans tester sur ordinateur, donnez les valeurs de a, b et c en fin

— Exercice 11
Créez un nouveau projet Exercice11.
Le programme doit permeUre de saisir 5 notes et au final d'afficher la moyenne de ces notes.

solu&on

Voyons si vous arrivez à gérer plusieurs boucles en même temps avec les exercices suivants :

— Exercice 13
Créez un nouveau projet Exercice13.
Le programme doit permeUre de saisir un en'er entre 1 et 9 (en contrôlant la saisie) et d'afficher la table
de mul'plica'on de cet en'er.

— Exercice 14
Créez un nouveau projet Exercice14.
Améliorer le programme précédent en faisant en sorte que l'on puisse demander d'afficher plusieurs
tables de mul'plica'ons. Pour cela, une fois la 1ère table affichée, il faut demander "Voulez-vous afficher
une nouvelle table de mul'plica'on ? (O/N) ". CeUe ques'on doit être reposée après l'affichage de chaque
table. Vous pouvez aussi contrôler la réponse (pour qu'elle soit bien 'O' ou 'N'). Pensez à effacer l'écran
entre 2 tables de mul'plica'ons.

5. Les opéra3ons spécifiques

Certains types permeUent des opéra'ons spécifiques. Voyons les plus classiques.
5A. La manipula,on des chaînes
Tous les langages offrent différentes possibilités de manipula'ons des chaînes. But
Pouvoir réaliser différentes opéra'ons sur les chaînes. Vous avez déjà vu la concaténa'on mais il y a beaucoup
d'autres possibilités. Syntaxe C#
Programma'on procédurale 26 / 71

Voici les opéra'ons les plus classiques sur les chaînes, et leur syntaxe en C# (chaine1, chaine2, oldchaine,
newchaine sont de type string, debut, longueur sont de type int) :
chaine1.Length Donne la longueur de la chaîne.

chaine1.Contains(chaine2) Vrai si chaine2 est contenu dans chaine1.

chaine1.StartsWith(chaine2) Vrai si chaine1 commence par chaine2.

chaine1.EndsWith(chaine2) Vrai si chaine1 se termine par chaine2.

chaine1.Equals(chaine2) Vrai si les 2 chaînes sont égales (privilégiez Equals pour

comparer les chaînes plutôt que ==).

chaine1.CompareTo(chaine2) Comparaison par rapport à l'ordre alphabé'que :

-1 si chaine1 avant chaine2
1 si chaine1 après chaine2
0 si chaine1 iden'que à chaine2
chaine1.IndexOf(chaine2) Donne la posi'on de chaine2 dans chaine1 (sachant que le
1er caractère est à la posi'on 0). -1 si chaine2 n'est pas
trouvé.
chaine1.IndexOf(chaine2, debut) Donne la posi'on de chaine2 dans chaine1, en cherchant à
par'r de la posi'on debut (sachant que le 1er caractère est à
la posi'on 0).
chaine1.Insert(debut, chaine2) Insère chaine2 dans chaine1 à par'r de la posi'on debut.

chaine1.Replace(oldchaine,newchaine) Donne une chaîne iden'que à chaine1 mais avec toutes les
occurrences oldchaine remplacées par newchaine (oldchaine
et newchaine sont de type string).
chaine1.Replace(oldcarac,newcarac) Donne une chaîne iden'que à chaine1 mais avec toutes les
occurrences oldcarac remplacées par newcarac (oldcarac et
newcarac sont de type char).
chaine1.Substring(debut) Permet de récupérer une sous-chaîne issue de l'extrac'on
dans chaine1 à par'r de la posi'on début jusqu'à la fin.

chaine1.Substring(debut, longueur) Permet de récupérer une sous-chaîne issue de l'extrac'on

dans chaine1 à par'r de la posi'on début et avec longueur
comme nombre de caractères.
chaine1.ToLower() Permet d'obtenir la même chaîne tout en minuscule.

chaine1.ToUpper() Permet d'obtenir la même chaîne tout en majuscule.

Exemples
Voici quelques exemples :
Programma'on procédurale 27 / 71

EXEMPLES

string phrase = "Bonjour à tous.";

int longueur = phrase.Length; // longueur contient 15
if (phrase.Contains("ou")) // vrai
{
Console.WriteLine("la chaine contient ou");
}
if (phrase.StartsWith("Bon")) // vrai
{
Console.WriteLine("la chaine commence par Bon");
}
string newphrase = phrase.Insert(10, "vous "); // newphrase contient "Bonjour à
vous tous"
newphrase = phrase.Replace("Bonjour", "Bonsoir");
// newphrase contient "Bonsoir à tous"
string extrait = phrase.Substring(6, 3);
// extrait contient "r à"

— Exercice 15
Créez un nouveau projet Exercice15.
Le programme doit permeUre de saisir une phrase puis d'afficher la même phrase mais avec des "_" à la place
des espaces.
Programma'on procédurale 28 / 71

— Exercice 16
Créez un nouveau projet Exercice16.
Le programme doit permeUre de saisir une phrase puis un mot. Si ce mot est présent dans la phrase, il faut
afficher la phrase mais uniquement à par'r de ce mot. Si le mot n'est pas présent, il faut le signaler par un
message.
Exemple :
Si la phrase saisie est "N'essaie pas, fais-le, ou ne le fais pas"
Et que le mot saisi est "ne"
Le résultat doit être "ne le fais pas"

5B. Les fonc,ons mathéma,ques

Tous les langages offrent des ou'ls mathéma'ques puissants.
But Pouvoir réaliser des opéra'ons mathéma'ques
évoluées.
Syntaxe C#
En u'lisant la classe Math (j'u'lise le terme "classe" dès maintenant, mais vous comprendrez vraiment son sens
plus tard), vous avez accès à de nombreuses possibilités. Vous pouvez facilement le voir en tapant Math suivi d'un
point. Voici quelques exemples :
Math.PI Donne la valeur du nombre PI (type double).
Math.Pow(nombre, puissance) Donne le nombre élevé à la puissance.

Math.Abs(nombre) Donne la valeur absolue d'un nombre (le nombre sans son signe).
Math.Max(val1, val2) Donne la plus grande des 2 valeurs.

Math.Min(val1, val2) Donne la plus pe'te des 2 valeurs.

Math.Round(nombre) Donne l'en'er le plus proche.
Math.Sqrt(nombre) Donne la racine carrée d'un nombre.

...
Faites aUen'on aux types retournés par les différentes fonc'ons. Les variables qui doivent recevoir le résultat
doivent être du bon type. À chaque fois que vous u'lisez une fonc'on, l'IDE précise le type concerné. Certains
types sont cependant compa'bles. Exemples
Voici quelques exemples :

EXEMPLES
int val = Math.Min(2, 5); // val contient 2
Programma'on procédurale 29 / 71

double cube = Math.Pow(val, 3); // cube contient 8 (2 puissance 3)

int valabs = Math.Abs(-12); // valabs contient 12
double nombre = Math.Sqrt(valabs); // nombre contient 3,464101615...
double arrondi = Math.Round(nombre); // arrondi contient 3
double arrondi2 = Math.Round(Math.Sqrt(valabs)); // arrondi2 contient 3

Remarquez le dernier exemple : il est possible de meUre dans les parenthèses l'appel d'une autre fonc'on, à
condi'on qu'elle donne une valeur du type aUendu dans les parenthèses.

— Exercice 17
Créez un nouveau projet Exercice17.
Le programme doit permeUre de saisir un nombre puis de demander de saisir la racine carrée de ce
nombre. Si l'u'lisateur a saisi la bonne valeur, "bravo" sera affiché, sinon il faudra lui dire qu'il s'est
trompé et afficher la bonne réponse sous la forme : "Erreur, la racine carrée de 9 est 3" (dans le cas où le
nombre de départ est 9).

— Exercice 18
Créez un nouveau projet Exercice18.
Le programme doit permeUre de saisir 3 nombres (type double) et d'afficher le plus pe't des trois. Le but
ici est de ne pas u'liser de "if".

5C. Les autres fonc,ons

Sans détailler plus, sachez qu'il existe de nombreux ou'ls mis à votre disposi'on par les langages pour manipuler
différentes no'ons. Par exemple, il existe des fonc'ons pour gérer les dates (nombre de jours entre 2 dates, jour
de la semaine d'une date…).
Vous aurez l'occasion de découvrir ces possibilités au cours de votre appren'ssage et au fur et à mesure des
besoins. Pour le moment, l'important est juste de savoir que cela existe.
Programma'on procédurale 30 / 71

6. Op3misa3on
Un programme ne doit pas se contenter de "marcher". Il doit être op'misé pour être le plus performant possible.
L'op'misa'on intervient à plusieurs niveaux.
6A. Op,misa,on en lisibilité : règles de codage
On parle aussi de charte de code. L'idée est de respecter un certain nombre de règles pour que le code soit le
plus propre possible mais aussi et surtout soit facile à lire et relire par l'auteur ou par tout autre développeur
connaissant la charte. Voici les règles principales. Indenta+ons
Les indenta'ons représentent les décalages faits dans le code pour améliorer sa lisibilité en permeUant de repérer
plus facilement les différents blocs et leurs imbrica'ons. Les décalages u'lisés doivent toujours être de même
taille. Tous les IDE évolués proposent les indenta'ons et les insèrent automa'quement. Cependant, suivant les
modifica'ons que vous allez apporter, vous pouvez parfois "casser" ces indenta'ons. Pensez donc à les contrôler.
Sous Visual Studio, si vous sélec'onnez un ensemble de lignes et que vous faites Ctrl+K suivi de Ctrl+F, les
indenta'ons se refont automa'quement dans la par'e sélec'onnée. Autre astuce : il suffit de supprimer la
dernière accolade fermante et de la réinsérer : toutes les indenta'ons se refont. Ce qu'il faut retenir c'est que
chaque contenu de bloc doit être décalé à droite.

EXEMPLE
int a = 3, b = 2, c = 3;
while (a > b)
{
if (a == c)
{
a-;
if(a > 1)
{
c++;
b = Math.Min(a, c);
}
} else
{
b++;
}
}

Remarquez bien que chaque bloc est entouré d'accolades et le contenu est décalé vers la droite.
Nom des variables et des modules
Les noms des variables et des modules (et, nous verrons plus tard, d'autres choses comme les classes), doivent
être choisis judicieusement.
Voici les règles classiquement admises :
— Le nom doit représenter clairement le contenu.
— Les caractères u'lisés dans le nom sont limités : leUres non accentuées, chiffres, 'ret bas. Le 'ret bas n'est
préconisé qu'en premier caractère, dans certaines circonstances par'culières.
Programma'on procédurale 31 / 71

— Le premier caractère du nom ne peut être qu'une leUre ou, uniquement dans certains cas précis, un 'ret
bas.
— L'u'lisa'on des majuscules respecte la nota'on camelCase pour les noms de variables (chaque mot
cons'tuant le nom commence par une majuscule, sauf le premier mot) et PascalCase (aussi appelée
UpperCamelCase) pour les noms de modules (idem camelCase mais même le premier mot commence par une
majuscule).

EXEMPLE
float note, moyenneNotes;
int nbNotes, coef;
string matiere, nomEtudiant,
prenomEtudiant;
static int Min(int a, int b) { ...}

Dans cet exemple, on a respecté les règles suivantes : nommer de façon parlante, éviter les caractères accentués,
u'liser la nota'on camelCase pour les noms de variables et la nota'on PascalCase pour les noms des modules :
ce sont les nota'ons préconisées sous Visual Studio. Si vous écrivez un module commençant par une minuscule,
sans signaler d'erreur, il informe juste que le nommage n'est pas correct :

Commentaires
Les commentaires permeUent d'apporter des informa'ons en clair pour aider à la compréhension du code.
Certains commentaires sont ignorés par l'ordinateur (donc ne servent qu'à informer celui qui lit le code),
d'autres commentaires apportent des informa'ons interprétées par l'ordinateur (par exemple pour générer
automa'quement la documenta'on technique). Les différents types de commentaires Il existe 3 types de
commentaires sous C#:
Programma'on procédurale 32 / 71

/*
* commentaire informatif de plusieurs
* lignes
*/
// commentaire informatif d'une ligne
/**
* commentaire pouvant être interprété
* de plusieurs lignes
*/
/// commentaire pouvant être interprété, d'une ligne

Remarquez la différence de couleur (des étoiles et des barres) entre les commentaires interprétés et ceux non
interprétés (vert pour "informa'f", gris pour "interprété"). Autre remarque : les étoiles sur chaque ligne
intermédiaire ne sont pas obligatoires

. Important
Inu8le de meYre beaucoup de commentaires non interprétés. Ne meYez pas un commentaire par ligne de
code, mais plutôt un commentaire en tête d'un ensemble de lignes pour présenter le but du bloc concerné. Le
code lui-même doit être clair à comprendre. Si ce n'est pas le cas, donc si le code est obscur, il doit être repensé.
Les commentaires interprétés
En revanche, les commentaires interprétés en tête de modules sont indispensables et doivent préciser le rôle du
module, des paramètres et, dans le cas d'une fonc'on qui retourne une valeur, le rôle du retour. Visual Studio
apporte une aide à la créa'on de commentaires de modules, dans le but de la généra'on automa'que de la
documenta'on technique au format XML. Il suffit de placer le curseur une ligne au-dessus du module, de valider
pour que le curseur se place au bon niveau d'indenta'on, et de taper "///". On ob'ent automa'quement la
structure suivante :
Programma'on procédurale 33 / 71

EXEMPLE DE STRUCTURE DE COMMENTAIRE D'UN MODULE SOUS C#

/// <summary>
///
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns> static
int Min(int a, int b)
{
if (a < b)
{
return a;
} else
{
return b;
}
}
Il ne reste alors plus qu'à remplir avec les informa'ons que l'on désire retrouver dans la documenta'on
technique.

EXEMPLE DE COMMENTAIRE REMPLI D'UN MODULE SOUS C#

/// <summary>
/// recherche le minimum entre 2 entiers reçus en paramètre ///
</summary>
/// <param name="a">premier entier</param>
/// <param name="b">second entier</param>
/// <returns>le plus petit entre les 2 paramètres</returns> static
int Min(int a, int b)
{
if (a < b)
{
return a;
} else
{
return b;
}
}
Programma'on procédurale 34 / 71

Généra8on de la documenta8on technique

Pour que la documenta'on technique soit automa'quement générée, il faut modifier le paramétrage du projet.
Cela se fait dans le menu "Projet > Propriétés". Dans la par'e "Build" (à gauche), il faut cocher la case "Fichier de
documenta'on XML". Le chemin et le nom du fichier apparaissent (ce qui est modifiable).

Par défaut, le chemin est "bin\Debug\" et le nom du fichier de la documenta'on est le nom du projet avec
l'extension "xml".
Voici à quoi ressemble le contenu du fichier, à par'r de l'exemple de commentaire précédent :
Programma'on procédurale 35 / 71

EXEMPLE DE DOCUMENTATION TECHNIQUE SOUS C#

<?xml version="1.0"?>
<doc>
<assembly>
<name>MesTestsPersos</name>
</assembly>
<members>
<member name="M:MesTestsPersos.Program.Min(System.Int32,System.Int32)">
<summary>
recherche le minimum entre 2 entiers reçus en paramètre
</summary>
<param name="a">premier entier</param>
<param name="b">second entier</param>
<returns>le plus petit entre les 2 paramètres</returns>
</member>
</members>
</doc>
Remarquez la balise "<member name" qui a été automa'quement remplie avec le nom du projet, suivi de
"Program", du nom de la fonc'on "Min" et des types des paramètres aUendus. La suite correspond aux
informa'ons qui ont été saisies dans la zone de commentaire.
Il faut ensuite u'liser des ou'ls permeUant d'exploiter le fichier xml afin de présenter son contenu proprement,
par exemple sous forme d'un site. Cet aspect sera vu plus tard.
6B. Op,misa,on en temps
Le but est parfois d'op'miser le temps d'exécu'on d'un programme. Un même programme peut être écrit de
plusieurs façons différentes : toutes les solu'ons peuvent donner un résultat iden'que à la fin, mais pas avec le
même temps d'exécu'on.
La différence est parfois minime mais lorsqu'on se place à un autre niveau (par exemple des centaines
d'internautes qui essayent d'exécuter la même fonc'onnalité), on peut obtenir des différences de temps très
significa'ves.
Il faut donc essayer de supprimer au maximum les redondances, les traitements inu'les et op'miser ceux qui sont
gourmands en ressources.
Le principe consiste à compter le nombre d'instruc'ons qui s'exécutent (qui peut être variable dès qu'il y a des
alterna'ves et surtout des itéra'ons). Le nombre d'instruc'ons peut vite exploser s'il y a des itéra'ons
imbriquées. Il faut chercher à minimiser le nombre d'instruc'ons exécutées, en par'culier en analysant les
itéra'ons u'lisées et leur per'nence.
Par exemple, méfiez-vous des boucles imbriquées : si vous avez une itéra'on qui va boucler 20 fois et qui con'ent
une autre itéra'on qui va boucler 30 fois, l'air de rien le nombre de boucles s'élève à 20x30 donc 600 fois !

EXEMPLE
Programma'on procédurale 36 / 71

// première version : 400 boucles, 400 tests, 401 affectations

int somme = 0;
for(int x = 0; x < 20; x++)
{
for(int y = 0; y < 20; y++)
{
if (y > x)
{
somme += y;
}
}
}
// deuxième version : 200 boucles, 0 tests, 201
affectations somme = 0;
for (int x = 0; x < 19; x++)
{
for (int y = x+1; y < 20; y++)
{
somme += y;
}
}

Vous pouvez tester sous Visual Studio : vous ob'endrez dans les 2 cas 2470 dans somme. Pourtant, la seconde
solu'on est 3 fois plus rapide. Cela vient d'une meilleure analyse des traitements effectués.
Dans la première solu'on, les 2 boucles vont de 0 à 19 mais l'ajout dans somme ne se fait que quand y est
supérieur à x. Donc, autant faire démarrer la seconde boucle à par'r de x+1 (la première valeur supérieure à
x). Cela permet de diminuer le nombre de boucles et d'éliminer le test.
6C. Op,misa,on en espace
L'espace représente la place de stockage. Pour le moment, vous n'avez abordé que le stockage en mémoire
centrale (des différentes variables). Vous verrez plus tard d'autres types de stockage, sur supports permanents
(disque dur…).
Actuellement, suivant les types de supports, l'op'misa'on en espace peut être plus ou moins importante : sur un
ordinateur classique, les espaces de stockage sont assez importants, mais ce n'est pas le cas pour tous les
supports, dont certains objets connectés.
6D. Op,misa,on fonc,onnelle
Le but est d'éviter les redondances au niveau du code. Pour cela, il faut repérer les répé''ons iden'ques ou
similaires et, lorsque cela est possible, créer des modules paramétrés pour les remplacer. La no'on de "module"
sera abordée dans la séance suivante.
Pour le moment, vous pouvez juste faire en sorte de minimiser les redondances dans le code. Par exemple, si vous
devez afficher plusieurs fois la même phrase avec juste une valeur qui change, autant afficher la phrase qu'une
seule fois et u'liser une variable pour la valeur.
Programma'on procédurale 37 / 71

7. Exercices récapitula3fs
Dans le domaine de la programma'on, plus vous coderez, plus vous serez à l'aise. Surtout ne regardez pas les
correc'ons directement. Vous devez tenter de coder par vous-même en u'lisant les ou'ls mis à votre disposi'on
pour corriger le programme (l'IDE vous aide pour trouver les erreurs de compila'on, ainsi que les erreurs
d'exécu'on et de logique avec le débogueur).
Les exercices sont progressifs.

— Exercice 20
Créez un nouveau projet Exercice20.
Le programme doit permeUre de saisir un nom de ville et un nombre d'habitants, pour afficher au final un
message du type :
"Grasse possède 35000 habitants."
Programma'on procédurale 38 / 71

— Exercice 21
Créez un nouveau projet Exercice21.
Le programme doit permeUre de récupérer une couleur de feu tricolore (officiellement par un capteur,
mais ce sera ici sous forme de saisie de R pour rouge, O pour orange et V pour vert) et d'afficher l'ordre
qui doit être exécuté : "s'arrêter", "ralen'r", "passer". La saisie de la couleur doit être contrôlée. Essayez
de réaliser 2 versions du programme : une avec des "if" imbriqués et une avec un switch.

— Exercice 22
Créez un nouveau projet Exercice22.
Le programme doit permeUre de saisir 10 notes puis d'afficher le nombre de notes supérieures ou égales à
la moyenne (10) et le nombre de notes inférieures à la moyenne. Il n'est pas demandé de contrôler la
saisie.

— Exercice 23
Créez un nouveau projet Exercice23.
Le programme doit permeUre de saisir plusieurs notes (entre 0 et 20) puis d'afficher la plus pe'te et la plus
grande. Pour savoir combien de notes doivent être saisies, on posera d'abord la ques'on à l'u'lisateur. Il
n'est pas demandé de contrôler les saisies.

— Exercice 24
Créez un nouveau projet Exercice24.
Le programme doit permeUre de saisir 10 températures (néga'ves ou posi'ves, et pas de bornes fixées)
puis d'afficher la plus pe'te et la plus grande.

— Exercice 25
Créez un nouveau projet Exercice25.
Le programme doit permeUre de saisir plusieurs valeurs numériques (on arrêtera la saisie en posant la
ques'on à l'u'lisateur entre chaque saisie) puis au final de dire si la suite de valeurs saisies est strictement
croissante (les valeurs ont été saisies de la plus pe'te à la plus grande). Les contrôles de saisie ne sont pas
demandés.
Aide : pour voir si la suite est croissante, il faut comparer chaque valeur saisie avec la précédente. Donc il
faut en permanence mémoriser 2 valeurs (la valeur actuelle et la précédente). Dès que 2 valeurs ne sont
pas dans le bon ordre, c'est toute la suite qui n'est pas croissante (pensez à u'liser une variable booléenne
pour mémoriser le fait que la suite est croissante ou non).
Programma'on procédurale 39 / 71

— Exercice 26
Créez un nouveau projet Exercice26.
Le programme doit permeUre de saisir un nombre de secondes (entre 0 et 86400) et d'afficher la
conversion sous forme HH:MM:SS. Faites en sorte qu'il y ait bien 2 posi'ons pour chaque valeur, donc
éventuellement en ajoutant 0 quand cela est nécessaire. Exemple : 13205 secondes donnent 03:40:05 (et
non pas 3:40:5)
Programma'on procédurale 40 / 71

CORRECTIONS

1. Correc3on des entraînements

 Programma'on procédurale 41 / 71

— Entraînement 3
Voici plusieurs déclara'ons : string
a, b;
char c; int d;
byte e;
double f;
Pour chaque instruc'on, donnez la bonne syntaxe, dans le cas où celle proposée n'est pas correcte : a
= Console.ReadLine();
b = int.Parse(Console.ReadLine());
b = Console.ReadLine();
c c = char.Parse(Console.ReadLine());
d = Console.ReadKey().KeyChar;
e = Console.ReadLine(); d = int.Parse(Console.ReadLine()); e =
int.Parse(Console.ReadLine()); e = byte.Parse(Console.ReadLine()); f =
double.Parse(Console.ReadLine());
Il suffit de bien regarder les types des variables. Par défaut, la saisie retourne un type string. Donc il ne faut pas de conversion
si la variable est de type string. Pour toutes les autres variables, il faut conver&r en respectant le type.

— Entraînement 4
Voici plusieurs déclara'ons et ini'alisa'ons :
int a = 34, b = 5, c = 4, d, e, f;
float g;
Voici une succession de traitements. A chaque ligne, précisez la valeur de la variable à gauche de l'affecta'on :
d = a / c; d = 34 / 8 // division entière
e = a % c; e = 34 % 2 = 2 // reste de la division
b *= c; b = 5 * 4 = 20
b++; b = 20 + 1 = 21 f = d * c + e;
f = 8 * 4 + 2 = 34 g = a / c;
g = 34 / 4 = 8 !!! // et non pas 8,5
Si vous vous êtes trompé sur le dernier calcul, c'est normal. Le résultat de ceAe division est bien 8,5 et on affecte ce résultat
dans une variable de type float, donc on pourrait s'aAendre à ce que la variable con&enne 8,5. En fait, C# part garde les
types des variables du calcul : puisque vous divisez un en&er par un en&er, il retourne un en&er. Dans le calcul, il suffit
qu'une des valeurs soit de type float pour que le résultat soit bien de type float. Pour conver&r la variable de type int en
type float, vous ne pouvez pas u&liser float.Parse qui sert à conver&r un string en float. Il faut u&liser une autre méthode
qui fonc&onne sur des types dits "compa&bles" : g = (float)a / c;
CeUe fois, g con'endra bien 8,5.
Programma'on procédurale 42 / 71
Programma'on procédurale 43 / 71
Programma'on procédurale 44 / 71
 Programma'on procédurale 45 / 71

2. Correc3on des exercices

— Exercice 1
Code de la correc'on :
static void Main(string[] args)
{
// déclarations et initialisations
string prenom = "Alain"; string
nom = "DUPONT"; int age = 19;
// affichage personnalisé
Console.WriteLine("Bonjour" + prenom + " " + nom + ", vous avez " + age + "
ans.");
Console.ReadLine();
}
Explica&ons :
L'affichage peut se faire comme ci -dessus en une seule ligne, en combinant les chaînes en dur (mi ses entre
guillemets et qui apparaissent en rouge dans le code) et les variables. Le signe + permet de concaténer les
chaînes (les coller les unes à la suite des autres). Tout ce qui est entre guillemets est affiché en l'état. Tout ce
qui n'est pas entre g uillemets sont des variables : c'est leur contenu qui est affiché.
Il est bien sûr possible aussi de faire l'affichage avec plusieurs Console.WriteLine. Il est
possible aussi de séparer les déclara'ons des ini'alisa'ons.
— Exercice 2
Code de la correc'on :
static void Main(string[] args)
{
// déclarations
string prenom, nom;
int age;
// saisie des 3 informations
Console.Write("Entrez votre prénom : ");
prenom = Console.ReadLine();
Console.Write("Entrez votre nom : ");
nom = Console.ReadLine();
Console.Write("Entrez votre âge : ");
age = int.Parse(Console.ReadLine());
// affichage personnalisé
Console.WriteLine("Bonjour " + prenom + " " + nom + ", vous avez " + age + "
ans."); Console.ReadLine();
Explica&ons :
Le principe est le même excepté que les variables sont remplies avec des saisies et non directement ini&alisées. Remarquez
le Parse pour l'âge car ce qui est saisi est toujours de type string et il faut changer son type pour l'affecter dans la vari able
age qui est de type int.
Programma'on procédurale 46 / 71
Programma'on procédurale 47 / 71

{
— Exercice 5
Programma'on procédurale
Code de la correc'on : 48 / 71
static void Main(string[] args)
{
// Déclaration
int age;
// Saisie de l'âge
Console.Write("Entrez votre âge = ");
age = int.Parse(Console.ReadLine());
// Test sur l'âge
if (age >= 18)
{
Console.WriteLine("Vous êtes majeur");
} else
{
Console.WriteLine("Vous êtes mineur");
Console.WriteLine("Vous serez majeur dans " + (18 - age) + " an(s)");
}
Console.ReadLine();
}

Explica'ons :
Ce programme est le premier qui con'ent une alterna've. Dans la par'e "else", puisque la personne est
mineure, il est possible de facilement calculer le nombre d'années manquantes avant la majorité. Le calcul a
été directement intégré dans l'affichage (remarquez les parenthèses pour ne pas confondre avec la
concaténa'on des chaînes). Si vous avez réalisé le calcul dans une variable, c'est tout à fait juste.
En revanche, ce qui fonc'onne mais n'est pas correct, c'est refaire un test dans le "else" pour contrôler que
l'âge est inférieur à 18. C'est une erreur très classique. Prenez conscience que si vous êtes dans le "else", c'est
que la condi'on du "if" est fausse, donc que age est bien strictement inférieur à 18. Il est donc inu'le de le
retester. Donc voilà ce qu'il ne fallait pas faire :
if (age >= 18)
{
Console.WriteLine("Vous êtes majeur");
} else
{
if (age < 18) // test totalement inutile
{
Console.WriteLine("Vous êtes mineur");
Console.WriteLine("Vous serez majeur dans " + (18 - age) + " an(s)");
}
}
Autre cas : si vous avez fait deux tests séparés, le programme va fonc'onner mais il n'est pas op'misé. En
effet, les deux tests vont être évalués alors qu'un seul suffit. Voilà donc aussi ce qu'il ne fallait pas faire :
{
Console.WriteLine("Vous êtes majeur");
}
if (age < 18) // test inutile puisqu'on peut utiliser le précédent
Console.WriteLine("Vous êtes mineur");
Console.WriteLine("Vous serez majeur dans " + (18 - age) + " an(s)");
Programma'on procédurale 49 / 71

Surtout ne vous dites pas "mon programme marche c'est le plus important". Si vous voulez devenir un bon programmeur,
vous devez faire des programmes qui marchent et qui sont efficaces.
Programma'on procédurale 50 / 71
Programma'on procédurale 51 / 71

— Exercice 7
Code de la correc'on :
static void Main(string[] args)
{
// Déclarations
float prix, total = 0;
// Saisie d'un premier prix
Console.Write("Entrez un prix (0 pour terminer) = ");
prix = float.Parse(Console.ReadLine());
// Boucle sur la saisie des prix et le cumul
while (prix != 0)
{
total = total + prix;
// saisie d'un nouveau prix
Console.Write("Entrez un prix (0 pour terminer) = ");
prix = float.Parse(Console.ReadLine());
}
// Affichage du total
Console.WriteLine("total des prix = " + total);
Console.ReadLine();
}
Explica&ons :
C'est le premier exemple d'itéra&on. Remarquez la première saisie de prix avant la boucle, puis l'autre saisie en fin de
boucle. C'est la saisie dans la boucle qui va se répéter plusieurs fois. Après chaque saisie, on teste si 0 a été entré : c'est la
condi&on pour sor&r de la boucle.
Cet exercice u&lise aussi une variable de cumul, nommée total. Elle est obligatoirement ini&alisée avant la boucle (ici, 0 lui
est affecté) car elle est u&lisée par la suite dans la boucle. Si vous n'ini&alisez pas à 0 la variable total, lors du premier
passage dans la boucle, il y a un souci car total+prix ne peut être effectué (puisque total ne con&ent rien).

— Exercice 8
Code de la correc'on :
static void Main(string[] args)
{
// Déclarations
float prix, total = 0;
char reponse;
// demande si un prix est à saisir
Console.Write("Avez-vous un prix à saisir ? (O/N) ");
reponse = Console.ReadKey().KeyChar;
// Boucle sur la saisie des prix et le cumul
while (reponse=='O')
{
// saisie d'un nouveau prix
Console.Write(" Entrez un prix = ");
prix = float.Parse(Console.ReadLine());
// cumul
total = total + prix;
// demande si un nouveau prix est à saisir
Console.Write("Avez-vous un prix à saisir ? (O/N) ");
reponse = Console.ReadKey().KeyChar;
}
// Affichage du total
Programma'on procédurale 52 / 71

Console.ReadLine();
}
Explica&ons :
La saisie de la réponse se fait sur un caractère : c'est plus pra&que. Du coup, faites aAen&on, la comparaison se fait ave c
'O' entre 2 apostrophes et non entre guillemets. C# fait la différence entre 'O' et "O" : lepremier est un caractère, le second
est une chaîne ne contenant qu'un caractère.
Ne soyez pas étonné des espaces laissés en début de chaîne " Entrez un prix = " : c'est juste pour la présenta&on pour
éviter que ce soit collé au 'O' qui est saisi just e avant. Vous avez peut -être plutôt géré un retour à la ligne juste avant.
— Exercice 9
Code de la correc'on :
static void Main(string [] args)
{
// Déclarations
int note;
// Boucle sur le contrôle de la saisie de la note
do
{
Console.Write( "Entrez une note entre 0 et 20 = ");
note = int.Parse(Console .ReadLine()); } while (note <
0 || note > 20);
// Affichage de la note
Console.WriteLine( "note saisie : " + note);
Console.ReadLine();
}
Explica&ons :
Ce genre de boucle est idéal pour tester une saisie, car justement il faut d'abord saisir avant de tester.
Dans le test de la boucle, vous avez peut -être d'abord fait l'erreur de meAre && (et) au lieu de || (ou). C'est bien
|| (ou) car on ne peut pas avoir une note qui est à la fois inférieure à 0 et supérieure à 20…
Vous avez peut -être u&lisé des types différents de ceux u&lisés dans la correc&on, et parfois même mieux adapté.
D'ailleurs ici, le type limite aux notes en&ères, ce qui ne reflète p as forcément la réalité.

Console.WriteLine(" total des prix = " + total);

Programma'on procédurale 53 / 71
Programma'on procédurale 54 / 71
Programma'on procédurale 55 / 71
Programma'on procédurale 56 / 71

— Exercice 14
Code de la correc'on :
static void Main(string[] args)
{
// Déclaration
int entier;
char reponse;
// Boucle sur plusieurs tables de multiplications
do
{
// Saisie d'un entier entre 1 et 9 avec contrôle de saisie
do
{
Console.Write("Entrez un entier entre 1 et 9 = ");
entier = int.Parse(Console.ReadLine());
} while (entier < 1 || entier > 9);
// boucle sur la table de multiplication de cet entier
for (int k = 0; k <= 10; k++)
{
Console.WriteLine(entier + " x " + k + " = " + (entier * k));
}
// Demande pour l'affichage d'une table de multiplication
do
{
Console.WriteLine();
Console.Write("Voulez-vous afficher une nouvelle table de
multiplication ? (O/N) ");
reponse = Console.ReadKey().KeyChar;
} while (reponse!='O' && reponse!='N');
// Effacer l'écran Console.Clear();
} while (reponse=='O');
}
Explica'ons :
Le programme est plus complexe car il faut arriver à gérer la grande boucle qui con'ent les autres traitements.
Si vous n'êtes pas arrivé à le faire, prenez le temps de bien le comprendre. La grande boucle générale permet
de répéter plusieurs fois l'ensemble des traitements, donc de pouvoir obtenir l'affichage de plusieurs tables de
mul'plica'ons. C'est une boucle "do" car on veut afficher au moins une table. Dans ceUe grande boucle, on
retrouve les traitements du programme précédent, avec en plus la ques'on pour con'nuer ou non.
Programma'on procédurale 57 / 71
Programma'on procédurale 58 / 71
Programma'on procédurale 60 / 71

L'erreur à ne pas faire est de penser qu'on peut meAre directement 3 valeurs dans les parenthèses : la fonc&on Min n'aAend
que 2 valeurs.
Programma'on procédurale 62 / 71
Programma'on procédurale 64 / 71

— Exercice 23
Code de la correc'on :
static void Main(string[] args)
{
// déclaration
int note;
// saisie du nombre de notes
Console.Write("Nombre de notes à saisir = ");
int nbnotes = int.Parse(Console.ReadLine());
// initialisation du min et max
int min = 20, max = 0;
// saisie des notes et recherche des min et max
for (int k = 1; k <= nbnotes; k++)
{
// saisie de la note
Console.Write("note n°" + k + " = ");
note = int.Parse(Console.ReadLine());
// est -ce la nouvelle plus petite note ?
if (note < min)
{
min = note;
}
// est-ce la nouvelle plus grande note ?
if (note > max)
{
max = note;
}
}
// affichage des extrema
if (nbnotes > 0)
{
Console.WriteLine("La plus petite note est = " + min);
Console .WriteLine( "La plus grande note est = " + max);
}
Console.ReadLine();
}
Explica&ons :
La boucle "for" reste la plus adaptée car, mêmesi le nombre de notes n'est pas fixe, il est connu dès le début du programme
après la 1ère saisie.
La recherche de la plus pe&te et de la plus grande valeur dans une série de valeurs se fait en comparant chaque valeur
avec une valeur de référence. Par ex emple, ici, pour la plus pe&te note, la variable min a été ini&alisée à 20 (car il ne peut
pas y avoir de notes au-dessus de 20) et elle est comparée à chaque note saisie. Dès qu'on saisit une nouvelle note, il suffit
de la comparer à min : si elle est plus pe&te, alors on est face à la nouvelle plus pe&te note, voilà pourquoi elle est transférée
dans min. Même logique pour max.
Lorsqu'on recherche la plus pe'te et/ou la plus grande valeur d'une série, il peut y avoir 2 cas possibles :
— soit la série est bornée (comme ici, des valeurs entre 0 et 20) alors il suffit d'ini'aliser min et max avec
les bornes ;

— soit la série est non bornée, alors il faut ini'aliser min et max avec une des valeurs de la série
(généralement la 1ère valeur).
Encore une fois, on n'a pas besoin de mémoriser toutes les valeurs d'une série pour trouver la plus pe&te ou la plus grande
valeur.
Enfin, remarquez le test final. En effet, si vous saisissez 0 notes, il ne faut pas afficher le min et le max.

— Exercice 24
Code de la correc'on :
static void Main(string[] args)
{
// déclaration
double temperature, min, max;
// saisie de la 1ère température pour initialiser min et max
Console.Write("température n°1 = ");
min = max = double.Parse(Console.ReadLine());
// saisie des autres températures et recherche des min et max
for (int k = 2; k <= 10; k++)
{
// saisie de la temperature
Console.Write("temperature n°" + k + " = ");
Programma'on procédurale 67 / 71

temperature = double.Parse(Console.ReadLine());
// est-ce la nouvelle plus petite température ?
if (temperature < min)
{
min = temperature;
}
// est-ce la nouvelle plus grande température ?
if (temperature > max)
{
max = temperature;
}
}
// affichage des extrema
Console.WriteLine("La plus petite température est = " + min);
Console.WriteLine("La plus grande température est = " + max);
Console.ReadLine();
}
Explica&ons :
Comme cela a été expliqué dans l'exercice précédent, lorsque la série n'est pas bornée, il faut alors ini&aliser min et max
avec une des valeurs de la série. Généralement on isole la première valeur. Vous remarquerez d'ailleurs que je n'ai même
pas transféré la saisie dans la variable temperature, mais directement dans min et dans max, puisqu'il n'y a pas de test à
faire.
Programma'on procédurale 68 / 71
Programma'on procédurale 69 / 71

Explica&ons :
Le programme est plus difficile mais une aide est donnée dans l'énoncé et permet de savoir comment gérer le problème.
Remarquez la première valeur saisie avant la boucle pour avoir une valeur d'avance afin de la comparer avec la nouvelle
valeur saisie. Si l'u&lisateur dit 'N' dès le début, une seule valeur sera saisie et du coup la suite sera croissante, ce qui est
correct. Pour les autres cas, donc à par&r de 2 valeurs saisies, il y a bien une comparaison des valeurs 2 à 2.
La variable croissant est à vrai au départ, et passe à faux dès que 2 valeurs ne sont pas dans l'ordre. Remarquez bien que
ceAe variable ne peut jamais repasser à vrai, une fois qu'elle est à faux. Le test final peut aussi s'écrire :
L'écriture de la correc'on vous montre comment on peut tester un booléen. C'est une écriture

if ( croissant == true) raccourcie.

Programma'on procédurale 70 / 71