[Link]

fr

Algorithmique et
Programmation Orientée
Objet
Paul-Antoine Bisgambiglia
2018
Cours 2009-2010

bisgambiglia@[Link] GEN -
 @pabisgambiglia

 Maitre de conférences en Informatique

 Directeur du département informatique depuis
2012
 Responsable du futur Master Informatique DFS
« Développeur Full Stack »
 Responsable du Master Informatique S2I depuis
2013
 Directeur des études de la licence SFA puis SPI
2012-2014
 Docteur en informatique depuis 2008

bisgambiglia@[Link] 2
 Objectifs

 L’objectif de ce cours est de réaliser une mise à

niveau dans le domaine de l’algorithmique et de la
programmation.
 Introduire les notions à la base de la POO :
 Encapsulation
 Héritage
 Polymorphisme
 Etc.

bisgambiglia@[Link] 3
 Sommaire

1. Rappels : Le Codage de l’information (2h)

2. Algorithmique (13h)
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 4
 Le Codage de l’information
Pour parler à une machine, mieux vaut connaître son vocabulaire…

 Lorsqu’un ordinateur traite du texte, du son, de l’image,

de la vidéo, il traite en réalité des informations binaires.

 Une information binaire ne peut avoir que deux états.

 Par exemple, (ouvert – fermé), (libre – occupé), (blanc – noir),
(vrai – faux), (chargé – non chargé), (haut – bas), (troué – non
troué), etc.
 La mémoire vive (RAM) est formée de millions de composants
électroniques qui peuvent retenir ou relâcher une charge
électrique.
 La surface d’un disque dur, d’une bande ou d’une disquette est
recouverte de particules métalliques qui peuvent, grâce à un
aimant, être orientées dans un sens ou dans l’autre.

! bisgambiglia@[Link] 5
 Le Codage de l’information
Circuit et Logique (1/4)

 Nous représentons par une variable booléenne x dans

{0,1} le passage d’un courant électrique.
 Lorsque x = 0, nous dirons que x est à l’état 0 (le courant
ne passe pas)

 Lorsque x = 1, nous dirons que x est à l’état 1 (le courant

passe)

 Une telle variable booléenne permet ainsi de visualiser,

sous forme d’un bit d’information (0,1) le comportement
d’un composant physique laissant ou ne laissant pas passer
le courant.
bisgambiglia@[Link] 6
Le Codage de l’information
Circuit et Logique (2/4)

bisgambiglia@[Link] 7
Le Codage de l’information
Circuit et Logique (3/4)

bisgambiglia@[Link] 8
Le Codage de l’information
Circuit et Logique (4/4)

bisgambiglia@[Link] 9
 Le Codage de l’information
Code binaire (1/3)

Les ordinateurs ont été conçus pour manier ces

informations par paquets de 0 et de 1. Et la taille de
ces paquets a été fixée à 8 informations binaires.

 Chaque bit de l’octet (8) peut occuper deux états. Il y

a donc dans un octet : 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 =
28 = 256 possibilités
 Cela signifie qu’un octet peut servir à coder 256
nombres différents : ce peut être la série des nombres
entiers de 1 à 256, ou de 0 à 255, ou de –127 à +128.
! bisgambiglia@[Link] 10
 Le Codage de l’information
Code binaire (2/3)

Exemple :
11010011
1 1 0 1 0 0 1 1
1 * 27 + 1 * 26 + 0*25 + 1 * 24 + 0*23 + 0*22 + 1 * 21 + 1 * 20 =
1 * 128 + 1 * 64 + 1 * 16 + 1 * 2 + 1 * 1 =
128 + 64 + 16 + 2 + 1 =
=> 211

bisgambiglia@[Link] 11
 Le Codage de l’information
Code binaire (3/3)

Exemple :
186.
Dans 186, on trouve 1 x 128, soit 1 * 27. Je retranche 128 de 186 et j’obtiens
58.
186 = 128 + 58 ou 128 = 186 – 58
186 = 1 x 128, soit 1 * 27
58 = 0 * 64, soit 0 * 26
58 = 1 * 32, soit 1 * 25 Je retranche 32 de 58 et j’obtiens 26.
26 = 1 * 16, soit 1 * 24 Je retranche 16 de 26 et j’obtiens 10.
10 = 1 * 8, soit 1 * 23 Je retranche 8 de 10 et j’obtiens 2.
2 = 0 * 4, soit 0 * 22
2 = 1 * 2, soit 0 * 21 Je retranche 2 de 2 et j’obtiens 0.
0 = 0 * 1, soit 0 * 20
Il ne me reste plus qu’à reporter ces différents résultats (dans l’ordre !) pour
reconstituer l’octet. J’écris alors qu’en binaire, 186 est représenté par :
10111010

bisgambiglia@[Link] 12
 Le Codage de l’information
Exercices

 Convertir en base
binaire
10
2
11111111
10
11101001
355
00110011
1087
11001100
255
00011100
8000
00111100
L’alphabet !
00001000

bisgambiglia@[Link] 13
 Sources

 Informatique : le matériel - Ordinateur,

circuits, codage, système, réseau. Cours
informatique programmation Rm di Scala -
[Link]

 [Link]

bisgambiglia@[Link] 14
 Sommaire

1. Rappels : Le Codage de l’information (2h)

2. Algorithmique (13h)
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 15
 Sommaire

1. Rappels : Le Codage de l’information (2h)

2. Algorithmique (13h)
1. Introduction
2. Les variables
3. Lecture et Ecriture
4. Structures conditionnelles
5. Logique
6. Boucles
7. Tableaux
8. Procédures et Fonctions
9. Récursivité
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 16
 Algorithmique
La raison d’être d’un algorithme est de résoudre un problème !

 Avez-vous déjà indiqué un chemin à un touriste

égaré ? Avez vous fait chercher un objet à quelqu’un
par téléphone ? Ecrit une lettre anonyme stipulant
comment procéder à une remise de rançon ? Si oui,
vous avez déjà fabriqué – et fait exécuter – des
algorithmes !

 Un algorithme, c’est une suite d’instructions, qui une fois

exécutée correctement, conduit à un résultat donné.
 Pour fonctionner, un algorithme doit contenir uniquement
des instructions compréhensibles par celui qui devra
l’exécuter.
! bisgambiglia@[Link] 17
 Algorithmique
Faut-il être matheux pour être bon en algorithmique ?

NON
« moi, de toute façon, je suis mauvais(e) en algo, j’ai
jamais rien pigé aux maths ».

 Faut-il être « bon en maths » pour expliquer

correctement son chemin à quelqu’un ?
 La maîtrise de l’algorithmique requiert plusieurs
qualités :
 intuition,
 méthode et
 Rigueur.

! bisgambiglia@[Link] 18
 Algorithmique
Astuce

Chaque fois qu’on écrit une série d’instructions qu’on

croit justes, il faut systématiquement se mettre
‘mentalement’ à la place de la machine qui va les
exécuter, armé d'un papier et d'un crayon, afin de
vérifier si le résultat obtenu est bien celui que l’on
voulait.
Cette opération ne requiert pas la moindre once
d’intelligence.
Mais elle reste néanmoins indispensable, si l’on ne
veut pas écrire à l’aveuglette.

bisgambiglia@[Link] 19
 Sommaire

1. Rappels : Le Codage de l’information (2h)

2. Algorithmique (13h)
1. Introduction
2. Les variables
3. Lecture et Ecriture
4. Structures conditionnelles
5. Logique
6. Boucles
7. Tableaux
8. Procédures et Fonctions
9. Récursivité
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 20
 Algorithmique
Introduction (1/4)

 Définitions :

1. Un algorithme est un ensemble de prescriptions

et de règles qui définissent « ce qu’il faut faire »
et « dans quel ordre » pour résoudre et problème

2. Procédé de calcul, série d'énoncés indiquant les

opérations à faire pour obtenir un certain résultat
recherché

bisgambiglia@[Link] 21
 Algorithmique
Introduction (2/4)

 Pourquoi apprendre l’algorithmique pour

apprendre à programmer ? En quoi a-t-on besoin
d’un langage spécial, distinct des langages de
programmation compréhensibles par les
ordinateurs ?

 L’algorithmique exprime les instructions résolvant un

problème donné indépendamment des particularités de
tel ou tel langage.
 Apprendre l’algorithmique, c’est apprendre à manier la
structure logique d’un programme informatique.
 Facilite l’apprentissage de nouveaux langages.
! bisgambiglia@[Link] 22
 Algorithmique
Introduction (3/4)

 Les ordinateurs, ne sont capables de comprendre

que 4 catégories d'ordres (en programmation on
emploiera le terme instructions).
 Ces quatre familles d'instructions sont :
 l’affectation de variables
 la lecture / écriture
 les tests
 les boucles

 Un algorithme informatique se ramène donc

toujours au bout du compte à la combinaison de ces
quatre petites briques de base.

! bisgambiglia@[Link] 23
 Algorithmique
Introduction (4/4)

 Avec quelles conventions écrit-on un

algorithme ?

 On utilise généralement une série de conventions

appelée «  pseudo-code », qui ressemble à un
langage de programmation authentique dont on
aurait évacué la plupart des problèmes de
syntaxe. Ce pseudo-code est susceptible de varier
légèrement d’un livre (ou d’un enseignant) à un
autre. Le pseudo-code est purement
conventionnel ; aucune machine n’est censée le
reconnaître.
bisgambiglia@[Link] 24
 Algorithmique
Exemple

Algorithme
Variable - ne : réel, note d'écrit (coefficient 2)
Variable - no : réel, note d'oral (coefficient 1)
Variable - moy : réel, moyenne du module
Début
ne ← lire()
no ← lire()
moy ← (2 * ne + no)/3
si moy >= 10 alors
écrire ("reçu")
sinon
écrire ("refusé")
Fin si
Fin

! bisgambiglia@[Link] 25
 Sommaire

1. Rappels : Le Codage de l’information (2h)

2. Algorithmique (13h)
1. Introduction
2. Les variables
3. Lecture et Ecriture
4. Structures conditionnelles
5. Logique
6. Boucles
7. Tableaux
8. Procédures et Fonctions
9. Récursivité
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 26
 Algorithmique
Les variables (1/8)

 Dans un programme, on va avoir en permanence

besoin de stocker des valeurs. Il peut s’agir de
données issues du disque dur, fournies par
l’utilisateur (frappées au clavier), de résultats
obtenus par le programme : intermédiaires ou
définitifs.

 Ces données peuvent être de plusieurs types

(numériques, textuelles, etc.).

 Dès que l’on a besoin de stocker une information au

cours d’un programme, on utilise une variable.
! bisgambiglia@[Link] 27
 Algorithmique
Les variables (2/8)

 Définitions :

 Les variables associent un nom (le symbole) à

une valeur ou un objet (aA prend 5).

 Pour employer une image, une variable est une

boîte, que le programme (l’ordinateur) va repérer
par une étiquette (un symbole aA). Pour avoir
accès au contenu de la boîte, il suffit de la
désigner par son étiquette.
! bisgambiglia@[Link] 28
 Algorithmique
Les variables (3/8)

 Déclaration des variables :

 La première chose à faire avant de pouvoir utiliser une
variable est de créer la boîte et de lui coller une
étiquette.

 Ceci se fait tout au début de l’algorithme, avant même les

instructions proprement dites. C’est ce qu’on appelle la
déclaration des variables.

 Un nom de variable peut comporter des lettres et des

chiffres, mais exclut la plupart des signes de ponctuation,
! bisgambiglia@[Link] 29
 Algorithmique
Les variables (4/8)

 Type des variables :

 Lorsqu’on déclare une variable, il ne suffit pas de créer
une boîte; encore doit-on préciser ce que l’on voudra
mettre dedans, car de cela dépendent la taille de la boîte
(de l’emplacement mémoire) et le type de codage utilisé.
 Type numérique
 Byte (octet)
 Entier Simple, Entier Long
 Réel Simple, Réel Long
 Type texte
 Caractère
 Chaîne de Caractères

! bisgambiglia@[Link] 30
 Algorithmique
Type numérique Plage
Byte (octet) 0 à 255
Entier Simple -32768 à 32767
Entier Long -2 147 483 648 à 2 147 483 647
-3,40x1038 à -1,40x10-45 pour les valeurs négatives
Réel simple
1,40x10-45 à 3,40x1038 pour les valeurs positives
1,79x10308 à -4,94x10-324 pour les valeurs négatives
Réel double
4,94x10-324 à 1,79x10308 pour les valeurs positives
Type Texte Exemple
Caractère ‘a’, ‘b’, ‘c’, ‘!’, ‘5’, ‘$’, etc.
Chaîne de Caractères
En pseudo-code, une chaîne de caractères‘aaa’, ‘bonjour’,notée
est toujours ‘tutu’,entre
‘123’,guillemets
etc.
Autres type Exemple
Booléen VRAI ou FAUX
Tableau [1,2,3,4,5]
Liste (1,2,3,4,5)

! bisgambiglia@[Link] 31
 Algorithmique
Astuce (1/2)

Pourquoi ne pas déclarer toutes les variables numériques en

réel double, histoire de bétonner et d’être certain qu’il n’y
aura pas de problème ?

En vertu du principe de l’économie de moyens. Un bon

algorithme ne se contente pas de « marcher » ; il marche en
évitant de gaspiller les ressources de la machine. Sur
certains programmes de grande taille, l’abus de variables
surdimensionnées peut entraîner des ralentissements
notables à l’exécution, voire un plantage pur et simple de
l’ordinateur. Alors, autant prendre dès le début de bonnes
habitudes.

bisgambiglia@[Link] 32
 Algorithmique
Astuce (2/2)

Le type booléen est très souvent négligé par les programmeurs, à tort.

Il est vrai qu'il n'est pas à proprement parler indispensable, et qu'on

pourrait écrire à peu près n’importe quel programme en l'ignorant
complètement. Pourtant, si le type booléen est mis à disposition des
programmeurs dans tous les langages, ce n'est pas pour rien. Le
recours aux variables booléennes s'avère très souvent un puissant
instrument de lisibilité des algorithmes : il peut faciliter la vie de
celui qui écrit l'algorithme, comme de celui qui le relit pour le
corriger.

Alors, maintenant, c'est certain, en algorithmique, il y a une question

de style : c'est exactement comme dans le langage courant, il y a
plusieurs manières de s'exprimer pour dire sur le fond la même
chose.

bisgambiglia@[Link] 33
 Algorithmique
Les variables (5/8)

 En algorithmique, on ne se tracassera pas trop avec

les sous-types de variables numériques. On se
contentera donc de préciser qu'il s'agit d'un nombre,
en gardant en tête que dans un vrai langage, il
faudra être plus précis.

 Exemple : En pseudo-code, une déclaration de

variables aura ainsi cette tête :

Variable g en Numérique
ou encore
Variables PrixHT, TauxTVA, PrixTTC en Numérique
bisgambiglia@[Link] 34
 Algorithmique
Les variables (6/8)

 L’instruction d’affectation ou initialisation

 La seule chose qu’on puisse faire avec une
variable, c’est l’affecter, c’est-à-dire lui attribuer
une valeur.
 En pseudo-code, l'instruction d'affectation se note
avec le signe ← (en C par exemple c’est le signe
=)
 Exemple : une instruction d’affectation
 maVariable ← 24 ne modifie que ce
 monNombre ← 11 qui est situé
à gauche de la flèche.
 maVariable ← monNombre
!  monNombre ← maVariable +6
bisgambiglia@[Link] 35
 Algorithmique
Exemple d’affectation de variables

Exemple n°1 Exemple n°2

Début Début
Riri ← "Loulou" Riri ← "Loulou"
Fifi ← "Riri" Fifi ← Riri
Fin Fin

La seule différence entre les deux algorithmes consiste

dans la présence ou dans l’absence des guillemets lors de la seconde affectation.
Et l'on voit que cela change tout !

bisgambiglia@[Link] 36
 Algorithmique
Exercices (1/3)

 Exercice 1.1 : Quelles  Exercice 1.2 : Quelles

seront les valeurs des seront les valeurs des
variables A et B après variables A, B et C après
exécution des exécution des
instructions suivantes ? instructions suivantes ?
Variables A, B, C en Entier
Variables A, B en Entier Début
Début A←5
A←1 B←3
B←A+3 C←A+B
A←3 A←2
Fin C←B–A
Fin
bisgambiglia@[Link] 37
 Algorithmique
Correction et trace d’algo.

 Exercice 1.2 : Quelles

seront les valeurs des
variables A, B et C après
exécution des
instructions suivantes ?
Variables A, B, C en Entier
Début Après         La valeur des variables est :
A←5 A←5 A = 5          B = ?           C = ?
B←3 B←3 A = 5          B = 3           C = ?
C←A+B C ← A + B A = 5          B = 3           C = 8
A←2 A←2 A = 2          B = 3           C = 8
C←B–A C ← B – A A = 2         B = 3          C = 1
Fin
bisgambiglia@[Link] 38
 Algorithmique
Exercices (2/3)

 Exercice 1.3 : Quelles  Exercice 1.4 : Quelles

seront les valeurs des seront les valeurs des
variables A et B après variables A, B et C après
exécution des exécution des
instructions suivantes ? instructions suivantes ?
Variables A, B, C en Entier
Variables A, B en Entier Début
Début A←3
A←5 B ← 10
B←A+4 C←A+B
A←A+1
B←A+B
B←A–4
A←C
Fin Fin
bisgambiglia@[Link] 39
 Algorithmique
Exercices (3/3)

 Exercice 1.5 : Quelles  Exercice 1.6 : Plus difficile, mais

c’est un classique absolu, qu’il faut
seront les valeurs des absolument maîtriser : écrire un
variables A et B après algorithme permettant d’échanger les
exécution des valeurs de deux variables A et B, et
instructions suivantes ? ce quel que soit leur contenu
préalable.

Variables A, B en Entier
 Exercice 1.7 : Une variante du
Début
A←5 précédent : on dispose de trois
B←2 variables A, B et C. Ecrivez un
A←B algorithme transférant à B la valeur
B←A de A, à C la valeur de B et à A la
Fin valeur de C (toujours quels que
soient les contenus préalables de ces
bisgambiglia@[Link] 40
 Algorithmique
Variables (7/8)

 Expressions et opérateurs
 Pour qu’une instruction d’affectation soit valide, on
doit trouver :

 à gauche de la flèche, un nom de variable ;

 à droite de la flèche, ce qu’on appelle une expression. Une

expression est un ensemble de valeurs, reliées par des
opérateurs, et équivalent à une seule valeur;

 l’expression située à droite de la flèche doit du même type

que la variable située à gauche.
! bisgambiglia@[Link] 41
 Algorithmique
Variables (8/8)

 Expressions et opérateurs
 Un opérateur est un signe qui relie deux valeurs,
pour produire un résultat.
 Opérateurs numériques : Ce sont les opérations
arithmétiques tout ce qu’il y a de classique.
 + : addition
 - : soustraction
 * : multiplication
 / : division
 ^ : puissance (45 au carré s’écrira donc 45 ^ 2).
 Opérateur alphanumérique ou de concaténation (&)
 Opérateurs logiques (ou booléens) (et, ou, non, xor)

bisgambiglia@[Link] 42
 Algorithmique
Exercices

 Exercice 1.8 : Que  Exercice 1.9 : Que

produit l’algorithme produit l’algorithme
suivant ? suivant ?

Variables A, B, C en Variables A, B, C en
Caractères
Caractères
Début
Début
A ← "423"
B ← "12" A ← "423"
C←A+B B ← "12"
Fin C←A&B
Fin
bisgambiglia@[Link] 43
 Algorithmique
Remarques

 En mathématiques, une « variable » est généralement une

inconnue, qui recouvre un nombre non précisé de valeurs.

 En informatique, une variable possède à un moment donné une

valeur et une seule, cette valeur ne « varie » pas ou du moins
elle varie que lorsqu’elle est l’objet d’une instruction
d’affectation.
 Signe de l’affectation en algorithmique ← ; la quasi totalité
des langages emploient le signe égal =.
Et là, pour les débutants, la confusion avec les maths est
également facile. En maths, A = B et B = A sont deux
propositions équivalentes. En informatique, non, puisque cela
revient à écrire A ← B et B ← A, deux choses bien différentes.
De même, A = A + 1, qui en mathématiques, constitue une
équation sans solution, représente en programmation une
action tout à fait licite.
bisgambiglia@[Link] 44
 Sommaire

1. Rappels : Le Codage de l’information (2h)

2. Algorithmique (13h)
1. Introduction
2. Les variables
3. Lecture et Ecriture
4. Structures conditionnelles
5. Logique
6. Boucles
7. Tableaux
8. Procédures et Fonctions
9. Récursivité
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 45
 // En C
#include <stdio.h>
Algorithmique #include <stdlib.h>
int main(int argc, char *argv[])
{
Exemple
int ne; // note d'écrit (coefficient 2)
Algorithme int no; // note oral (coefficient 1)
Variable - ne : réel, note d'écrit int moy; // note moyenne
(coefficient 2) printf("Saisir la note écrit \t");
Variable - no : réel, note d'oral scanf("%d",&ne);
(coefficient 1) printf("Saisir la note oral \t");
Variable - moy : réel, moyenne du scanf("%d",&no);
module
moy = (ne*2+no)/3;
Début
if (moy >= 10)
ne ← lire()
{
no ← lire()
printf("reçu \n");
moy ← (2 * ne + no)/3
}
si moy >= 10 alors
else
écrire ("reçu")
{
sinon
printf("refusé \n");
écrire ("refusé")
}
Fin si
system("PAUSE");
Fin
return 0;
}

bisgambiglia@[Link] 46
 Algorithmique
Lecture et Ecriture (1/2)

 Comment dialoguer avec l’ordinateur ?

 ilQuand
existe des d’instructions pour permettre à la
l’utilisateur doit écrire au clavier, on appelle ça la lecture,
machine
et quanddeildialoguer aveconl’utilisateur
doit lire sur l’écran :
appelle çà l’écriture,
un algorithme est une suite d’instructions qui programme la machine, pas l’utilisateur !
 Dans un sens, ces instructions permettent à l’utilisateur
Donc quand on dit à la machine de lire une valeur,
de
celarentrer
implique des valeurs au
que l’utilisateur clavier
va devoir pour
écrire cettequ’elles
valeur. soient
Et quand on
utilisées pardemande à la machine d’écrire
le programme. Cetteuneopération
valeur, est la
c’est pour que l’utilisateur puisse la lire.
lecture.
Lecture etDans
écriturel’autre
sont doncsens, d’autres
des termes instructions
qui comme toujours enpermettent au
programmation,
doivent être compris du point de vue de la machine qui sera chargée de les exécuter.
programme de communiquer des valeurs à l’utilisateur
en les affichant à l’écran. Cette opération est l’écriture.

! bisgambiglia@[Link] 47
 Algorithmique
Lecture et Ecriture (2/2)

 Les instructions de lecture et d’écriture :

 Pour lire on utilise l’instruction Lire
 Dès que le programme rencontre une instruction Lire,
l’exécution s’interrompt, attendant la frappe d’une
valeur au clavier. Aussitôt que la touche Entrée (Enter)
a été frappée, l’exécution reprend.
 Pour écrire en utilise l’instruction Ecrire
 Exemple :
Variable nom en chaîne de caractères
Ecrire “Entrer votre nom“
Lire nom
Ecrire “Bonjour”&nom
! bisgambiglia@[Link] 48
 Algorithmique
Exercices

 Exercice 2.1: Quel résultat  Exercice 2.2 : Ecrire un programme

produit le programme qui demande un nombre à
suivant ? l’utilisateur, puis qui calcule et
affiche le carré de ce nombre.
Variables val, double numériques
Début
 Exercice 2.3 : Ecrire un programme
Val ← 231
Double ← Val * 2 qui lit le prix HT d’un article, le
Ecrire Val nombre d’articles et le taux de TVA,
Ecrire Double et qui fournit le prix total TTC
Fin
correspondant. Faire en sorte que des
libellés apparaissent clairement. 

bisgambiglia@[Link] 49
 Sommaire

1. Rappels : Le Codage de l’information (2h)

2. Algorithmique (13h)
1. Introduction
2. Les variables
3. Lecture et Ecriture
4. Structures conditionnelles
5. Logique
6. Boucles
7. Tableaux
8. Procédures et Fonctions
9. Récursivité
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 50
 Algorithmique
Exemple

Algorithme """ Python """

Variable - ne : réel, note d'écrit # -*- coding: cp1252 -*-
(coefficient 2) def moyenne():
Variable - no : réel, note d'oral """ fonction qui calcule la moyenne
(coefficient 1) ne => note d'écrit (coefficient 2)
Variable - moy : réel, moyenne du no => note oral (coefficient 1)
module moy=> note moyenne
Début """
ne ← lire() print "Saisir la note écrit"
no ← lire() ne = input()
moy ← (2 * ne + no)/3 print "Saisir la note oral"
si moy >= 10 alors no = input()
écrire ("reçu") moy = (ne*2+no)/3
sinon if moy >= 10:
écrire ("refusé") print "reçu"
Fin si else:
Fin print "refusé"

bisgambiglia@[Link] 51
 Algorithmique
Structures conditionnelles (1/15)

 Définitions :
 On appelle structure conditionnelle les
instructions qui permettent de tester si une
condition est vraie ou non ;
 On entend par structure conditionnelle, la
possibilité d'orienter un algorithme en fonction de
choix particuliers ;
 Une structure conditionnelle permet d'influer sur
le déroulement du programme, suivant certains
conditions.
! bisgambiglia@[Link] 52
 Algorithmique
Structures conditionnelles (2/15)

 Structure de tests
Si condition alors
Instruction
FinSi

 Une condition est un test ou un choix sur une ou

plusieurs variables : a > b, a=5, b<=12, a=2 et b=6
Si condition alors
Instruction 1
Sinon
Instruction 2
FinSi

 Une instruction est le code à exécuter si la

condition est vérifiée.
! bisgambiglia@[Link] 53
 Algorithmique
Structures conditionnelles (3/15)

 Exemples :
si moy >= 10 alors
écrire ("reçu")
sinon
écrire ("refusé")
Fin si

si maSommedArgent >= prixDuCafé alors

j’achète un café
je le bois
sinon
je taxe un copain
Fin si

bisgambiglia@[Link] 54
 Algorithmique
Structures conditionnelles (4/15)

 Qu’est ce qu’une condition ?

 Une condition est une comparaison
 Elle est composée de trois parties :
1. Une variable : a
2. Un opérateur de comparaison : <,>,=, ≠, ≤, ≤
3. Une autre variable : b
 Les opérateurs de comparaison sont :
 Égal à (= en algo), (== en C)
 Différent de (≠ en algo), (!= en C)
 Strictement plus petit que (< en algo et en C)
 Strictement plus grand que (> en algo et en C)
 Plus petit ou égal à (≤ en algo), (<= en C)
 Plus grand ou égal à (≤ en algo), (>= en C)

bisgambiglia@[Link] 55
 Algorithmique
Remarques

 « Toto est compris entre 5 et 8 ». On peut être tenté de la

traduire par : 5 < Toto < 8
Or, une telle expression, qui a du sens en français, comme en
mathématiques, mais ne veut rien dire en programmation.
En effet, elle comprend deux opérateurs de comparaison, soit
un de trop, et trois valeurs, soit là aussi une de trop.

 A noter que les opérateurs de comparaison peuvent tout à fait

s’employer avec des caractères.

"t " < " w "               VRAI

" Maman " > " Papa «  FAUX
" maman " > " Papa "   VRAI

bisgambiglia@[Link] 56
 Algorithmique
Structures conditionnelles (5/15)

 Conditions composées
 Association de conditions grâce à des opérateurs logique :
(ET, OU, NON, XOR)
’’’ EXEMPLE
si maSommedArgent >= prixDuCafé OU qu’un copain m’invite alors
je bois le café
Fin si

 ET : pour que "Condition1 ET Condition2" soit VRAI, il faut

impérativement que Condition1 soit VRAI et que Condition2
soit VRAI. Dans tous les autres cas le test sera faux.
 OU : pour que "Condition1 OU Condition2" soit VRAI, il
suffit que Condition1 soit VRAIE ou que Condition2 soit
VRAIE.
! bisgambiglia@[Link] 57
 Algorithmique
Structures conditionnelles (6/15)

 Conditions composées
 A et B deux variables
 Opérateur ET

ET A est Vrai A est Faux

B est Vrai Vrai Faux

B est Faux Faux Faux

bisgambiglia@[Link] 58
 Algorithmique
Structures conditionnelles (7/15)

 Conditions composées
 A et B deux variables
 Opérateur OU

OU A est Vrai A est Faux

B est Vrai Vrai Vrai

B est Faux Vrai Faux

bisgambiglia@[Link] 59
 Algorithmique
Structures conditionnelles (8/15)

 Conditions composées
 A et B deux variables
 Opérateur XOR

XOR A est Vrai A est Faux

B est Vrai Faux Vrai

B est Faux Vrai Faux

bisgambiglia@[Link] 60
 Algorithmique
Structures conditionnelles (9/15)

 Conditions composées
 A une variable
 Opérateur NON

NON A est Vrai A est Faux

Faux Vrai

bisgambiglia@[Link] 61
 Algorithmique
Exercices

 Exercice 3.1 : Ecrire un algorithme qui demande un nombre à

l’utilisateur, et l’informe ensuite si ce nombre est positif ou
négatif (on laisse de côté le cas où le nombre vaut zéro).

 Exercice 3.2 : Ecrire un algorithme qui demande deux

nombres à l’utilisateur et l’informe ensuite si leur produit est
négatif ou positif (on laisse de côté le cas où le produit est
nul). Attention toutefois : on ne doit pas calculer le produit des
deux nombres.

 Exercice 3.3 : Ecrire un algorithme qui demande trois noms à

l’utilisateur et l’informe ensuite s’ils sont rangés ou non dans
l’ordre alphabétique.

bisgambiglia@[Link] 62
 Algorithmique
Structures conditionnelles (10/15)

 Tests imbriqués : exemple t°c

Variable Temp en Entier Variable Temp en Entier
Début Début
Ecrire "Entrez la t°C de l’eau :" Ecrire "Entrez la t°c de l’eau :"
Lire Temp Lire Temp
Si Temp =< 0 Alors Si Temp =< 0 Alors
  Ecrire "C’est de la glace"   Ecrire "C’est de la glace"
FinSi Sinon
Si Temp > 0 Et Temp < 100 Alors   Si Temp < 100 Alors
  Ecrire "C’est du liquide"     Ecrire "C’est du liquide"
Finsi   Sinon
Si Temp > 100 Alors     Ecrire "C’est de la vapeur"
  Ecrire "C’est de la vapeur"   Finsi
Finsi Finsi
Fin Fin

! bisgambiglia@[Link] 63
 Algorithmique
Structures conditionnelles (11/15)

 Tests imbriqués : trace d’algo. I

Ecrire "C’est de la glace"
Si Temp =< 0

Ecrire "C’est du liquide"

Si Temp > 0 Et
Temp < 100 Alors

Ecrire "C’est de la vapeur"

Si Temp > 100

bisgambiglia@[Link] 64
 Algorithmique
Structures conditionnelles (12/15)

 Tests imbriqués : trace d’algo. II

Ecrire "C’est de la glace"

Si Temp =< 0 Ecrire "C’est du liquide"
Si Temp < 100

Ecrire "C’est de la vapeur"

bisgambiglia@[Link] 65
 Algorithmique
Exercices
 Exercice 3.4 : Ecrire un algorithme qui demande un nombre à l’utilisateur,
et l’informe ensuite si ce nombre est positif ou négatif (on inclut cette fois
le traitement du cas où le nombre vaut zéro).

 Exercice 3.5 : Ecrire un algorithme qui demande deux nombres à

l’utilisateur et l’informe ensuite si le produit est négatif ou positif (on
inclut cette fois le traitement du cas où le produit peut être nul). Attention
toutefois, on ne doit pas calculer le produit !

 Exercice 3.6 : Ecrire un algorithme qui demande l’âge d’un enfant à

l’utilisateur. Ensuite, il l’informe de sa catégorie :
 "Poussin" de 6 à 7 ans
 "Pupille" de 8 à 9 ans
 "Minime" de 10 à 11 ans
 "Cadet" après 12 ans
Peut-on concevoir plusieurs algorithmes équivalents menant à ce résultat ?

bisgambiglia@[Link] 66
 Algorithmique
Structures conditionnelles (13/15)

 Représentation graphique :
Instruction 1

si

Instruction 3 Fin si

si
Instruction 2

 Dans le cas de tests imbriqués, le Sinon et le Si

peuvent être fusionnés en un SinonSi. On considère
alors qu’il s’agit d’un seul bloc de test, conclu par un
seul FinSi
bisgambiglia@[Link] 67
 Algorithmique
Structures conditionnelles (14/15)

 Tests imbriqués : Avec SinonSi

Variable Temp en Entier Variable Temp en Entier
Début Début
Ecrire "Entrez la t°c de l’eau :" Ecrire "Entrez la t°c de l’eau :"
Lire Temp Lire Temp
Si Temp =< 0 Alors Si Temp =< 0 Alors
  Ecrire "C’est de la glace"   Ecrire "C’est de la glace"
Sinon SinonSi Temp < 100 Alors
  Si Temp < 100 Alors   Ecrire "C’est du liquide"
    Ecrire "C’est du liquide" Sinon
  Sinon   Ecrire "C’est de la vapeur"
    Ecrire "C’est de la vapeur" Finsi
  Finsi g
Finsi
Fin

bisgambiglia@[Link] 68
 Algorithmique
Structures conditionnelles (15/15)

 Variables booléennes :
 type de variables susceptibles Variable Temp en Entier
de stocker les valeurs VRAI Variables A, B en Booléen
ou FAUX; Début
Ecrire "Entrez la t°c de l’eau :"
 une variable booléenne n’a
Lire Temp
besoin que d’un seul bit pour
A ← Temp =< 0
être stockée;
B ← Temp < 100
 dans certains cas, notamment Si A Alors
celui de conditions composées   Ecrire "C’est de la glace"
très lourdes (avec plein de ET SinonSi B Alors
et de OU) cette technique peut   Ecrire "C’est du liquide"
faciliter le travail du Sinon
programmeur, en améliorant   Ecrire "C’est de la vapeur"
nettement la lisibilité de Finsi
l’algorithme. Fin

bisgambiglia@[Link] 69
 Algorithmique
Exercice

Algorithme
 Exercice : Améliorer cet algorithme pour prendre en compte
Variable - ne : réel,de
les moyennes note d'écrit (coefficient
rattrapage : 2)
Variable - no : réel, note d'oral (coefficient 1)
Variable - moy : réel, moyenne du module
 Moyenne >= 10
Début
 « reçu »
ne ← lire()
← Moyenne
no  lire() entre 8 et 10
moy ← (2« rattrapage »
* ne + no)/3
si moy >= 10 alors
 Moyenne <8
écrire ("reçu")»
 «  refusé
sinon
écrire ("refusé")
Fin si
Fin

bisgambiglia@[Link] 70
 Sommaire

1. Rappels : Le Codage de l’information (2h)

2. Algorithmique (13h)
1. Introduction
2. Les variables
3. Lecture et Ecriture
4. Structures conditionnelles
5. Logique
6. Boucles
7. Tableaux
8. Procédures et Fonctions
9. Récursivité
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 71
 Algorithmique
Exemple
// En C++
Algorithme #include <cstdlib>
Variable - ne : réel, note d'écrit #include <iostream>
(coefficient 2) using namespace std;
Variable - no : réel, note d'oral int main(int argc, char *argv[]){
(coefficient 1) int ne, no, moy;
Variable - moy : réel, moyenne du cout << "Saisir la note écrit" << endl;
module
cin >> ne;
Début
cout << "Saisir la note oral" << endl;
ne ← lire()
cin >> no;
no ← lire()
moy = (ne*2+no)/3;
moy ← (2 * ne + no)/3
if (moy >=10) {
si moy >= 10 alors
cout << "reçu" << endl;
écrire ("reçu")
}else{
sinonSi moy >= 8 ET moy<10
if(moy>8 && moy<10){
écrire ("rattrapage")
cout << "rattrapage" << endl;
sinon
}else
écrire ("refusé")
cout << "redoublement" << endl;
Finsi
}
Fin
system("PAUSE");
return EXIT_SUCCESS; }

bisgambiglia@[Link] 72
 Algorithmique
Logique (ET et/ou OU) (1/3)

 Test :
Variables A, B, C, D, E en Booléen
Variable X en Entier
Que renvoie cet algo. ?
Début Quelles sont les valeurs de A,
Lire X B, C, D et E pour X ← 3, X
A ← X > 12
B←X>2
← 14 ?
C←X<6
D ← (A ET B) OU C
E ← Dans
A ET (B
uneOU C)
condition composée employant à la fois des opérateurs ET et
Ecrire D, E des opérateurs OU,
Fin la présence de parenthèses possède une influence sur le résultat,
tout comme dans le cas d’une expression numérique
comportant des multiplications et des additions.

! bisgambiglia@[Link] 73
 Algorithmique
Logique (ET et/ou OU) (2/3)

 Test :
Si il fait trop chaud ET il ne pleut pas Alors
  Ouvrir la fenêtre
Sinon Toute structure de test requérant une condition composée
  Fermer lafaisant
fenêtreintervenir l’opérateur ET peut être exprimée
Finside manière équivalente avec un opérateur OU, et réciproquement.
Règle de transformation de Morgan :
Quelle estSi la différence entre ces deux algo. ?
A ET B Alors I1 Sinon I2 FinSi

Ces deux formulations sont strictement équivalentes
Si NON A OU NON B Alors I2 Sinon I1 FinSi
Si il ne fait pas trop chaud OU il pleut Alors
  Fermer la fenêtre
Sinon
  Ouvrir la fenêtre
Finsi
! bisgambiglia@[Link] 74
 Algorithmique
Exercices (1/5)
 Exercice 4.1 : Formulez un algorithme équivalent à l’algorithme suivant :

Si Tutu > Toto + 4 OU Tata = "OK" Alors

  Tutu ← Tutu + 1
Sinon
  Tutu ← Tutu – 1
Finsi

 Exercice 4.2 : Cet algorithme est destiné à prédire l'avenir, et il doit être
infaillible !
Il lira au clavier l’heure et les minutes, et il affichera l’heure qu’il sera une
minute plus tard. Par exemple, si l'utilisateur tape 21 puis 32, l'algorithme
doit répondre :
"Dans une minute, il sera 21 heure(s) 33".
NB : on suppose que l'utilisateur entre une heure valide. Pas besoin donc de la
vérifier.

bisgambiglia@[Link] 75
 Algorithmique
Exercices (2/5)
 Exercice 4.3 : De même que le précédent, cet algorithme doit demander une heure
et en afficher une autre. Mais cette fois, il doit gérer également les secondes, et
afficher l'heure qu'il sera une seconde plus tard.
Par exemple, si l'utilisateur tape 21, puis 32, puis 8, l'algorithme doit répondre : "Dans
une seconde, il sera 21 heure(s), 32 minute(s) et 9 seconde(s)".
NB : là encore, on suppose que l'utilisateur entre une date valide.

 Exercice 4.4 : Un magasin de reprographie facture 0,10 E les dix premières

photocopies, 0,09 E les vingt suivantes et 0,08 E au-delà. Ecrivez un algorithme qui
demande à l’utilisateur le nombre de photocopies effectuées et qui affiche la facture
correspondante.

 Exercice 4.5 : Les habitants de Zorglub paient l’impôt selon les règles suivantes :
 les hommes de plus de 20 ans paient l’impôt
 les femmes paient l’impôt si elles ont entre 18 et 35 ans
 les autres ne paient pas d’impôt
Le programme demandera donc l’âge et le sexe du Zorglubien, et se prononcera donc
ensuite sur le fait que l’habitant est imposable.

bisgambiglia@[Link] 76
 Algorithmique
Logique (ET et/ou OU) (3/3)

 Style: Il n’y a jamais une seule manière juste de traiter les

structures alternatives. Entre les différentes possibilités, qui ne
sont parfois pas meilleures les unes que les autres, le choix est
une affaire de style.
 On peut très bien remplacer les booléens (ET, OU) par des
tests imbriqués (Si, SinonSi) :

Si il fait trop chaud ET il ne pleut Si il fait trop chaud Alors

pas Dans
Alors une structure alternative complexe,
  Si il neles conditions
pleut composées,
pas Alors
  l’imbrication
Ouvrir la fenêtredes structures de tests et   l’emploi
Ouvrir la des variables booléennes
fenêtre
Sinon ouvrent la possibilité de choix stylistiques différents.
  Sinon
  FermerL’alourdissement
la fenêtre    allège
des conditions Fermer leslastructures
fenêtre de tests
Finsi   Finsinécessaires ;
et le nombre des booléens
l’emploi de booléens supplémentaires Sinon
permet d’alléger les conditions
  Fermer la fenêtre
et les structures de tests, et ainsi de suite.
Finsi
! bisgambiglia@[Link] 77
 Algorithmique
Exercices (3/5)
 Exercice 4.6 : Les élections législatives, en Guignolerie Septentrionale,
obéissent à la règle suivante :
 lorsque l'un des candidats obtient plus de 50% des suffrages, il est élu dès le
premier tour.
 en cas de deuxième tour, peuvent participer uniquement les candidats ayant
obtenu au moins 12,5% des voix au premier tour.
 Vous devez écrire un algorithme qui permette la saisie des scores de quatre
candidats au premier tour. Cet algorithme traitera ensuite le candidat
numéro 1 (et uniquement lui) : il dira s'il est élu, battu, s'il se trouve en
ballottage favorable (il participe au second tour en étant arrivé en tête à
l'issue du premier tour) ou défavorable (il participe au second tour sans
avoir été en tête au premier tour).
 Astuce : il ne faut pas oublier que le candidat peut très bien avoir eu 20 %
mais être tout de même éliminé, tout simplement parce que l'un des autres
a fait plus de 50 % !
 Moralité : ne jamais se jeter sur la programmation avant d'avoir
soigneusement mené l'analyse du problème à traiter.

bisgambiglia@[Link] 78
 Algorithmique
Exercices (3/5)
 Correction 4.6 :
Variables A, B, C, D en Numérique
Début
Ecrire "Entrez les scores des quatre prétendants :« 
Lire A, B, C, D
C1 ← A > 50
C2 ← B > 50 ou C > 50 ou D > 50
C3 ← A >= B et A >= C et A >= D
C4 ← A >= 12,5
Si C1 Alors
  Ecrire “Elu au premier tour« 
Sinonsi C2 ou Non(C4) Alors
  Ecrire “Battu, éliminé, sorti !!!”
SinonSi C3 Alors
  Ecrire "Ballotage favorable« 
Sinon
  Ecrire "Ballotage défavorable« 
FinSi
Fin
bisgambiglia@[Link] 79
 Algorithmique
Exercices (4/5)
 Exercice 4.7 : Une compagnie d'assurance automobile propose à ses clients quatre
familles de tarifs identifiables par une couleur, du moins au plus onéreux : tarifs
bleu, vert, orange et rouge. Le tarif dépend de la situation du conducteur :
 un conducteur de moins de 25 ans et titulaire du permis depuis moins de deux
ans, se voit attribuer le tarif rouge, si toutefois il n'a jamais été responsable
d'accident. Sinon, la compagnie refuse de l'assurer.
 un conducteur de moins de 25 ans et titulaire du permis depuis plus de deux
ans, ou de plus de 25 ans mais titulaire du permis depuis moins de deux ans a
le droit au tarif orange s'il n'a jamais provoqué d'accident, au tarif rouge pour
un accident, sinon il est refusé.
 un conducteur de plus de 25 ans titulaire du permis depuis plus de deux ans
bénéficie du tarif vert s'il n'est à l'origine d'aucun accident et du tarif orange
pour un accident, du tarif rouge pour deux accidents, et refusé au-delà
 De plus, pour encourager la fidélité des clients acceptés, la compagnie propose
un contrat de la couleur immédiatement la plus avantageuse s'il est entré dans
la maison depuis plus d'un an.
 Ecrire l'algorithme permettant de saisir les données nécessaires (sans contrôle de
saisie) et de traiter ce problème. Avant de se lancer à corps perdu dans cet exercice,
on pourra réfléchir un peu et s'apercevoir qu'il est plus simple qu'il n'en a l'air (cela
s'appelle faire une analyse !)

bisgambiglia@[Link] 80
 Algorithmique
Exercices (5/5)
 Exercice 4.8 : Ecrivez un algorithme qui a près avoir demandé un numéro
de jour, de mois et d'année à l'utilisateur, renvoie s'il s'agit ou non d'une
date valide.
 Cet exercice est certes d’un manque d’originalité affligeant, mais après
tout, en algorithmique comme ailleurs, il faut connaître ses classiques ! Et
quand on a fait cela une fois dans sa vie, on apprécie pleinement
l’existence d’un type numérique « date » dans certains langages…).
 Il n'est sans doute pas inutile de rappeler rapidement que le mois de février
compte 28 jours, sauf si l’année est bissextile, auquel cas il en compte 29.
L’année est bissextile si elle est divisible par quatre. Toutefois, les années
divisibles par 100 ne sont pas bissextiles, mais les années divisibles par
400 le sont. Ouf !
 Un dernier petit détail : vous ne savez pas, pour l’instant, exprimer
correctement en pseudo-code l’idée qu’un nombre A est divisible par un
nombre B. Aussi, vous vous contenterez d’écrire en bons télégraphistes
que A divisible par B se dit « A dp B ».

bisgambiglia@[Link] 81
 Sommaire

1. Rappels : Le Codage de l’information (2h)

2. Algorithmique (13h)
1. Introduction
2. Les variables
3. Lecture et Ecriture
4. Structures conditionnelles
5. Logique
6. Boucles
7. Tableaux
8. Procédures et Fonctions
9. Récursivité
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 82
 // En C#
using System;

Algorithmique
using [Link];
using [Link];
namespace ConsoleApplication1
{
Exemple
class Program
{
Algorithme static void Main(string[] args)
Variable - ne : réel, note d'écrit {
int ne, no, moy;
(coefficient 2) string userEntry = "";
Variable - no : réel, note d'oral bool IsOk = false;
(coefficient 1) do
Variable - moy : réel, moyenne du {
module [Link]("Saisir la note écrit.");
userEntry = [Link]();
Début IsOk = [Link](userEntry, out ne);
ne ← lire() [Link]("Saisir la note oral.");
no ← lire() userEntry = [Link]();
IsOk = [Link](userEntry, out no);
moy ← (2 * ne + no)/3 } while (!IsOk);
si moy >= 10 alors moy = (ne * 2 + no) / 3;
écrire ("reçu") if (moy >= 10){
[Link]("reçu");
sinonSi moy >= 8 ET moy<10 }else{
écrire ("rattrapage") if (moy > 8 & moy < 10){
sinon [Link]("rattrapage");
}else
écrire ("refusé") [Link]("redoublement");
Finsi }
Fin }
}
}

bisgambiglia@[Link] 83
 Algorithmique
Les Boucles (1/8)
Algorithme
 Exercice : Améliorer cet algorithme pour prendre en compte
Variable - ne : réel, note d'écrit (coefficient 2)
une -erreur
Variable no : réel,de
notel’utilisateur (contrôle
d'oral (coefficient 1) de saisie ), il ne doit
pouvoir
Variable - moysaisir
: réel, que desdu
moyenne notes
module comprises entre 0 et 20.
Début
 Si il commet une erreur, à l’aide :
ne ← lire()
 d’un test, redemandez lui de saisir la note erronée.
no ← lire()
moy←d’une
(2 * neboucle,
+ no)/3redemandez lui de saisir la note erronée.
si moy >= 10 alors
écrire ("reçu")
sinon si moy > 8 et moy < 10
écrire ("rattrapage")
sinon
écrire ("refusé")
Fin si
Fin

! bisgambiglia@[Link] 84
 Algorithmique
Les Boucles (2/8)

Structures répétitives ou structures itératives :

 Rôle :
 Effectuer un contrôle de saisie
 Répéter des instructions
 Types :
 TantQue test Faire instructions
 Faire instructions TantQue test
 Pour valeur Faire instructions valeur Suivant
 Principe : répète des instructions tant que le test ou la
condition est vérifiée.

! bisgambiglia@[Link] 85
 Algorithmique
Les Boucles (3/8)

 Application :
Variable ne en numérique Que retourne / fait cet algo ?
Debut
Ecrire “Entrer une note“ Variable ne en numérique
TantQue ne < 0 OU ne >20 Debut
Lire ne Ecrire “Entrer une note“
FinTantQue Lire ne
Fin TantQue ne < 0 OU ne >20
Que retourne / fait cet algo ? Lire ne
Variable ne en numérique FinTantQue
Debut Fin
ne ← 22
Ecrire “Entrer une note“
TantQue ne < 0 OU ne >20 Que retourne / fait cet algo ?
Lire ne
FinTantQue
Fin
! bisgambiglia@[Link] 86
 Algorithmique
Les Boucles (4/8)

 Dangers :
 Ecrire une boucle TantQue dans laquelle la
condition n’est jamais VRAI
 On ne rentre jamais dans la boucle
 Ecrire une boucle TantQue dans laquelle le test
n’est jamais FAUX
 On ne sort jamais de la boucle
 Attention lorsqu’on manipule (modifie) une
variable du test dans les instructions de la boucle

bisgambiglia@[Link] 87
 Algorithmique
Exercices

 Exercice 5.1 : Ecrire un algorithme qui demande à l’utilisateur

un nombre compris entre 1 et 3 jusqu’à ce que la réponse
convienne.

 Exercice 5.2 : Ecrire un algorithme qui demande un nombre

compris entre 10 et 20, jusqu’à ce que la réponse convienne.
En cas de réponse supérieure à 20, on fera apparaître un
message : « Plus petit ! », et inversement, « Plus grand ! » si le
nombre est inférieur à 10.

 Exercice 5.3 : Ecrire un algorithme qui demande un nombre

de départ, et qui ensuite affiche les dix nombres suivants. Par
exemple, si l'utilisateur entre le nombre 17, le programme
affichera les nombres de 18 à 27.

bisgambiglia@[Link] 88
 Algorithmique
Les Boucles (5/8)

 La boucle Pour :
 la structure « Pour … Suivant » n’est pas du tout
indispensable ; on pourrait utiliser uniquement un « Tant
Que ». Le seul intérêt du « Pour » est d’épargner un peu de
fatigue au programmeur, en lui évitant de gérer lui-même la
progression de la variable qui lui sert de compteur, on parle
d’incrémentation.
Variable i en Entier Variable i en Entier
Début Début
i←0 Pour i ← 0 à 15 Pas 1
TantQue i < 15    Ecrire "Passage numéro : ", i
 i←i+1 i Suivant
  Ecrire "Passage numéro : ", i Fin
Incrémentation fixée à 1 par défaut et
FinTantQue
modifiable par l’utilisateur (2, -1, etc.)
Fin
! bisgambiglia@[Link] 89
 Algorithmique
Les Boucles (6/8)

 Structure de la boucle Pour :

Pour Compteur ← Initial à Final Pas ValeurDuPas
…
Instructions
…
Compteur suivant
 Attention :
 Quand on stipule un pas négatif dans une boucle, la valeur
initiale du compteur doit être supérieure à sa valeur finale si l’on
veut que la boucle tourne ! Dans le cas contraire, on aura
simplement écrit une boucle dans laquelle le programme ne
rentrera jamais.
 Lorsqu’on modifie la valeur du Variable i en Entier
Début
Compteur dans les instruction la Pour i ← 1 à 15
boucle peut devenir infinie.  i←i*2
  Ecrire "Passage numéro : ", i
i Suivant Fin
bisgambiglia@[Link] 90
 Algorithmique
Les Boucles (7/8)

 Les structures Pour

TantQue
sont sont
employées
employées
dansdans
les situations
les situations
où l’on
où
l’on procéder
doit doit procéder
à un traitement
à un traitement
systématique
systématique
sur les éléments
sur les
éléments
d’un ensemble
d’un ensemble
dont le dont
programmeur
on ne connaît
connaîtpas d’avance
d’avance la
quantité, comme par exemple :
quantité.
 le contrôle d’une saisie
 la gestion des tours d’un jeu (tant que la partie n’est pas finie, on
recommence)
 la lecture des enregistrements d’un fichier de taille inconnue

bisgambiglia@[Link] 91
 Algorithmique
Les Boucles (8/8)

 Boucles imbriquées et successives :

Variables Truc, Trac en Entier Variables Truc, Trac en Entier
Début Début
Pour Truc ← 1 à 15 Que Pour Truc ← 1 à 15
  Ecrire "Il est passé par ici" font   Ecrire "Il est passé par ici"
  Pour Trac ← 1 à 6 ces Truc Suivant
    Ecrire "Il repassera par là" algos. ? Pour Trac ← 1 à 6
  Trac Suivant   Ecrire "Il repassera par là"
Truc Suivant Trac Suivant
Fin Fin

Les boucles ne peuvent jamais, ne doivent jamais, être croisées.

Variables Truc, Trac en Entier
Pour Truc ← … instructions
  Pour Trac ← … instructions
Truc Suivant instructions
  Trac Suivant
! bisgambiglia@[Link] 92
 Algorithmique
Exercices (1/4)
 Exercice 5.4 : Ecrire un algorithme qui demande un nombre de départ, et
qui ensuite écrit la table de multiplication de ce nombre, présentée comme
suit (cas où l'utilisateur entre le nombre 7) :
 Table de 7 :
 7x1=7
 7 x 2 = 14
 7 x 3 = 21
 …
 7 x 10 = 70

 Exercice 5.5 : Ecrire un algorithme qui demande un nombre de départ, et

qui calcule la somme des entiers jusqu’à ce nombre. Par exemple, si l’on
entre 5, le programme doit calculer :
1 + 2 + 3 + 4 + 5 = 15
 NB : on souhaite afficher uniquement le résultat, pas la décomposition du
calcul.

bisgambiglia@[Link] 93
 Algorithmique
Exercices (2/4)
 Exercice 5.6 : Ecrire un algorithme qui demande un nombre de départ, et
qui calcule sa factorielle.
NB : la factorielle de 8, notée 8 !, vaut : 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8

 Exercice 5.7 : Ecrire un algorithme qui demande successivement 20

nombres à l’utilisateur, et qui lui dit ensuite quel était le plus grand parmi
ces 20 nombres :
Entrez le nombre numéro 1 : 12
Entrez le nombre numéro 2 : 14
etc.
Entrez le nombre numéro 20 : 6
Le plus grand de ces nombres est  : 14
 Modifiez ensuite l’algorithme pour que le programme affiche de surcroît
en quelle position avait été saisie ce nombre : C’était le nombre numéro 2

bisgambiglia@[Link] 94
 Algorithmique
Exercices (3/4)

 Exercice 5.8 : Réécrire l’algorithme précédent, mais

cette fois-ci on ne connaît pas d’avance combien
l’utilisateur souhaite saisir de nombres. La saisie des
nombres s’arrête lorsque l’utilisateur entre un zéro.

 Exercice 5.9 : Lire la suite des prix (en euros entiers

et terminée par zéro) des achats d’un client. Calculer
la somme qu’il doit, lire la somme qu’il paye, et
simuler la remise de la monnaie en affichant les textes
"10 Euros", "5 Euros" et "1 Euro" autant de fois qu’il
y a de coupures de chaque sorte à rendre.

bisgambiglia@[Link] 95
 Algorithmique
Exercices (4/4)
 Exercice 5.10 : Écrire un algorithme qui permette de connaître ses chances
de gagner au tiercé, quarté, quinté et autres impôts volontaires.
On demande à l’utilisateur le nombre de chevaux partants, et le nombre de
chevaux joués. Les deux messages affichés devront être :
Dans l’ordre : une chance sur X de gagner
Dans le désordre : une chance sur Y de gagner
X et Y nous sont donnés par la formule suivante, si n est le nombre de
chevaux partants et p le nombre de chevaux joués (on rappelle que le signe
! signifie "factorielle", comme dans l'exercice 5.6 ci-dessus) :
X = n ! / (n - p) !
Y = n ! / (p ! * (n – p) !)
 NB : cet algorithme peut être écrit d’une manière simple, mais relativement
peu performante. Ses performances peuvent être singulièrement
augmentées par une petite astuce. Vous commencerez par écrire la manière
la plus simple, puis vous identifierez le problème, et écrirez une deuxième
version permettant de le résoudre.

bisgambiglia@[Link] 96
 Sommaire

1. Rappels : Le Codage de l’information (2h)

2. Algorithmique (13h)
1. Introduction
2. Les variables
3. Lecture et Ecriture
4. Structures conditionnelles
5. Logique
6. Boucles
7. Tableaux
8. Procédures et Fonctions
9. Récursivité
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 97
 Algorithmique
Tableau (1/7) ‘Exemple’
Algorithme
Variable - ne : réel, note d'écrit
 Exercice : Améliorer cet
Variable - moy : réel, moyenne du module algorithme pour lire 10
Début
Ecrire “Saisir une note“
notes et en faire la moyenne.
ne ← lire()  3 solutions !
TantQue (ne < 0 OU ne >20)
Ecrire “Erreur : Saisir à nouveau la note“
 Déclarer 10 variables n1, n2,
ne ← lire() etc.
FinTantQue  Lire dans une boucle Pour
…
moy ← (2 * ne + no)/3
 Utiliser un tableau
si moy >= 10 alors
écrire ("reçu")
sinon si moy > 8 et moy < 10
écrire ("rattrapage")
sinon
écrire ("refusé")
Fin si
Fin

! bisgambiglia@[Link] 98
 Algorithmique
Tableau (2/7)

 Définition :
 Ensemble de valeurs portant le même nom de variable et
repérées par un nombre, ou une variable indicée. Nombre
ou indice qui sert à repérer chaque valeur. Chaque fois que
l’on doit désigner un élément du tableau, on fait figurer le
nom du tableau, suivi de l’indice de l’élément, entre
parenthèses.
 Notation / Déclaration :
 Tableau NonDuTableau(Taille) Type
 Tableau tab(10) en Entier
 Intérêts :
 Regrouper un ensemble de valeurs
 Simplifier leurs traitements (utilisation des boucles)
bisgambiglia@[Link] 99
 Algorithmique
Tableau (3/7)

 Représentation :
Indice 0 1 2 3 4 5 6 7 8 9

Notes 12 10 8 18 5 11 15 7 14 16

 Tableau Notes(10) en Entier

 Indice i de 0 à 9
 Taille 10 Attention : il faut bien distinguer
 Notes(0) renvoie 12 la taille tu tableau, et
son indice.
 Notes(3) renvoie 18 L’indice commence à 0

bisgambiglia@[Link] 100
 Algorithmique
Tableau (4/7)

 Exemple :
Tableau Note(12) en Numérique → Déclaration du tableau
Variables Moy, Som en Numérique
Variables i en Entier
→ Déclaration de l’indice
Début
Pour i ← 0 à 11
  Ecrire "Entrez la note n°", i → Boucle pour remplir le tableau
  Lire Note(i)
i Suivant
Som ← 0 → Initialisation de la variable
Pour i ← 0 à 11 Som
  Som ← Som + Note(i) → Boucle qui parcourt le tableau
i Suivant et calcule la somme Som
Moy ← Som / 12
Ecrire “ La moyenne est : “, Moy
Fin
→ Calcul de la moyenne
→ Affichage de la moyenne
bisgambiglia@[Link] 101
 Algorithmique
Tableau (5/7)

 Exécution :
Tableau Note(10) en Numérique i 0 1 2 3 4 5 6 7 8 9
Variables Moy, Som en Numérique
Variables i en Entier Note
Début
Pour i ← 0 à 9
i 0 1 2 3 4 5 6 7 8 9
  Ecrire "Entrez la note n°", i
  Lire Note(i) Note 12 10 8 18 5 11 15 7 14 16
i Suivant
Som ← 0
Pour i ← 0 à 9 Pour i = 0, Som = 0 + 12
  Som ← Som + Note(i) Pour i = 1, Som = 12 + 10
i Suivant Pour i = 2, Som = 22 + 8
Moy ← Som / 10 Pour i = 3, Som = 30 + 18
Ecrire “ La moyenne est : “, Moy …
Fin Pour i = 9, Som = 100+16

! bisgambiglia@[Link] 102
 Algorithmique
Tableau (6/7)

 Dans un tableau, la valeur d’un indice doit toujours :

 être égale au moins à 0 (dans quelques rares langages, le premier
élément d’un tableau porte l’indice 1). Attention, Truc(6) est le
septième élément du tableau Truc !

 être un nombre entier Quel que soit le langage, l’élément Truc(3,1416)

n’existe jamais.

 être inférieure ou égale au nombre d’éléments du tableau (moins 1, si

l’on commence la numérotation à zéro). Si le tableau Bidule a été
déclaré comme ayant 25 éléments, la présence dans une ligne, sous une
forme ou sous une autre, de Bidule(32) déclenchera automatiquement
une erreur.

 Astuce : pour la déclaration tab(9+1), 9 c’est l’indice et 10 la taille du

tableau
 Ne pas confondre la valeur de l’indice i et la valeur du tableau
bisgambiglia@[Link] 103
 Algorithmique
Exercices (1/2)
 Exercice 6.1 : Ecrire un
algorithme qui déclare et
 Exercice 6.5 : Ecrivez la fin de
remplisse un tableau de 7 valeurs l’algorithme 6.3 afin que le
numériques en les mettant toutes calcul de la moyenne des notes
à zéro. soit effectué et affiché à l’écran.
 Exercice 6.2 : Ecrire un
algorithme qui déclare et remplit
un tableau contenant les six Tableau Nb(5+1) en Entier
voyelles de l’alphabet latin. Variable i en Entier
 Exercice 6.3 : Ecrire un Début
algorithme qui déclare un tableau Pour i ← 0 à 5
de 9 notes, dont on fait ensuite Nb(i) ← i * i
saisir les valeurs par l’utilisateur. i suivant
Pour i ← 0 à 5
 Exercice 6.4 : Que produit
l’algorithme ci-contre ? Ecrire Nb(i)
Peut-on simplifier cet algorithme i suivant
avec le même résultat ? Fin

bisgambiglia@[Link] 104
 Exercice

 6.5.1
 Tableau de N notes
 L’utilisateur rentre ses notes

 L’algo renvoie la moyenne, la note max et la note

min

bisgambiglia@[Link] 105
 Algorithmique
Exercices (2/2)
 Exercice 6.6 : Que produit  Exercice 6.7 : Que produit
l’algorithme suivant ? l’algorithme suivant ?
Peut-on simplifier cet algorithme
avec le même résultat ?
Tableau Suite(7+1) en Entier
Tableau N(6+1) en Entier Variable i en Entier
Variables i, k en Entier Début
Début Suite(0) ← 1
N(0) ← 1 Suite(1) ← 1
Pour k ← 1 à 6 Pour i ← 2 à 7
  N(k) ← N(k-1) + 2   Suite(i) ← Suite(i-1) + Suite(i-2)
k Suivant i suivant
Pour i ← 0 à 6 Pour i ← 0 à 7
  Ecrire N(i)   Ecrire Suite(i)
i suivant i suivant
Fin Fin

bisgambiglia@[Link] 106
 Algorithmique
Tableau (7/7) ‘info en +’

 Taille dynamique : Il arrive fréquemment que l’on ne

connaisse pas à l’avance le nombre d’éléments que
devra comporter un tableau (sa taille) :
 Déclarer le tableau de taille infinie (espace mémoire)
 Déclarer le tableau après avoir demandé à l’utilisateur le
nombre d’éléments à entrer
0 1 2
I
 Tableau à deux dimensions ou matrice : J

 Indice de lignes i 0 6 8 4
 Indice de colonnes j 1 3 5 7
 tab(i)(j) => tab(1)(1) renvoie 5 2 9 6 3
 Les tableaux sont fréquemment utilisés avec les
algorithmes de tri

bisgambiglia@[Link] 107
 Algorithmique
Exercices (1/2)
 Exercice 6.8 : Ecrivez un algorithme permettant à l’utilisateur de saisir un
nombre quelconque de valeurs, qui devront être stockées dans un tableau.
L’utilisateur doit donc commencer par entrer le nombre de valeurs qu’il
compte saisir. Il effectuera ensuite cette saisie. Enfin, une fois la saisie
terminée, le programme affichera le nombre de valeurs négatives et le
nombre de valeurs positives.

 Exercice 6.9 : Ecrivez un algorithme calculant la somme des valeurs d’un

tableau (on suppose que le tableau a été préalablement saisi).

 Exercice 6.10 : Ecrivez un algorithme constituant un tableau, à partir de

deux tableaux de même longueur préalablement saisis. Le nouveau tableau
sera la somme des éléments des deux tableaux de départ.
Tableau 1 : 4 8 7 9 1 5 4 6

Tableau 2 : 7 6 5 2 1 3 7 4

Tableau à constituer : 11 14 12 11 2 8 11 10

bisgambiglia@[Link] 108
 Algorithmique
Exercices (2/2)
 Exercice 6.11 : Toujours à partir de deux tableaux précédemment saisis,
écrivez un algorithme qui effectue le calcule suivant : il multiplier chaque
élément du tableau 1 par chaque élément du tableau 2, et additionner le
tout. Par exemple si l'on a :
Tableau 1 : | 4 | 8 | 7 | 1 | 2 |
Tableau 2 : | 3 | 6 |
Résultat : 3 * 4 + 3 * 8 + 3 * 7 + 3 * 12 + 6 * 4 + 6 * 8 + 6 * 7 + 6 * 12 = 279

 Exercice 6.12 : Ecrivez un algorithme qui permet la saisie d’un nombre

quelconque de valeurs, sur le principe de l’ex 6.8. Toutes les valeurs
doivent être ensuite augmentées de 1, et le nouveau tableau sera affiché à
l’écran.

 Exercice 6.13 : Ecrivez un algorithme permettant, toujours sur le même

principe, à l’utilisateur de saisir un nombre déterminé de valeurs. Le
programme, une fois la saisie terminée, renvoie la plus grande valeur en
précisant quelle position elle occupe dans le tableau. On prendra soin
d’effectuer la saisie dans un premier temps, et la recherche de la plus
grande valeur du tableau dans un second temps.
bisgambiglia@[Link] 109
 Algorithmique
Tableau et Tri (1/4)

1. Recherche dans un tableau

 Ecrire un algo. qui renvoie vrai si un élément E, saisie
par l’utilisateur, est dans le tableau
 Modifier l’algo. Pour renvoyer aussi l’indice de E
 Astuce : utiliser un booléen

2. Tri par sélection

 Chercher le plus petit élément et le ranger à la première
place via une permutation
 Ainsi de suite

3. Tri à bulles
 Permutation d’éléments qui ce suivent
bisgambiglia@[Link] 110
 Algorithmique
Tableau et Tri (2/4)

1. Recherche Tableau Tab(20) en Numérique

Variable N en Numérique
Début
Ecrire "Entrez la valeur à rechercher"
Lire N
Trouvé ← Faux
Pour i ← 0 à 19
  Si N = Tab(i) Alors
   SiTrouvé
N = Tab(i)
← VraiAlors
      Ecrire "N fait partie du tableau"
FinSi
i  suivant
Sinon
Si   Trouvé
EcrireAlors
"N ne fait pas partie du tableau"
   Ecrire
FinSi "N fait partie du tableau"
i suivant
Sinon
  Ecrire "N ne fait pas partie du tableau"
FinSi
Fin
bisgambiglia@[Link] 111
 Algorithmique
Tableau et Tri (3/4)
boucle principale : le point de départ se décale à chaque tour
2. Tri par sélectionPour i ← 0 à 10
on considère provisoirement que t(i) est le plus petit élément
  posmini ← i
45 122 12 3 21 on examine tous les éléments suivants
  Pour j ← i + 1 à 11
3 122 12 45 21     Si t(j) < t(posmini) Alors
       posmini ← j
3 12 122 45 21
    Finsi
  j suivant
3 12 21 45 122
A cet endroit, on sait maintenant où est le plus petit élément.
Il ne reste plus qu'à effectuer la permutation.
  temp ← t(posmini)
  t(posmini) ← t(i)
  t(i) ← temp
On a placé correctement l'élément numéro i,
on passe à présent au suivant.
i suivant
bisgambiglia@[Link] 112
 Algorithmique
Tableau et Tri (4/4)

3. Tri à bulles Variable Yapermute en Booléen

Début
Idée de départ : un tableau trié en ordre
…
croissant, c’est un tableau dans lequel tout Yapermut ← Vrai
élément est plus petit que celui qui le suit. TantQue Yapermut
Prendre chaque élément, et le comparer avec   Yapermut ← Faux
l’élément qui le suit. Si l’ordre n’est pas bon,   Pour i ← 0 à 10
on permute ces deux éléments. Et on     Si t(i) > t(i+1) alors
recommence jusqu’à ce que l’on n’ait plus       temp ← t(i)
aucune permutation à effectuer.       t(i) ← t(i+1)
      t(i+1) ← temp
      Yapermut ← Vrai
Le flag Yapermute va nous indiquer si nous
    Finsi
venons ou non de procéder à une permutation   i suivant
au cours du dernier balayage du tableau, dans FinTantQue
le cas contraire, c’est signe que le tableau est Fin
trié.
! bisgambiglia@[Link] 113
 Algorithmique
Exercices
 Exercice 7.2 : Ecrivez un algorithme qui trie un tableau dans l’ordre
décroissant.
Vous écrirez bien entendu deux versions de cet algorithme, l'une employant le
tri par insertion, l'autre le tri à bulles.

 Exercice 7.3 : Ecrivez un algorithme qui inverse l’ordre des éléments d’un
tableau dont on suppose qu'il a été préalablement saisi (« les premiers
seront les derniers… »)

 Exercice 7.4 : Ecrivez un algorithme qui permet à l’utilisateur de

supprimer une valeur d’un tableau préalablement saisi. L’utilisateur
donnera l’indice de la valeur qu’il souhaite supprimer. Attention, il ne
s’agit pas de remettre une valeur à zéro, mais bel et bien de la supprimer du
tableau lui-même ! Si le tableau de départ était : 
Tableau initial : | 12 | 8 | 4 | 45 | 64 | 9 | 2 |
Et que l’utilisateur souhaite supprimer la valeur d’indice 4, le nouveau
tableau sera : 
Tableau final : | 12 | 8 | 4 | 45 | 9 | 2 |
bisgambiglia@[Link] 114
 Sommaire

1. Rappels : Le Codage de l’information (2h)

2. Algorithmique (13h)
1. Introduction
2. Les variables
3. Lecture et Ecriture
4. Structures conditionnelles
5. Logique
6. Boucles
7. Tableaux
8. Procédures et Fonctions
9. Récursivité
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 115
 Algorithmique
Exemple

Algorithme Fonction moyenne() en Entier

Debut
Variable - moy : réel, moyenne du module
som ← 0
Début
Pour i de 0 à 9
moy ← moyenne() Ecrire(“Entrer une note")
si moy >= 10 alors ne(i) ← lire()
écrire ("reçu") TantQue ne(i)<0 OU ne(i)>20
sinonSi moy > 8 et moy < 10 Ecrire(“La note n’est pas
écrire ("rattrapage") correcte, Entrer une note")
sinon ne (i) ← lire()
FinTantQue
écrire ("refusé")
i Suivant
FinSi
som ← som + ne(i)
Fin FinPour
moy ← som / 10
renvoyer(moy)
Fin
bisgambiglia@[Link] 116
 Algorithmique
Procédures et Fonctions (1/15)

 Définitions :
 Une fonction est une portion de code représentant un sous
programme, qui effectue une tâche ou un calcul
relativement indépendant du reste du programme.
 Une procédure, aussi appelée routine ou sous-routine, est
une fonction qui ne renvoie pas de résultat.

 Rôle :
 Simplifier le programme en transformant une partie de
code redondant en fonction qui peut alors être appelée
plusieurs fois.

bisgambiglia@[Link] 117
 Algorithmique
Procédures et Fonctions (2/15)

 Prototype et déclaration :
 Fonction NonDeLaFct(paramètres Type du paramètre)
Type du résultat retourné
 Procédure NonDeLaPdr(paramètres Type du paramètre)

 Exemple et Utilisation :
 Fonction carre(x en Entier) en Entier
Fonction carre(x en Entier) en Variable a, b en Entier
Entier a← 4
Début b ← carre(a)
Variable résultat en Entier Ecrire “le carré de“+a+“est“+b
résultat ← x*x // renvoie => le carré de 4 est 16
Renvoyer résultat
FinFonction
bisgambiglia@[Link] 118
 Algorithmique
Procédures et Fonctions (3/15)

 Les fonctions sont constituées de quatre parties :

1. le nom; il doit impérativement correspondre à une
fonction proposée par le langage.
2. deux parenthèses, une ouvrante, une fermante. Ces
parenthèses sont toujours obligatoires, même lorsqu'on
n'écrit rien à l'intérieur.
3. une liste de valeurs, indispensables à la bonne exécution
de la fonction. Ces valeurs s’appellent des arguments,
ou des paramètres. Certaines fonctions exigent un seul
argument, d’autres deux, etc.
4. Un type de retour, qui spécifie quel est le type de
résultat renvoyé par la fonction. Attention : non
renseigné pour les procédures, elles ne renvoient rien.

bisgambiglia@[Link] 119
 Algorithmique
Procédures et Fonctions (4/15)

 Fonctions prédéfinies :
 Fonctions classiques :
 Lire()
 Ecrire(“Texte")
 Fonctions de texte :
 Len(“texte") => renvoie la taille du texte passé en paramètre (ici
5)
 Trouve(“texte“,“mot") => renvoie l’indice de la première lettre
du nom dans le texte
 Fonctions numériques :
 Ent(3.14) => renvoie le paramètre arrondit (ici 3)
 Mod(10,3) => renvoie le reste de la division euclidienne (ici 1)
 Alea(0,10) => renvoie un nombre aléatoire (ici entre 0 et 10)
 Fonctions mathématiques :
 Sin(PI), Cos(PI), Tan(PI)

bisgambiglia@[Link] 120
 Algorithmique
Procédures et Fonctions (5/15)

 Exemple - que renvoie ces fonctions ?

 Len("Bonjour, ça va ?")
 Len("") 

 Trouve("Un pur bonheur", "pur")

 Ent(13,228)

 Mod(12,2)

 Mod(44,8)

bisgambiglia@[Link] 121
 Algorithmique
Exercices
 Exercice 9.2 : Ecrivez un algorithme qui demande un mot à l’utilisateur et
qui affiche à l’écran le nombre de lettres de ce mot.

 Exercice 9.3 : Ecrivez un algorithme qui demande une phrase à

l’utilisateur et qui affiche à l’écran le nombre de mots de cette phrase. On
suppose que les mots ne sont séparés que par des espaces.

 Exercice 9.4 : Ecrivez un algorithme qui demande une phrase à

l’utilisateur et qui affiche à l’écran le nombre de voyelles contenues dans
cette phrase. On pourra utiliser la fonction Trouve.

 Exercice 9.10 : Ecrivez un algorithme qui demande un nombre entier à

l’utilisateur. L’ordinateur affiche ensuite le message "Ce nombre est pair"
ou "Ce nombre est impair" selon le cas.

bisgambiglia@[Link] 122
 Algorithmique
Procédures et Fonctions (6/15)

 Fonctions personnalisées :
 But : la modularité et la lisibilité du code
 Séparation entre le corps du programme (procédure
principale - main) et des bouts de code (module) qu’on
peut rappeler a volonté (fonctions ou sous-procédures)
 Principe : isoler les instructions à répéter et créer
un fonction dans le rôle sera de traiter un cas précis
et renvoyer le résultat correspondant.
 On remarque l’apparition d’un nouveau mot-clé :
Renvoyer, qui indique quelle valeur ‘résultat’ sera
renvoyer lorsque la fonction est utilisée par le
!
programme.
bisgambiglia@[Link] 123
 Algorithmique
Procédures et Fonctions (7/15)

Mauvaise Structure : Fonction

... Fonction RepOuiNon() en
Ecrire "Etes-vous marié ?" caractère
Rep1 ← "" Truc ← ""
TantQue Rep1 <> "Oui" et Rep1 <> TantQue Truc <> "Oui" et Truc <>
"Non" "Non"
  Ecrire "Tapez Oui ou Non"   Ecrire "Tapez Oui ou Non"
  Lire Rep1   Lire Truc
FinTantQue FinTantQue
... Renvoyer Truc
Ecrire "Avez-vous des enfants ?" FinFonction
Rep2 ← ""
TantQue Rep2 <> "Oui" et Rep2 <> Bonne Structure :
"Non" ...
  Ecrire "Tapez Oui ou Non" Ecrire "Etes-vous marié ?"
  Lire Rep2 Rep1 ← RepOuiNon()
FinTantQue …
...
! bisgambiglia@[Link] 124
 Algorithmique
Procédures et Fonctions (8/15)

 Fonctions personnalisées avec arguments :

Fonction puissance Fonction puissance
Fonction puissance() en entier Fonction puissance(x en entier, p en
Debut entier) en entier
Ecrire “Entrer une valeur“ Debut
Lire(x) resultat ← 1
Ecrire “Entrer une puissance“ Pour i de 0 à (p-1) Faire
Lire(p) resultat ← x * resultat
resultat ← 1 finPour
Pour i de 0 à (p-1) Faire renvoyer resultat
resultat ← x * resultat Fin
finPour
renvoyer resultat
Fin

! bisgambiglia@[Link] 125
 Algorithmique
Exercices

 Exercice 11.1 : Écrivez une fonction qui renvoie la somme de

cinq nombres fournis en argument.

 Exercice 11.a : Ecrivez une fonction qui calcule les solutions

d’une équation du second degré de la forme ax2+bx+c=0
 Rappel : delta = b2-4*A*C
 Si delta = 0 il y a une solution –b/2a
 Si delta > 0 il y a deux solutions (–b+√delta)/2A et (–b-√delta)/2A
 Si delta < 0 il n’y a pas de solution réelle

 Exercice 11.B : Ecrire une fonction qui renvoie vrai si un

nombre N, passé en paramètre, est premier, et faux sinon.
 Rappel : un nombre premier n’est divisible de par 1 et lui-
même exemple 3, 5, 7, 11, etc.
bisgambiglia@[Link] 126
 Algorithmique
Procédures et Fonctions (9/15)

 Procédures :
 C’est une fonction qui ne renvoie pas de résultat à l’aide
du mot clé ‘renvoyer’.
 Attention : par contre elle peut afficher un résultat à l’écran
à l’aide du mot clé ‘écrire’. Cette instruction, n’est pas
considéré comme un renvoi de valeurs.
Fonction Procédure
Fonction a() en Entier Procedure a()
… …
Renvoyer res Ecrire “le résultat est“+res
… …
FinFonction FinProcedure
Utilisation Utilisation
x en Entier a()
x ← a()
! bisgambiglia@[Link] 127
 Algorithmique
Procédures et Fonctions (10/15)

 Procédures :
 Rôle : permettent de renvoyer des informations multiples,
la ou une fonction ne renvoie qu’une valeur unique.
 Exemple : L’affichage des éléments d’un tableau
Procédure
Procedure affiche(tab(3)(3) en Entier)
Debut
Tab(0)(0) Tab(0)(1) Tab(0)(2)
Pour i de 0 à 2 Faire //Colonne
Pour j de 0 à 2 Faire //Ligne Tab(1)(0) Tab(1)(1) Tab(1)(2)
Ecrire “|“+tab(i)(j)+“|“ Tab(2)(0) Tab(2)(1) Tab(2)(2)
FinPour
Ecrire “\n“ //Saut de Ligne
FinPour
FinProcedure

bisgambiglia@[Link] 128
 Algorithmique
Procédures et Fonctions (11/15)

 Bilan I :
 Une fonction se caractérisait par les mots-clés Fonction ... Fin
Fonction, une procédure est identifiée par les mots-clés
Procédure ... Fin Procédure.
 Lorsqu'une fonction était appelée, sa valeur (retournée) était toujours
affectée à une variable (ou intégrée dans le calcul d'une expression).
L'appel à une procédure, lui, est au contraire toujours une instruction
autonome.
 Toute fonction doit, pour cette raison, comporter l'instruction
"Renvoyer". Pour la même raison, l'instruction "Renvoyer" n'est
jamais utilisée dans une procédure. La fonction est une valeur
calculée, qui renvoie son résultat vers le programme principale. La
procédure, elle, est un traitement ; elle ne "vaut" rien.
 Toute procédure possédant un et un seul paramètre en sortie
peut également être écrite sous forme d'une fonction.

bisgambiglia@[Link] 129
 Algorithmique
Exercice
Algorithme Fonction moyenne() en Entier
Variable - moy : réel, moyenne du Debut
module som ← 0
Début Pour i de 0 à 9
moy ← moyenne() Ecrire(“Entrer une note")
si moy >= 10 alors ne(i) ← lire()
écrire ("reçu") TantQue ne(i)<0 OU ne(i)>20
sinonSi moy > 8 et moy < 10 Ecrire(“La note n’est pas correcte,
écrire ("rattrapage") Entrer une note")
sinon ne (i) ← lire()
écrire ("refusé") FinTantQue
FinSi som ← som + ne(i)
Fin i Suivant
FinPour
moy ← som / 10
renvoyer(moy)
Modifier ces programmes, pour que la Fin
fonction moyenne prennent en paramètre
un tableau de note. Puis transformer la
fonction moyenne en procédure, et
adapter le programme principal.
bisgambiglia@[Link] 130
 Algorithmique
Procédures et Fonctions (12/15)

 Le problème des arguments :

 Données d’entrées
 Rôle : transmettre des informations depuis le code donneur d'ordres
(prog. principal) jusqu'au code sous-traitant (fonction ou
procédure).
 Données de sorties
 Rôle : Renvoyer suite à un traitement par la procédure ou la
fonction, des informations ou un résultat au prog. principal
 Pour les fonctions, données envoyées à l’aide du mot clé
Renvoyer (modifications possibles)
 Pour les procédures, données affichées à l’aide de la commande
Ecrire() (pas de modifications possibles)

bisgambiglia@[Link] 131
 Algorithmique
Procédures et Fonctions (13/15)

// Procédure // Fonction
Procedure test(a en Entier) Fonction test(a en Entier) res en Entier
Debut Debut
a ← a+10 a ← a+10
Ecrire(“Le résultat est : “,a) Renvoyer a
FinProc FinFct
// Prog. Principal // Prog. Principal
Variable a et b en Entier Variable a et b en Entier
Debut Debut
a←5 a←5
b←a b←a
test(a) a ← test(a)
Ecrire (“a vaut : “,a) Ecrire (“a vaut : “,a)
Ecrire (“b vaut : “,b ) Ecrire (“b vaut : “ ,b)
Fin Fin

bisgambiglia@[Link] 132
 Algorithmique
Procédures et Fonctions (14/15)

 Porté des variables

 Une variable déclarée dans une fonction n’est visible ou
utilisable que dans la fonction, sa valeur n’est connue que
par la fonction (variable local ou privée)
 Une variable déclarée avant un programme (variable
globale ou public) est visible et utilisable par l’ensemble
des modules constituant le programme. Sa valeur est
connue par tous

 Pourquoi ne pas rendre toutes les variables publiques,

et ainsi éviter le passage de paramètres
 Économie des ressources mémoire
! bisgambiglia@[Link] 133
 Algorithmique
Procédures et Fonctions (15/15)

 Bilan II
 Une application bien programmée est une application à
l'architecture claire, dont les différents modules font ce qu'ils
disent, disent ce qu'il font, et peuvent être testés (ou modifiés)
un par un sans perturber le reste de la construction.
 Il convient donc :
 de limiter l'utilisation des variables globales.
 de regrouper sous forme de modules distincts tous les morceaux de
code qui possèdent une certaine unité fonctionnelle (programmation
par "blocs"). C'est-à-dire de faire la chasse aux lignes de codes
redondantes, ou quasi-redondantes.
 de faire de ces modules des fonctions lorsqu'ils renvoient un résultat
unique, et des procédures dans tous les autres cas.

bisgambiglia@[Link] 134
 Sommaire

1. Rappels : Le Codage de l’information (2h)

2. Algorithmique (13h)
1. Introduction
2. Les variables
3. Lecture et Ecriture
4. Structures conditionnelles
5. Logique
6. Boucles
7. Tableaux
8. Procédures et Fonctions
9. Récursivité
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 135
 Algorithmique
Récursivité (1/5)

 Définitions :
 La récursivité est une démarche qui consiste à faire
référence à ce qui fait l'objet de la démarche, ainsi c'est le
fait de décrire un processus dépendant de données en
faisant appel à ce même processus sur d'autres données;
 Propriété d'un programme de faire appel à lui même en
cours d'exécution.
 Un programme qui pour fournir son résultat, va s’appeler
lui-même un certain nombre de fois.
 La programmation récursive est une technique
algorithmique applicable dans n'importe quel langage de
programmation (si l'on peut faire des fonctions). Elle
permet d'effectuer des traitements, souvent programmables
aussi avec des boucles mais de façon beaucoup plus légère
à l'exécution.
bisgambiglia@[Link] 136
 Algorithmique
Récursivité (2/5)

 Principe :
La programmation récursive est une méthode
permettant de répéter un nombre indéterminé de
fois une action (comme une boucle). On crée une
fonction qui va effectuer une action.
Dans cette fonction nous plaçons une condition. Si
cette condition est vraie on appelle la fonction à
nouveau en son sein même, si c'est faux on sort
avec un Renvoyer. On va ainsi répéter la fonction
tant que la condition est vraie.

bisgambiglia@[Link] 137
 Algorithmique
Récursivité (3/5)

 Exemple d’application :
 Fonction factorielle : A chaque appel , la fonction Fact est
appelée avec un argument différent Fact(4) : 4, 3, 2 et 1.
Tout se passe comme si on a plusieurs copies du code de la
fct. Ainsi pour chaque exécution, les variables locales
ainsi que les paramètres en entrée sont réalloués. A un
moment donné, seules les dernières allocations sont
référencées. Quand un retour est fait, les plus récentes
allocations sont libérées et une copie de la fct. est
réactivée. C'est donc le mécanisme de pile. A chaque appel,
une zone pour les variables locales et les paramètres est
allouée. A chaque retour, il y a un dépilement.

bisgambiglia@[Link] 138
 Algorithmique
Récursivité (4/5)

 Exemple fonction factorielle :

 Formule de calcule :
 n ! = 1 x 2 x 3 x … x n
 n ! = n x (n-1) !
Factorielle(4)
Fonction factorielle(k en Entier) en Entier renvoie
Debut 4* Factorielle(4-1)
Si k=0 Alors qui renvoie
Renvoyer 1 4*3* Factorielle(3-1)
SinonSi qui renvoie
4*3*2*Factorielle(2-1)
Renvoyer k * factorielle(k-1)
qui renvoie
FinSi 4*3*2*1*Factorielle(1-1)
Fin STOP

bisgambiglia@[Link] 139
 Algorithmique
Récursivité (5/5)

 Trois remarques fondamentales :

1. la programmation récursive, pour traiter certains
problèmes, est très économique pour le programmeur ; elle
permet de faire les choses correctement, en très peu
d'instructions.
2. en revanche, elle est très dispendieuse de ressources
machine. Car à l’exécution, la machine va être obligée de
créer autant de variables temporaires que de « tours » de
fonction en attente.
3. tout problème formulé en termes récursifs peut également
être formulé en termes itératifs ! Donc, si la
programmation récursive peut faciliter la vie du
programmeur, elle n’est jamais indispensable.
bisgambiglia@[Link] 140
 Algorithmique
Exercices (1/4)

 Exercice A : que renvoie cette fonction

Fonction syracuse(n en Entier) en Entier
fonction fibo(n, f_n_1 = 1, f_n = 0)
Debut
Si (n = 0) OU (n = 1) alors Debut
Renvoyer 1
Si (n = 0) Alors
SinonSi (mod(n,2) = 0) Alors
Renvoyer syracuse(n/2) renvoyer f_n
Sinon Renvoyer syracuse(3*n + 1)
Sinon renvoyer fibo(n - 1, f_n, f_n +
FinSi
f_n_1)
Fin
Exercice B : Réaliser une fonction récursive qui renvoie la valeur
de la suite de Fibonacci inférieur à n (passé en paramètre).
Formule : Un+1 = Un + Un-1
Exercice C : Ecrire une fonction récursive qui possède deux
arguments x et n qui fourni l’expression x puissance n

bisgambiglia@[Link] 141
 Algorithmique
Exercices (2/4)

 Exercice D : Le problème des tours de Hanoi

 On dispose de 3 tours A, B et C. Initialement, n disques de
diamètres différents sont placés sur A. Un disque plus grand
ne doit jamais se trouver sur un disque plus petit. Le
problème est de transférer les n disques de A vers C, en
utilisant B comme intermédiaire en respectant les deux
règles suivantes :
1. à un moment donné, seul le disque au sommet d'un piquet
peut être transféré vers un autre.
2. un disque plus grand ne doit pas se trouver sur un disque
plus petit.

 Il est très difficile de trouver une solution itérative

( essayer...). Par contre, il existe une solution récursive
simple et élégante. bisgambiglia@[Link] 142
 Algorithmique
Exercices (3/4)

 Supposons que nous avons une solution pour n-1 disques. Nous pourrons
alors définir une solution pour n disques au moyen de la solution de n-1
disques.
 n=1 constitue le cas trivial : transférer le disque unique de A vers C.
 Pour transférer n disques de A vers C, en utilisant B comme auxiliaire, on
procède comme suit:
1. Si n=1, alors transférer l'unique disque de A vers C.
2. Transférer les n-1 disques au sommet de A vers B avec C comme
auxiliaire.
3. Transférer le disque restant de A vers C.
4. Transférer les n-1 disques de B vers C avec A comme auxiliaire.

 Nous remarquons que c'est simple car nous venons de développer une
solution pour le cas trivial (n=1) et une solution pour le cas n en terme de
solution pour le cas plus simple n-1.

bisgambiglia@[Link] 143
 Algorithmique
Exercices (4/4)

 L'algorithme est alors le suivant :

#include <iostream.h>
#include <conio.h>
void hanoi(char dep, char dest, char temp, int n) {
if(n==1) {
Fonction hanoi(n
cout << : entier,
"deplacez "<< A : caractère,
dep << " vers "B<<
: caractère, C:
dest << endl;
caractère
getch();): : rien
début
}else {
si nhanoi( dep, temp, dest, n-1); // ss-problème 1
= 1 alors
hanoi( dep, dest,
écrire("déplacer ", temp, 1); ",
A, " vers //C)
ss-problème 2
hanoi(temp, dest, dep, n-1); // ss-problème 3
sinon
}
} hanoi(n-1, A, C, B) ;
// écrire("déplacer
prog. principal ", A, " vers ", C)
int hanoi(n-1,
main() { B, A, C) ;
int nb = 5; // Nombre de paliers à résoudre.
finsi
hanoi( 'a','c','b',nb);
fin
return 0;
}
bisgambiglia@[Link] 144
 Sources
 [Link]
 [Link]
 [Link]/communication/textes/[Link]
 [Link]
 Initiation à l’algorithmique - Denis Lapoire - 2006
[Link]
rs/

 [Link]
 [Link]
 [Link]
 [Link]
html

bisgambiglia@[Link] 145
 Sommaire

1. Rappels : Le Codage de l’information (2h)

2. Algorithmique (13h)
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 146
 Sommaire
1. Rappels : Le Codage de l’information (2h)
2. Algorithmique (13h)
3. Introduction à la programmation (6h)
1. Compilation
2. Introduction
3. Le langage C
1. 1er programme
2. Affichage
3. Lecture
4. Commentaires
5. Types et variables
6. Instructions conditionnelles
7. Boucles
8. Caractères
9. Fonctions et procédures
10. Structures de données et pointeurs
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 147
 Programmation
Interprétation et compilation (1/2)

 Du problème au code :
 Etape 1 : traduction

 Etape 2 :

 Etape 3 :
 C’est à cela que sert un langage : à Pour le programmeur :
vous épargner la programmation en Phase de test et de correction
binaire et vous permettre de vous Pour l’ordinateur :
Transformation du programme
faire comprendre de l’ordinateur en langage binaire
d’une manière (relativement) lisible.
bisgambiglia@[Link] 148
 Programmation
Interprétation et compilation (2/2)

 Tout langage doit obligatoirement procéder à une traduction

en langage machine pour être exécuté.
 Il existe deux stratégies de traduction (parfois disponibles au
sein du même langage):
1. le langage traduit les instructions au fur et à mesure qu’elles se
présentent. Cela s’appelle la compilation à la volée, ou
l’interprétation.
2. le langage commence par traduire l’ensemble du programme en
langage machine, constituant ainsi un deuxième programme (un
deuxième fichier) distinct physiquement et logiquement du premier.
Ensuite, et ensuite seulement, il exécute ce second programme. Cela
s’appelle la compilation.
 Il va de soi qu’un langage interprété est plus maniable : on
peut exécuter directement son code - et donc le tester - au fur
et à mesure, sans avoir à la compiler à chaque fois. Mais il va
aussi de soi qu’un programme compilé s’exécute beaucoup
plus rapidement qu’un programme interprété.
bisgambiglia@[Link] 149
 Programmation
Compiler en programme en C (1/2)

 Compilation en ligne de commande avec gcc :

 Commande à taper sous le terminal
 gcc -o [Link] nomprog.c
 gcc -g -o essai nomprog.c
 Compilation sous Dev-C++ :
 Raccourcis clavier F9
 Compilation sous visual studio :
 Raccourcis clavier F5
 Fonctionnement :

bisgambiglia@[Link] 150
 Programmation
Compiler en programme en C (2/2)

 Makefile : Lorsqu’un programme contient beaucoup de

fichiers, il est parfois assez difficile de se rappeler quel fichier
il faut recompiler. Il existe un utilitaire très pratique, appelé
make, qui utilise un fichier de dépendances appelé Makefile
qui décrit quels fichiers source il faut pour obtenir un
exécutable donné. Grâce à cette description make est en
mesure de recompiler seulement les fichiers qui ont été
modifiés depuis la dernière compilation.

bisgambiglia@[Link] 151
 Sommaire
1. Rappels : Le Codage de l’information (2h)
2. Algorithmique (13h)
3. Introduction à la programmation (6h)
1. Compilation
2. Introduction
3. Le langage C
1. 1er programme
2. Affichage
3. Lecture
4. Commentaires
5. Types et variables
6. Instructions conditionnelles
7. Boucles
8. Caractères
9. Fonctions et procédures
10. Structures de données et pointeurs
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 152
 Programmation
Introduction langage (1/2)

 La communication entre l’homme et la machine s’effectue à

l’aide de plusieurs moyens physiques externes. Les ordres
que l’on donne à l’ordinateur pour agir sont fondés sur la
notion d’instruction. Ces instructions constituent un langage
de programmation. Depuis leur création, les langages de
programmation ont évolué et se sont diversifiés, il est
possible de les classer en cinq catégories :
1. Les langages procéduraux ou impératifs (FORTRAN, C, etc.).
2. Les langages fonctionnels (Lisp, Scheme, etc.).
3. Les langages logiques (PROLOG).
4. Les langages objets (C++, C#, java, [Link], python, etc.).
5. Les langages de spécification (LPG, Z, etc.).
 L’un des principaux objectifs d’un langage de programmation
est de permettre la construction de logiciels.
! bisgambiglia@[Link] 153
Programmation
Introduction langage (2/2)

bisgambiglia@[Link] 154
 Sommaire
1. Rappels : Le Codage de l’information (2h)
2. Algorithmique (13h)
3. Introduction à la programmation (6h)
1. Compilation
2. Introduction
3. Le langage C
1. 1er programme
2. Affichage
3. Lecture
4. Commentaires
5. Types et variables
6. Instructions conditionnelles
7. Boucles
8. Caractères
9. Fonctions et procédures
10. Structures de données et pointeurs
4. Programmation Orientée Objet (6h)

bisgambiglia@[Link] 155
 Programmation
Le langage C

 Premier programme : Ajout de librairies standards

Pour l’utilisation des fonctions
d’entrées / sorties (printf, scanf)
#include <stdio.h>
#include <stdlib.h>
Déclaration de la fonction
principale (main)
int main(int argc, char *argv[])
{
printf("Bonjour \n"); Instruction d’affichage ‘printf’
system("PAUSE");
return 0; Mise en pause du
} système pour
l’affichage console
Valeur renvoyer par la fonction main
(0) de type int (entier)
bisgambiglia@[Link] 156
 Programmation
Le langage C

 Affichage : printf(“text %d \n“,a);

 fonction qui permet d’afficher à l’écran
 Les paramètres entre guillemets "text" sont affichés
 \n permet de faire un saut de ligne
 \t permet de faire une tabulation
 %d faire référence au second argument (a) et affiche un
décimal (entier).
int a = 5;
 %i entier.
 %f réel. printf("Jour %i\n",a); => affiche Jour 5
 %5.2f 5 caractères, 2 chiffres après la virgule.
 %c caractère.
 %s chaîne de caractères.
 %o octal

bisgambiglia@[Link] 157
 Programmation
Le langage C

 Affichage

bisgambiglia@[Link] 158
 Programmation
Le langage C

 Lecture au clavier :
/********** En C *********
 L’instruction scanf() * Programme de Nom, Date *
* Objet du programme : ____ *
 scanf("%d", ********************************/
&un_nombre), //Ajout de librairie
Attention de ne pas #include <stdio.h>
// Programme principal
oublier le signe & void main ()
devant le nom des {
variables numériques int un_nombre;
printf("Donnez un nombre: \t");
passées en argument. scanf("%d", &un_nombre);
}

bisgambiglia@[Link] 159
 Programmation
Le langage C

 Lecture au clavier :

bisgambiglia@[Link] 160
 Programmation
Le langage C

 Les commentaires :
 Sur une ligne // text
 Sur plusieurs lignes /* test */

/* Commentaire
qui s’étend sur
plusieurs lignes */

// Commentaire sur une ligne

bisgambiglia@[Link] 161
 Programmation
Le langage C

 Type de données :
Type de donnée Signification Taille (en octets) Plage de valeurs acceptée
char Caractère 1 -128 à 127
unsigned char Caractère non signé 1 0 à 255
short int Entier court 2 -32 768 à 32 767
unsigned short int Entier court non signé 2 0 à 65 535
2 (proc.16 bits) -32 768 à 32 767
int Entier
4 (proc. 32 bits) -2 147 483 648 à 2 147 483 647
2 (proc. 16 bits) 0 à 65 535
unsigned int Entier non signé
4 (proc. 32 bits) 0 à 4 294 967 295
long int Entier long 4 -2 147 483 648 à 2 147 483 647
unsigned long int Entier long non signé 4 0 à 4 294 967 295
float Flottant (réel) 4 3.4*10-38 à 3.4*1038
double Flottant double 8 1.7*10-308 à 1.7*10308
long double Flottant double long 10 3.4*10-4932 à 3.4*104932

bisgambiglia@[Link] 162
 Programmation
Le langage C

 Conversion de /********** En C *********

type : * Programme de Nom, Date *
 La conversion ou * Objet du programme : ____ *
cast permet de ********************************/
transformer une #include <stdio.h>
variable d’un type à void main ()
un autre (si c’est {
possible) float x;
 Les fonctions int entier;
mathématiques x = 3.54;
suivantes sont entier = x;
disponibles en C // Conversion automatique en entier
(parmi d’autres), entier = (int)(5 + x);
elles sont déclarées, // Conversion explicite en entier
comme ceil et floor, entier = (int)(x+0.5);
dans le fichier // Ajouter 0.5 donne un arrondi de x
math.h plutôt qu’une troncature
}
bisgambiglia@[Link] 163
 Programmation
Le langage C

 Autre fonctions de la
librairie math.h

bisgambiglia@[Link] 164
 Programmation
Le langage C

 Déclaration et initialisation de variable :

 Les variables sont des espaces de mémoire qui permettent de conserver
des nombres ou d’autres éléments (lettres, mots...). Chaque variable est
caractérisée par son nom, son type et son contenu.

En Algo En C
Variable un_nombre en Entier #include <stdio.h>
un_nombre ← 5 void main()
{
int un_nombre;
un_nombre = 5;
}

Toute variable utilisée dans un programme doit avoir été déclarée auparavant.
! bisgambiglia@[Link] 165
 Programmation
Le langage C

 Constantes en
/********** En C *********
C: * Programme de Nom, Date *
 Les constantes ont * Objet du programme : ____ *
une ‘porté’ plus ********************************/
//Ajout de librairie
importante que les
#include <stdio.h>
variables locales, // Déclaration de constante
elles sont connues #define PI 3.1415
dans tout le // Programme principal
programme. De plus void main()
comme leur nom {
l’indique elles ne double rayon, diametre;
peuvent pas varier rayon = 15.0;
diametre = 2*PI*rayon;
}

bisgambiglia@[Link] 166
 Programmation
Le langage C

 Le type enum :
/********** En C *********
 Une * Programme de Nom, Date *
* Objet du programme : ____ *
énumération est ********************************/
une suite de //Ajout de librairie
#include <stdio.h>
valeurs entières // Déclaration d’un constante enum
constantes enum mois { jan=1, fev, mar, avr,
mai, jun, jul, aou,sep, oct, nov,dec};
auxquelles on /* Dans cet exemple fev vaut 2, mar
vaut 3 et ainsi de suite. */
donne des
noms
symboliques.

bisgambiglia@[Link] 167
 Programmation
Le langage C

 Instructions /********** En C *********

conditionnelles * Programme de Nom, Date *
 Si Sinon * Objet du programme : ____ *
********************************/
 if else
#include <stdio.h>
void main ()
{
int i;
printf("Tapez un nombre entier positif ou negatif: ");
scanf("%d", &i);
if (i<0)
{ i=-i;
printf("J'ai remis i à une valeur positive.\n");
}else{
printf("Vous avez tapé un nombre positif.\n");
}
}

bisgambiglia@[Link] 168
 Programmation
Le langage C

 Instructions
conditionnelles
 Si Sinon
 if else

 Opérateurs
logiques

bisgambiglia@[Link] 169
 Programmation
Le langage C

 Instructions /********** En C *********

conditionnelles * Programme de Nom, Date *
 Si Sinon * Objet du programme : ____ *
********************************/
 if else
#include <stdio.h>
void main ()
 Opérateurs {
logiques float x;
int plusgrand; // variable booléenne
printf(“Entrez un reel: “);
 Variables scanf(“%f”,&x);
booléennes plusgrand = (x>15.0); // plusgrand ← 0 ou 1
if (plusgrand)
printf(“Plus grand que 15 \n”);
else
printf(“Plus petit que 15\n”);
}

bisgambiglia@[Link] 170
 Programmation
Le langage C

 Instructions #include <stdio.h>

conditionnelles void main ()
{ char operation;
 Si Sinon int r, a, b;
 if else printf("Entrez un signe d'opération: ");
scanf("%c", &operation);switch (operation) {
case '+':
a=273; b=158; r=0; case 'p':
 Opérateurs r = a + b;
if (operation=='+' || operation=='p')
break;
logiques r = a + b; case '-':
case 'm':
else if (operation=='-' || operation=='m')
r = a - b;
r = a - b; break;
 Variables case '*':
else if (operation=='*' || case
operation=='f')
'f':
booléennes r = a * b; r = a * b;
break;
else if (operation=='/' || operation=='d')
case '/':
case 'd':
 L’instruction r = a / b; r = a / b;
else break;
 switch printf("Non valable: ");
default:
printf("Non valable: "); }
printf("%d %c %d = %d\n", a, operation, b, r); }
! bisgambiglia@[Link] 171
 Programmation
Le langage C

 Les boucles : /********** En C *********

 TantQue * Programme de Nom, Date *
 while * Objet du programme : ____ *
********************************/
#include <stdio.h>
void main ()
 Faire TantQue
{ int i, M, N;
 do while do {
printf("Donnez M (M>-6) N (N<6) (N>M): ");
scanf("%d %d", &M, &N);
printf("Compteur de %d a %d \n",M,N);
}while (M <= -6 || N >= 6 || M >= N);
i = M;
while (i <= N) {
printf("%d ", i);
i = i+1;
}
printf("\n"); }
bisgambiglia@[Link] 172
 Programmation
Le langage C

 Les boucles : /********** En C *********

 TantQue * Programme de Nom, Date *
 while * Objet du programme : ____ *
********************************/
#include <stdio.h>
void main ()
 Faire TantQue
{
 do while int i, m1, m2;
printf("Donnez un minimum et un maximum: ");
scanf("%d %d", &m1, &m2);
 Pour for (i=m1; i<=m2; i++)
 for printf("%d\n", i);
for (i=D; i<=F; i++) printf("\n");
{ inst. } }

bisgambiglia@[Link] 173
 Programmation
Le langage C

 Les boucles : // FOR

 TantQue for (initialisation; condition; continuation) {
 while … - instruction - code - …
}
 Faire TantQue // WHILE
 do while initialisation;
while (condition) {
… - instruction - code - …
 Pour
continuation;
 for
}
for (i=D; i<=F; i++)
{ inst. } /* initialisation, condition et continuation sont trois
expressions pouvant être assez quelconques. */
 Rappels I

bisgambiglia@[Link] 174
 Programmation
Le langage C

 Les boucles :
 TantQue
 while

 Faire TantQue
 do while

 Pour
 for
for (i=D; i<=F; i++)
{ inst. }

 Rappels II

! bisgambiglia@[Link] 175
 Programmation
Le langage C
#include <stdio.h>
 Les boucles : #include <stdlib.h>
 TantQue int main(int argc, char *argv[])
{ int a = 0, b=0;
 while b = a++;
printf("a=%d b=%d\n",a,b);
b = ++a;
printf("a=%d b=%d\n",a,b);
 Faire TantQue a -= 2; b += 4;
 do while printf("a=%d b=%d\n",a,b);
a += 1; b *= 2;
printf("a=%d b=%d\n",a,b);
a--; b /= 2;
 Pour printf("a=%d b=%d\n",a,b);
system("PAUSE");
 for return 0; }
for (i=D; i<=F; i++)
{ inst. }

 Rappels III

bisgambiglia@[Link] 176
 Programmation
Le langage C
int main(int argc, char *argv[]) {
 Indentation char phrase[64];
 Lecture de int i, len, diff;
printf("Entrez une phrase (+ de 12 caracteres): ");
phrase fgets(phrase,64,stdin);
len = strlen(phrase);
diff = 'a' - 'A';
 Transforme if (len >= 12){
les for (i = 0; i <= len; i++) {
minuscules en if ('a' <= phrase[i] && phrase[i] <= 'z')
majuscules et phrase[i] = phrase[i] - diff;
else if ('A' <= phrase[i] && phrase[i] <= 'Z')
inversement phrase[i] = phrase[i] + diff;
}
}
 Tableau printf("%s\n", phrase);
system("PAUSE");
 int tab[TAILLE] return 0; }
!  char tab[TAILLE]
bisgambiglia@[Link] 177
 Programmation
Le langage C

 Manipulation /********** En C *********

des caractères : * Programme de Nom, Date *
* Objet du programme : ____ *
********************************/
 Code ASCII de
b = 98 #include <stdio.h>
void main ()
{
char carac, carac1, carac2;
int integer;
printf("Tapez un caractere :\t");
scanf("%c", &carac);
carac1 = carac-1;
carac2 = carac+1;
printf("%c %c %d\n", carac1, carac2, carac);
printf("Tapez un entier: ");
scanf("%d", &integer);
printf("%c\n", integer);
}
bisgambiglia@[Link] 178
Programmation
Utile à savoir

bisgambiglia@[Link] 179
 Programmation
Le langage C

 Manipulation /********** En C *********

des caractères : * Programme de Nom, Date *
* Objet du programme : ____ *
 Code ASCII de ********************************/
b = 98 char phrase[64];
printf("Entrez une phrase : ");
fgets(phrase,64,stdin);
 Lecture printf("%s \n", phrase);
scanf(“%31s”,m)
fgets(p,64,stdin) …
char votre_nom[32];
printf("Comment vous appelez-vous ? ");
scanf(“%31s”,stdin);
printf("Bonjour %s\n", votre_nom);
/!\ Il y a une différent de syntaxe entre un scanf pour lire un entier
(scanf("%d“,&entier))
Et le scanf pour lire une chaîne de caractères
(scanf(“%31s”,m))
! bisgambiglia@[Link] 180
 Programmation
Le langage C

 Manipulation
des caractères : Attention: en dehors de l'initialisation,
il n'est pas permis d'écrire prenom=”Olivier”
 Code ASCII de Pour remplir un tableau il faut utiliser une boucle
b = 98

 Lecture
scanf(“%31s”,m)
fgets(p,64,stdin) /********** En C *********
* Programme de Nom, Date *
 Initialisation * Objet du programme : ____ *
********************************/
char votre_nom[32]=“Paul";

char prenom[]=”Olivier”; // taille = 7

bisgambiglia@[Link] 181
 Programmation
Le langage C

 Manipulation
des caractères :
/********** En C *********
 Code ASCII de * Programme de Nom, Date *
b = 98 * Objet du programme : ____ *
********************************/
 Lecture #include <stdio.h>
/!\ chaine2 = chaine 1
scanf(“%31s”,m) #include <string.h>
=> ERREUR
fgets(p,64,stdin) void main ()
{
 Initialisation char chaine1[32], chaine2[32];
printf(“Tapez un mot: “);
scanf(“%31s”,chaine1);
 Copier strcpy(chaine2, chaine1);
printf(“Vous avez tape: %s\n”,chaine2
}

bisgambiglia@[Link] 182
 Programmation
Le langage C

 Manipulation /********** En C *********

des caractères : * Programme de Nom, Date *
* Objet du programme : ____ *
 Code ASCII de ********************************/
b = 98 #include <stdio.h>
#include <string.h>
void main ()
 Lecture { char s1[32], s2[32];
scanf(“%31s”,m) int i, len;
fgets(p,64,stdin) printf("Chaine? ");
fgets(s1,32,stdin);
 Initialisation len = strlen(s1);
strcpy(s2, "");
for (i=len-1; i>=0; i--)
 Copier s2[(len-1)-i] = s1[i]; // accumulation
s2[len] = '\0'; // Ne pas oublier le ’\0’ final
printf("\nA resultat: %s\n", s2);
 Exemple
}
bisgambiglia@[Link] 183
 Programmation
Traitement des chaînes de caractères

Toutes les fonctions de traitement de chaînes de caractères s'appliquent à des chaînes

terminées par un caractère nul ('\0').
 Les prototypes de toutes ces fonctions sont déclarés dans le fichier en-tête string.h.

Action Prototype Description

Copie de char *strcpy (char *dest, copie de la chaîne src dans la chaîne dest, y
chaîne const char *src) ; compris le caractère nul de fin de chaîne.

Longueur size_t strlen(const char strlen permet de calculer la longueur de str. size_t
d'une chaîne *str) ; et de type entier.

Comparaison int strcmp(const char *s1, strcmp effectue une comparaison des deux
de chaînes const char *s2) ; chaînes s1 et s2, et retourne une valeur négative
si s1 < s2, 0 si s1 = s2, et une valeur positive si
s1 > s2.

bisgambiglia@[Link] 184
 Programmation
Traitement des chaînes de caractères
 int strlen(chaîne) donne la longueur de la chaîne (\0 non compris)

 char *strcpy(char *destination,char *source) recopie la source dans la destination,

rend un pointeur sur la destination

 char *strncpy(char *destination,char *source,int longmax) idem strcpy mais

s'arrête au \0 ou longmax (qui doit comprendre le \0)

 char *strcat(char *destination,char *source) recopie la source à la suite de la
destination, rend un pointeur sur la destination

 char *strncat(char *destination,char *source,int longmax) idem, mais plus sûr

 int strcmp(char *str1,char*str2) rend 0 si str1= =str2, <0 si str1<str2, >0 si str1>str2
(classé alphabétiquement, donc test du premier caractère, si différents test du second,
etc...) Les majuscules sont différentes des minuscules (inférieures). Idem pour
strncmp, qui lui vérifie la dimension.

bisgambiglia@[Link] 185
 Programmation
Manipulation des chaînes de caractères

Il y a également des fonctions de conversions entre scalaires et chaînes, déclarées

dans stdlib.h

 int atoi(char *s) traduit la chaîne en entier (s'arrête au premier caractère

impossible, 0 si erreur dès le premier caractère) de même atol et atof

 sscanf et sprintf pour les conversions, qui offrent un maximum de possibilités.

Dans ctype.h, on trouve des fonctions utiles (limitées au caractères) :

 int isdigit(int c) rend un entier non nul si c'est un chiffre ('0' à '9'), 0 sinon. de
même : isalpha (A à Z et a à z, mais pas les accents), isalnum (isalpha||isdigit),
isascii (0 à 127), iscntrl (0 à 31), islower (minuscule), isupper, isspace (blanc,
tab, return...), isxdigit (0 à 9,A à F,a à f)...

 int toupper(int c) rend A à Z si c est a à z, rend c sinon (attention, les accents

ne sont pas gérés). Egalement tolower

bisgambiglia@[Link] 186
 Programmation
Manipulation des chaînes de caractères

<ctype.h> : Toutes les fonctions ci-dessous permettent de tester une propriété

du caractère passé en paramètre. Elles renvoient la valeur 1 si le caractère
vérifie la propriété et 0 sinon. Leur prototype est : int fonction(char c)
fonction renvoie 1 si le caractère est
isalnum une lettre ou un chiffre
Isalpha une lettre
iscntrl un caractère de commande
isdigit un chiffre décimal
isgraph un caractère imprimable ou le blanc
islower une lettre minuscule
isprint un caractère imprimable (pas le blanc)
isspace un blanc
isupper une lettre majuscule
isxdigit un chiffre hexadécimal
bisgambiglia@[Link] 187
 Programmation
Manipulation des chaînes de caractères

Il est capital de prendre garde au détail suivant concernant l'utilisation de la

fonction scanf.
Quand on lit une variable de type numérique simple (par exemple int i;), la syntaxe
est: scanf(“%d”, &i);
Quand on lit une variable tableau de caractères (par exemple char s[12];), la
syntaxe est: scanf(“%11s”, s);
Notez la présence du & accolé à la variable dans le premier cas et son absence
dans le deuxième.
Ceci est une source d'erreurs graves entraînant le plantage du programme, soyez
donc extrêmement vigilants.
La fonction scanf, quand elle lit une chaîne de caractères tapée au clavier, s'arrête
au premier espace rencontré, les caractères suivants sont considérés comme
faisant partie de la chaîne suivante. Il n'est donc pas possible de lire une chaîne
de caractères contenant des espaces en utilisant scanf(“%s”,...). Cette
particularité est souvent gênante, c'est pourquoi il existe d'autres fonctions pour
lire des chaînes de caractères au clavier qui, elles ne s'arrêtent pas aux espaces.
Celle que nous utiliserons le plus souvent est la fonction fgets (destination,
taille, source) :
 int s[12];
 fgets(s,12,stdin);
bisgambiglia@[Link] 188
 Programmation
Le langage C

#include <stdio.h>
 Les fonctions : #include <math.h>
 En algo int FahrToCelsius(int fahr);
int tempc;
 Fonction nom(para type) type
Déclaration de la fonction
 Renvoyer resultat void main(){
 En C int tempf = 35;
tempc = FahrToCelsius(tempf);
 type function nom(type para)
printf("%d F -> %d
 return resultat C\n",tempf,tempc);
printf("%d F->%d C\n",12,
Appels de la fonction
FahrToCelsius(12));
}
int FahrToCelsius(int fahr)
{ return 5*(fahr-32)/9;}

Définition de la fonction

! bisgambiglia@[Link] 189
 Programmation
Le langage C

#include <stdio.h>
 Les procédures : #include <stdlib.h>
 En algo void affiche(int a);
 Procedure nom(para type) int main(int argc, char *argv[])
{int x;
 En C
Déclaration
printf("Entrer une valeur de la
positive");
 void function nom(type para)scanf("%d",&x); proc.
affiche(x);
system("PAUSE");
return 0; Appels de la proc.
}
void affiche(int a){
int i;
for(i=0;i<=a;i++) printf("%d\n",i);}

Définition de la proc.

bisgambiglia@[Link] 190
 Programmation
Le langage C

 Récursivité :
 Tout objet est dit récursif s'il se définit à partir de lui-même. Ainsi,
une fonction est dite récursive si elle comporte, dans son corps, au
moins un appel à elle-même.
factoriel :
(i) 0! = 1
(ii) Pour N entier naturel (N > 0), N! = N×(N - 1)!

Algo factoriel :
fact(N)
si N = 0
retourner 1
retourner (N x fact(N-1))

bisgambiglia@[Link] 191
 Programmation
Le langage C

Exercice 1 : récursivité

1. que fait la fonction somme ?
2. à partir de la fonction somme, définir une fonction somme1 plus simple (non
récursive mais itérative)
3. faire une fonction factorielle (récursive) et factoriel1 (itérative)
n! = n×(n-1)×(n-2)×...×1
int somme(int n) int somme1(int n) /* int somme1(int n) */
{ { /* { */
if(n>0)return(somme(n-1)+n); int s=n; /* int s=0; */
return(0); do /* for(;n>0;n--) s+=n; */
} { /* return(s); */
s=s+(n-1); /* } */
n--;
}
/* somme&somme1 calculent while(n>0);
i=n + la somme des (n-1) return(s);
tant que n>0 */ }
bisgambiglia@[Link] 192
 Programmation
Le langage C

int f1_factoriel(int n) // fact recurcive int f1_factoriel1(int n) // fact iterative

{ {
if(n>0)return(factoriel(n-1)*n); int s=n;
return(1); do
} {
s=s*(n-1);
n--;
}
while(n>1);
return(s);
int f1_factoriel1(int n) // fact iterative }
{
int s=1;
for(;n>0;n--) s*=n;
return(s);
}

bisgambiglia@[Link] 193
 Programmation
Le langage C

 Exercices I

Structures conditionnelles, Boucles et fonctions

bisgambiglia@[Link] 194
 Programmation
Calcul du PGCD

A=136, B=48
Algo: div euclide Le pgcd est le dernier reste non nul de la
A = B * quo + rst division euclidien de A par B
136 = 48 * 2 + 40
48 = 40 * 1 + 8
Algo: soustraction
40 = 8 * 5 + 0
136 – 48 = 88
88 – 48 = 40
Le pgcd est le dernier résultat des 48 – 40 = 8
soustractions successives de A par B 40 – 8 = 32
32 – 8 = 24
24 – 8 = 16
Algo : 16 – 8 = 8
1. Vérifier que A >= B, sinon permuter 8–8=0
2. Si A=B le pgcd est A, fin
3. Sinon faire soustraction A-B
4. Revenir à l’étape 1.

bisgambiglia@[Link] 195
 Programmation
Calcul du PGCD

Algo :
1. Vérifier que A >= B, sinon permuter
2. Si A=B le pgcd est A, fin
3. Sinon faire soustraction A-B
4. Revenir à l’étape 1.

Programme :

Etape 1: Etape 2:
if (A<B) if (A==B)
{ {
C=A, A=B, B=C; printf(‘’pgdc(%d,%d)=%d’’,A,B,A);
} exit(0);
}

Etape 3:
A=A-B;
bisgambiglia@[Link] 196
 Programmation
Calcul du PGCD

int main(int argc, char * argv[ ])

{
int A, B, C ;
A = 136 ;
B = 48 ;
for ( ; ;)
{
if (A<B)
{
C=A ; A=B ; B=C ;
}
if (A==B)
{
printf("La valeur du PGCD est %d\n", A) ;
return 0 ;
}
A=A-B ;
}}
bisgambiglia@[Link] 197
 Programmation
#include <stdio.h> Calcul du PGCD
int A, B ;
void pgcd(void)
{ int C ;
for ( ; ;)
{
if (A<B) { C=A ; A=B ; B=C ; }
if (A==B) { return A; }
A=A-B ;
}
}
int main(int argc, char * argv[])
{
A = 136 ;
B = 48 ;
pgcd() ;
printf("La valeur du PGCD est %d\n", A) ;
return 0 ;
}
bisgambiglia@[Link] 198
 Programmation
Calcul du PGCD
#include <stdio.h>
int pgcd(int X, int Y)
{ int C ;
for ( ; ;) {
if (X<Y) { C=X ; X=Y ; Y=C ; }
if (X==Y) { return X ; }
X=X-Y ;
}
}
int main(int argc, char * argv[])
{
int A, B, R ;
A = 136 ;
B = 48 ;
R = pgcd(A,B);
printf("La valeur du PGCD est %d\n", R) ;
return 0 ;
}
bisgambiglia@[Link] 199
 Programmation
Le langage C / Exercices I

Exo : 1 Proposez un bloc d'instructions permettant d'afficher tous

les diviseurs d'un nombre N. Proposez une solution avec
une boucle "for" et une solution avec une boucle "while".

Exo : 2 1. Indiquez si un nombre N est premier ou pas.

2. Ecrire un programme qui affiche la liste des nombres

premiers inférieurs à une valeur donnée.

3. Ecrire un programme qui affiche tous les nombres

premiers qui sont diviseurs d'un nombre N donné.

bisgambiglia@[Link] 200
 Programmation
Le langage C / Exercices I

Ecrire une fonction qui permet de trouver un nombre

Exo : 3
entre 0 et 1000 choisi par l'ordinateur. On indiquera à
chaque essais si le nombre est plus grand ou plus petit
que la solution. On affichera à la fin le nombre d'essais.

Exo : 4 Ecrire un programme qui affiche le Plus Petit Commun

Multiple (PPCM) et le Plus Grand Commun Diviseur
(PGCD) de deux nombres entiers.

Exo : 5 Ecrire un programme qui lit un nombre en binaire et

l'affiche en décimal. Écrire le programme inverse.

bisgambiglia@[Link] 201
 Programmation
Le langage C / Exercices I

Exo : 6 Écrire un programme qui donne le résultat de Xn. La

valeur de N devra être comprise entre 1 et 10.

Ecrire un programme qui calcule le résultat d'une

Exo : 7
expression de la forme : AnXn + An-1Xn-1 …. A1X1 +
A0

Exo : 8 Faire un programme qui simule une calculatrice avec les

opérations classiques (+,/,*,-,%).

bisgambiglia@[Link] 202
 Programmation
Le langage C / Exercices I

Ecrire un programme qui calcule, sur une machine

Exo : 9
quelconque, la longueur en bits d’un char, d’un short,
d’un int et d’un long. Utilisez dans cet exercice les
décalages de bits.

bisgambiglia@[Link] 203
Exo : 1 Programmation
Le langage C / Correction Exercices I

void fct_exo1(){
printf("\t EXO 1 diviseur d un nombre \n") ;
/*Déclaration des variables locales */
int i, N ;
puts("Entrez le nombre N") ;
scanf("%d",&N) ;
for (i=2; i<=N/2; i++)
if ((N%i)==0) printf(" %d est un diviseur de %d \n", i, N) ;

int i=2, N ;
puts("Entrez le nombre N") ;
scanf("%d",&N) ;
while (i<N/2)
{ if ((N%i)==0) printf(" %d est un diviseur de %d \n", i, N) ;
i++;
}

bisgambiglia@[Link] 204
Exo : 2 Programmation
Le langage C / Correction Exercices I

void fct_exo2(){
printf("\t EXO 2.1 nombre premier \n") ;
/*Déclaration des variables locales */
int i=2, N, continuer=1 ;
puts("Entrez le nombre N") ;
scanf("%d",&N) ;
while ((i<N) && (continuer==1))
if ((N%i)==0) continuer=0 ;
else i++ ;
if (i<N) printf (" %d n'est pas un nombre premier %d le divise\n",
N, i) ;
else printf (" %d est un nombre premier\n",N) ;
}

if (continuer==1) printf (" %d n'est pas un nombre premier %d le

divise\n", N, i) ;
else printf (" %d est un nombre premier\n",N) ;

bisgambiglia@[Link] 205
Exo : 2 Programmation
Le langage C / Correction Exercices I

void fct_exo2_2(){
printf("\t EXO 2.2 nombre premier diviseur de N \n") ;
int i=2, N, val, continuer=1, affiche=0 ;
puts("Entrez le nombre N") ;
scanf("%d",&N) ;
val=N ;
while (i<=val){ if ((val%i)==0){
if (affiche==0) {
printf(" %d est un nombre premier diviseur de
%d\n", i, N) ;
affiche=1 ;
}
val/=i ;
}
else{ affiche=0 ; i++ ; }
}
}

bisgambiglia@[Link] 206
Exo : 2 Programmation
Le langage C / Correction Exercices I

void fct_exo2_3(){
printf("\t EXO 2.3 nombre premier inferieur a N \n") ;
int nombre, borne, i ;
/* Les deux premiers nombres premiers sont affichés */
puts("Entrez le nombre limite inferieure a 1000 : ") ;
scanf("%d",&borne) ;
while ((borne<1) || (borne>1000))
{ puts(" -- La borne doit etre comprise en 1 et 1000 : ");
scanf("%d",&borne) ; }
printf("1, 2");
for (nombre = 3; nombre <= borne ; nombre+=2)
{ for (i = 2; i*i <= nombre; i++) if (!(nombre%i)) break;
if (i*i > nombre) printf(", %d", nombre);
}
printf("\n");
}

bisgambiglia@[Link] 207
Exo : 3 Programmation
Le langage C / Correction Exercices I
#include <stdio.h>
void main(void)
{ int nb1, nb2, PPCM=2 ;
printf("Entrez le premier nombre : ");
scanf("%d", &nb1) ; PGCD1=nb1 ;
printf("Entrez le second nombre : ") ;
scanf("%d", &nb2) ; PGCD2=nb2 ;
/* calcul du pgcd */
while (PGCD1 != PGCD2)
(PGCD1 > PGCD2) ? (PGCD1 -= PGCD2) : (nb2 -= nb1)) ;
if (PGCD1==1) printf("Il n’y a pas de PGCD ") ;
else printf("Le PGCD est : %d\n", PGCD1) ;
/* calcul du ppcm */
while (((nb1%PPCM)!=0) && ((nb2%PPCM)!=0))
if (++PPCM>((nb1>nb2) ? nb2 : nb1)) break ;
if (PPCM>nb1 || PPCM>nb2) printf("Il n’y a pas de PPCM ") ;
printf("Le PPCM est : %d\n", PPCM) ;
}

bisgambiglia@[Link] 208
 Pgcd et ppcm sous forme de
fonctions
int ppcm(int nbr1, int nbr2) {
int lePpcm;
if ((0 == nbr1) || (0 == nbr2)) return 0;
/*-----fonction pgcd -------*/ for (lePpcm = (nbr1 < nbr2) ? nbr2 :
int pgcd(int A, int B){ nbr1; lePpcm < (nbr1 * nbr2);
int C; lePpcm++)
//for ( ; ;) autre solution {
while (A!=B) if ((0 == (lePpcm % nbr1)) && (0 ==
{ (lePpcm % nbr2))) break;
if (A<B) }
{ return lePpcm;
C=A ; A=B ; B=C ; }
}
if (A==B)
/*-----fonction ppcm avec pgcd -------*/
{
int ppcm(int nbr1, int nbr2) {
return A;
if ((0 == nbr1) || (0 == nbr2)) return 0;
}
return (nbr1 * nbr2) / pgcd(nbr1, nbr2);
A=A-B ;
}
}
}

bisgambiglia@[Link] 209
Exo : 3 Programmation
Le langage C / Correction Exercices I

/*----- version avec fct -------*/

void fct_exo3_1(){
printf("\t EXO 3 PGCD - PPCM \n") ;
int nb1, nb2;
printf("Entrez le premier nombre : ");
scanf("%d", &nb1) ;
printf("Entrez le second nombre : ") ;
scanf("%d", &nb2) ;
// Apl de fct dans un printf pour afficher le resultat
printf("pgcd = %d\n",pgcd(nb1,nb2));
printf("ppcm = %d\n",ppcm2(nb1,nb2));
/*------- Autre Solution -------------
--- int ResPGCD = pgcd(nbr1,nbr2);
--- int ResPPCM = ppcm(nbr1,nbr2);
--- printf("pgcd = %d, ppcm = %d\n",ResPGCD,ResPPCM);
----------------------------------------*/
}

bisgambiglia@[Link] 210
Exo : 4 Programmation
Le langage C / Correction Exercices I

void fct_exo4(){
printf("\t EXO 4 Quel nombre ? \n") ;
int solution, reponse, nb_essais=0 ;
time_t t;
srand ((unsigned) time(&t)) ; /* initialisation du générateur */
solution=rand()%1000 ;
do
{
puts("Proposez un nombre compris entre 0 et 1000 ");
scanf("%d",&reponse) ;
if (reponse>solution) puts(" Le nombre est trop grand \n") ;
else if (reponse!=solution) puts(" Le nombre est trop petit \n") ;
nb_essais++ ;
}
while (reponse!=solution) ;
printf("Vous avez trouve la solution en %d essais ", nb_essais) ;
}

bisgambiglia@[Link] 211
 Programmation
Le langage C / Correction Exercices I

#include <stdio.h>
void main(void)
{ int nombre=0 ;
char car, continue='O' ;
puts("Proposez nombre en binaire ") ;
while (((car=getchar()) != EOF) && (continue=='O'))
if (car =='0' || car=='1')
nombre=(car - '0') + nombre*2 ;
else
continue='N' ;
printf("%d\n", nombre) ;
}

bisgambiglia@[Link] 212
 Exo : 5 Programmation
void fct_exo5()
{
int tab[10];
int k,j,i,val;
int puissance=0,resultat=0;
// TABLEAU DE 10 ENTIER 0 OU 1
puts("tapez un binaire a 10 chiffres en tapant ENTREE a chaque chiffre.");
for(k=0;k<=9;k++){
do{
scanf("%d",&val);
tab[k]=val;
}while((val != 0) || (vak !=1))
}
//on calcul le chiffre en décimal
for(j=9;j>=0;j--){
if(tab[j]==0){
puissance++;
}else{
resultat+=pow(2,puissance);//(2**puissance);
puissance++;
}
}
printf("le nombre donne %d en decimal\n",resultat);
}

bisgambiglia@[Link] 213
Exo : 5 Programmation
void fct_exo5_2(){
printf("\t EXO 5 conversion 10 en 2 \n") ;
int nombre, div=2 ;
puts("Proposez nombre en decimal \n") ;
scanf("%d",&nombre) ;
while ((div*div) < nombre) div=div*div ;
while (div>=2)
{ if (nombre>=div)
{ printf("%c", '1') ;
nombre-=div ;
}
else
printf ("%c", '0') ;
div/=2 ;
}
if (nombre==1) printf("%c", '1') ;
else printf("%c", '0') ;
}

bisgambiglia@[Link] 214
Exo : 6 Programmation
Le langage C / Correction Exercices I

void fct_exo6(){
printf("\t EXO 6 X puissance N\n") ;
int i, X, N, resultat=1 ;
puts("Proposez une valeur pour N inferieure a 10 : ") ;
scanf("%d",&N) ;
while ((N<1) || (N>10))
{ puts(" -- N doit etre compris en 1 et 10 : ") ;
scanf("%d",&N) ;
}
puts("Donnez la valeur de X : ") ;
scanf("%d",&X) ;
for (i=1; i<=N; i++) resultat*=X ;
printf("Le resultat est %d\n ", resultat) ;
}

bisgambiglia@[Link] 215
 void fct_exo7(){
printf("\t EXO 7 polynome N\n") ;
Exo : 7 int Nmax, i, j ;
float An, X, Terme, Resultat=0 ;
puts("Quel est l'ordre du polynome (inferieure a 10) : ");
scanf("%d",&Nmax);
while ((Nmax <1) || (Nmax >10))
{
puts(" -- N doit être compris en 1 et 10 : ");
scanf("%f",& Nmax);
}
puts("Donnez la valeur de X : ") ;
scanf("%f",&X);
for (i=1; i<=Nmax; i++)
{
printf("Donnez la valeur de A[%d] : ",i) ;
scanf("%f",&An) ;
Terme=1 ;
for (j=1; j<=i; j++) Terme*=X ;
Resultat+=Terme*An ;
}
printf("Le resultat est %f\n ", Resultat) ;
}

bisgambiglia@[Link] 216
Exo : 8 Programmation
void fct_exo8(){
printf("\t EXO 8 calculatrice \n");
float val1, val2, resultat ;
char op ;
int fin=0;
do
{ puts("Entrez l operation sous cette forme (ex: 3*5) ");
scanf("%f%c%f",&val1,&op,&val2) ;
switch (op) {
case '*' : resultat=val1*val2 ; break ;
case '+' : resultat=val1+val2 ; break ;
case '-' : resultat=val1-val2 ; break ;
case '/' : resultat=val1/val2 ; break ;
case '=' : fin++ ; break ;
}
if (!fin) printf ("%f%c%f=%f\n",val1,op,val2,resultat) ;
}
while (!fin) ;
}

bisgambiglia@[Link] 217
Exo : 9 Programmation
void fct_exo9(){
printf("\t EXO 9 longeur d'un type \n");
char un_char ; short un_short ; int un_int ; long un_long ;
int cptr ; /* compteur de bits */

/* calcul du nombre de bits d'un char */

for (cptr = 0, un_char = 1; 0 != un_char ; un_char <<= 1) cptr++;
printf("Taille d'un char : %d\n", cptr);
/* calcul du nombre de bits d'un short */
for (cptr = 0, un_short = 1; 0 != un_short ; un_short <<= 1) cptr+
+;
printf("Taille d'un short : %d\n", cptr);
/* calcul du nombre de bits d'un int */
for (cptr = 0, un_int = 1; 0 != un_int ; un_int <<= 1) cptr++;
printf("Taille d'un int : %d\n", cptr);
/* calcul du nombre de bits d'un long */
for (cptr = 0, un_long = 1; 0 != un_long; un_long <<= 1) cptr++;
printf("Taille d'un long : %d\n", cptr);
}

bisgambiglia@[Link] 218
 Programmation

Exercices et notions complexes

 Tableau
 Notion de pointeurs
 Structure de données

bisgambiglia@[Link] 219
 Programmation
Le langage C

Déclaration:
int MAX = 20; Tableaux
int tab[ MAX]; //tableau d’entier de taille 20

Initialisation:
tab={1,2,3,4,5,6,7,8,9} /* fct qui retourne la somme des éléments
d’un tableau de taille n */
Manipulation int pruc(int titi[ ], int n)
tab[0]=>1 {
tab[5]=>6 int i ;
int somme=0 ;
for (i=0 ; i<n ; i++)
somme = somme+titi[ i ];
//somme+=titi[ i ]
return somme ;
}

bisgambiglia@[Link] 220
 Programmation
Le langage C

 Variables et adresses
Pointeurs
#include <stdio.h>
int main(int argc, char *argv[])
{
int i = 1, j = 2;
printf("i=%d, adresse(i)=%p\n",i,&i);
printf("j=%d, adresse(j)=%p\n",j,&j);
return 0;
}
donne à l’exécution :
i=1, adresse(i)=7fff2ee0
j=2, adresse(j)=7fff2ee4

bisgambiglia@[Link] 221
 Programmation
Pointeurs

Ces opérateurs sont utilisées avec des pointeurs. On utilise

 &variable : donne l'adresse d'une variable
 *pointeur : réfère à la variable pointée (opérateur d'indirection)
 . : champ d'une structure
 -> : champ pointé

 Soit la fonction : void echange(int i, int j) { int k; k=i; i=j; j=k;}

 Apl de la fonction echange(a,b);
 Avec pointeur : void echange(int *i, int *j) { int k; k=*i; *i=*j; *j=k;}
 Apl de la fonction : echange(&a,&b);

 & (adresse de) et * (contenu de)

 En conclusion, pour effectuer un passage d'argument par adresse, il suffit

d'ajouter l'opérateur & devant l'argument réel (à l'appel de la fonction), et
l'opérateur * devant chaque apparition de l'argument formel, aussi bien
dans l'entête que le bloc de la fonction

bisgambiglia@[Link] 222
 Programmation
int i = 2 ; // déclaration d’1 entier
int *j; // déclaration d’1 adresse en mémoire pointant sur un int

j = &i; // mémorise ds j l’@ de i

int i 2i 4 Mémoire

&1 &2 &3 &4 &5 &… &… &.. &n Adresse
i=2 @
.
int *j j=&i

printf(" *j = %d \n ", *j qui, à l’exécution, affiche :

); *j=2
*j=4; // accès a la valeur i=4
printf(" i = %d \n " , i);
bisgambiglia@[Link] 223
 Programmation
Pointeurs

Fonction retournant un pointeur et pointeur de fonction

 type*fonc(arguments) est une fonction qui renvoie un pointeur.

exemple :
int *max(int tableau[], int taille)
{
int i, *grand;
for(grand=tableau,i=1;i<taille;i++)
if(tableau[i] > *grand)
grand = tableau+i;
return(grand);
}

Cette fonction rend l'adresse du plus grand entier du tableau.

bisgambiglia@[Link] 224
 Programmation
Pointeurs

Ptr = TAB; /*met l'adresse du début du tableau dans ptr*/

for(i=0;i<10;i++)
{
printf("entrez la %dième valeur :\n",i+1); /* +1 pour commencer à 1*/
scanf("%d",ptr+i); /* ou &TAB[i] puisque scanf veut une adresse*/
}
puts("affichage du tableau");
for(ptr=TAB; ptr<TAB+10 /* ou &TAB[10] */ ; ptr++)
printf("%d ",*ptr);
puts(" ");
/* attention actuellement on pointe derrière le tableau ! */
ptr-=10; /* ou plutôt ptr=TAB qui lui n'a pas changé */
printf("%d", *ptr+1); /* affiche (TAB[0])+1 */
printf("%d", *(ptr+1)); /* affiche TAB[1] */
printf("%d", *ptr++); /* affiche TAB[0] puis pointe sur TAB[1] */
printf("%d", (*ptr)++); /* affiche TAB[1] puis ajoute 1 à TAB[1]*/

TAB est une "constante pointeur", alors que ptr est une variable (donc
TAB++ est impossible).
bisgambiglia@[Link] 225
 Programmation
Structure de données

On souhaite pouvoir gérer des informations rangées dans un tableau.

Une information est structurée de la manière suivante :
#define MaxNom 20
typedef struct Structure de données
{ insigned char Jour, Mois, Année ;
} TypeDate;
typedef struct
{ char Nom[MaxNom] ;
int Taille ;
typedef struct { Typedate Date ;
int jour; } TypeInformation ;
int mois;
int année;
}date; date *ptr;
date aujourdhui={24,12,1992}; ptr=(struct date *)malloc(sizeof(date));
/*évite de répéter struct*/ *[Link]=14;
ptr->mois=7;

bisgambiglia@[Link] 226
 Programmation
Le langage C

 Exercices II

Fonctions, tableaux et pointeurs

bisgambiglia@[Link] 227
 Programmation
Le langage C / Exercices II

Ecrire une fonction qui permet de remplire un tableau

Exo : 1 d'entiers avec une valeur. Proposez une version avec les
pointeurs.

Ecrire une fonction qui remplit un tableau d'entiers à

Exo : 2 partir de nombres choisi par l'ordinateur. Calculez la
somme et la moyenne.

Exo : 3 Initialisez un tableau avec des valeurs toutes différentes.

Ecrire une fonction qui recherche une valeur dans un

Exo : 4 tableau.
bisgambiglia@[Link] 228
 Programmation
Afficher les minimum et le maximum d'un tableau
Exo : 5 d'entiers. Modifier le programme afin afficher les
emplacements de ces éléments dans le tableau.

Ecrire une fonction qui trie un tableau d'entiers par

Exo : 6 ordre croissant, et afficher les éléments 5 par 5.

Proposez une fonction permettant de supprimer dans un

Exo : 7 tableau un élément donné. On suppose qu'il existe
plusieurs occurrences de l'élément dans le tableau.

Ecrire une procédure permettant d'insérer dans un

Exo : 8 tableau trié des éléments.
bisgambiglia@[Link] 229
 Programmation
Ecrire un programme qui compte tous les lettres d’un
Exo : 9
texte, les espaces, les minuscules et les majuscules.

Ecrire un programme qui calcule le nombre de

consonnes (ou de voyelles) dans un texte non accentué et
Exo : 10 terminé par un #. On utilisera pour cela une fonction qui
teste si une lettre est une consonne ou une voyelle.

Réaliser un programme permettant de rechercher dans

une suite de caractères donnée, le nombre de fois
Exo : 11 qu'apparaît une séquence particulière. La séquence et la
suite de caractères sont terminés par $.
bisgambiglia@[Link] 230
Exo : 1 Programmation
#include <stdio.h>
#define Max 100
void main(void)
{ int Tab[Max], Taille, value ;
do
printf("Entrez la taille réelle du tableau (< %d) : ", Max) ;
scanf("%d",&Taille) ;
while (Taille>Max) ;
printf("Donnez la valeur à mettre dans le tableau : ");
scanf("%d", &value) ;
for (i=0; i<Taille; i++) Tab[i]=value ;
}

….
void main(void)
{ int *ptr ;
……
for (ptr=Tab; ptr<Tab+Taille; ptr++) *ptr=value ; }

bisgambiglia@[Link] 231
Exo : 2 Programmation
#include <stdio.h>
#include <stdlib.h> /* permet d'utiliser le random */
#include <time.h> /* permet de trouver l'heure, afin dinit. random
*/
#define Max 10
void main(void)
{ int Tab[Max], Taille, somme=0, i ;
time t;
srand ((unsigned) time(&t)) ;
do
printf("Entrez la taille réelle du tableau (< %d) : ", Max) ;
scanf("%d",&Taille) ;
while (Taille>Max) ;
for (i=0; i<Taille; i++) Tab[i]=rand()%100 ;
/* calcul de la moyenne */
for (i=0; i<Taille; i++) somme+=Tab[i] ;
printf( "La somme des nombre du tableau est : %d  ",somme) ;
printf( "La moyenne est : %d  ",somme/Taille) ;
}

bisgambiglia@[Link] 232
Exo : 3 Programmation
#include <stdio.h>
…… /* Utilisation des bibliothèques pour rand() */
#define Max 10
void main(void)
{ int Tab[Max], Taille, val ;
int i, j ;
……. /* initialisation de Taille et du générateur automatique */
for (i=0; i<Taille; i++)
{ val= rand()%100 ;
j=0 ;
while (j<i)
{ if (val==Tab[j])
{ val= rand()%100 ;
j=0 ; }
else j++ ; }
Tab[i]=val ;
}
}

bisgambiglia@[Link] 233
Exo : 4 Programmation
…… /* Des directives du pré-processeur */
void main(void)
{ int Tab[Max], Taille, val, i=0 ;
char Trouve, Continuer ;
……. /* initialisation de Taille et du générateur automatique */
for (i=0; i<Taille; i++) Tab[i]=rand()%100 ;
do
printf("Entrez valeur à rechercher : ") ;
scanf("%d",&val) ;
while ((Trouve=='F') && (i<Taille))
if (val==Tab[i]) Trouve='V' ;
else i++ ;
if (Trouve=='V')
printf(" %d se trouve à la place %d\n", val, i) ;
else
printf(" %d n'est pas dans le tableau \n", val) ;
printf(" Voulez-vous chercher une autre valeur (O/N) ") ;
scanf("%d",&Continuer) ;
while (Continuer=='O') ; }

bisgambiglia@[Link] 234
Exo : 5 Programmation

…… /* Des directives du pré-processeur */

void main(void)
{ int Tab[Max], Taille, IndMax, IndMin, i ;
……. /* initialisation de Taille et du générateur automatique */
for (i=0; i<Taille; i++) Tab[i]=rand()%100 ;
IndMax=0 ;
IndMin=0 ;
for (i=1; i<Taille; i++)
{ if (Tab[i]>Tab[IndMax]) IndMax=i ;
if (Tab[i]<Tab[IndMin]) IndMin=i ;
}
printf("Le minimum est : %d \n", Tab[IndMin]) ;
printf("Le maximum est : %d \n", Tab[IndMax]) ;
}

bisgambiglia@[Link] 235
Exo : 6 Programmation
char affiche='F' ;
printf("Le minimum est : %d \n", Tab[IndMin]) ;
for (i=IndMin+1; i<Taille; i++)
if (Tab[i]==Tab[IndMin])
if (affiche== 'F')
{ printf ("Aux adresses : %d\t%d ", IndMin, i) ;
affiche== 'V' ; }
else printf ("\t %d ", i) ;
if (affiche== 'F') printf ("A l’adresse : %d", IndMin) ;
affiche='F' ; printf ("\n") ;
printf("Le maximum est : %d \n", Tab[IndMax]) ;
for (i=IndMax+1; i<Taille; i++)
if (Tab[i]==Tab[IndMax])
if (affiche== 'F')
{ printf ("Aux adresses : %d\t%d ", IndMin, i) ;
affiche== 'V' ; }
else printf ("\t %d ", i) ;
if (affiche== 'F') printf ("A l’adresse : %d", IndMin) ;
printf ("\n") ;

bisgambiglia@[Link] 236
Exo : 7 Programmation
…… /* Des directives du pré-processeur */
void main(void)
{ int Tab[Max], Taille, tmp ;
int i , j , IndMin ;
……. /* initialisation de Taille et du générateur automatique */
for (i=0; i<Taille; i++) Tab[i]=rand()%100 ;
for (i=0; i<Taille-1; i++)
{ IndMin=i ;
for (j=i+1; j<Taille ; j++)
if (Tab[j]<Tab[IndMin]) IndMin=j ;
if (IndMin!=i)
{ tmp=Tab[i] ; Tab[i]=Tab[IndMin] ; Tab[IndMin]=tmp ; }
}
for (i=0; i<Taille; i++)
{ if ((i%5)==0) printf("\n") ;
printf("\t%d", Tab[i]) ;
}
}

bisgambiglia@[Link] 237
Exo : 8 Programmation

…… /* Des directives du pré-processeur */

void main(void)
{ int Tab[Max], Taille, val ;
int i , place ;
……. /* initialisation de Taille et du générateur automatique */
for (i=0; i<Taille; i++) Tab[i]=rand()%100 ;
printf("Entrez la valeur à supprimer : ") ;
scanf("%d",&val) ;
for (i=0, place=0; i<Taille; i++)
{ if ((Tab[i]!=val)
{ if (place!=i) Tab[place]=Tab[i] ;
place++ ;
}
}
Taille=place ;
}

bisgambiglia@[Link] 238
Exo : 9 Programmation
…… /* Des directives du pré-processeur et fonction main */
{ int Tab[Max], Taille, val, place ;
char continuer='O' ;
……. /* initialisation du tableau et trie */
while ((Taille<Max) && (continuer=='O'))
{ place=0 ;
printf("Entrez la valeur à insérer : ") ;
scanf("%d",&val) ;
while ((place<Taille) && (Tab[place]<val)) place++ ;
for (i=Taille; i>place; i--) Tab[i]=Tab[i-1] ;
Tab[place]=val ;
Taille++ ;
printf(" Voulez-vous insérer une autre valeur (O/N) : ") ;
scanf("%c",&continuer) ;
}
if (Taille==Max) printf("Le tableau es plein \n") ;
}

bisgambiglia@[Link] 239
Exo : 10 Programmation
…… /* Des directives du pré-processeur et fonction main */
{ char car ;
int space, lower, upper, letter[26];
for (i = 0; i < 26; i++) letter[i] = 0 ;
space = upper = lower = 0 ;
while ((car = getchar()) != EOF)
{ if (isspace(car)) nspace++;
else if (isalpha(car))
{ if (isupper(car)) { upper++ ; car = tolower(car) ; }
else if (islower(car)) lower++ ;
letter[car - 'a']++ ;
}
}
printf("uppercase: %d, lowercase: %d, spaces: %d\n", upper,
lower, space) ;
for (car = 'a'; car <= 'z'; car++)
if (letter[car - 'a']) { printf("%c: %d\n",car,letter[car - 'a']); }
}

bisgambiglia@[Link] 240
 void recherche(char *ch,char *sch)
Exo : 11 {
int pos=0;
while (*ch)
{
if (debut_egal(ch,sch))
printf("trouve en position
int debut_egal(char *ch,char *sch) %d\n",pos);
/* répond si sch est exactement le ch++;pos++;
début de ch */ }
{ }
while (*sch && *ch)
{
void test(void)
if (*sch!=*ch) return(0); else {ch+
+;sch++;} {
} char ch[TAILLE], sch[TAILLE] ;
return(!(*sch)); puts("chaine a tester ? ");
} scanf("%s",ch);
//gets(ch);
puts("sous-chaine a trouver ?");
//gets(sch);
scanf("%s",sch);
recherche(ch,sch);
}
bisgambiglia@[Link] 241
Programmation
Le langage C

 Exercices III

Chaînes de caractères

bisgambiglia@[Link] 242
 Programmation
Exercices

 Exercice 2
Manipulation de chaîne de caractères.
 Exercice 3
Chaîne de caractères : On dispose de deux tableaux (Ligne et Mot) contenant des
caractères.
 Exercice 4
On souhaite créer un programme pour gérer N places. Pour cela on dispose d’un
tableau de booléen (table des places). Si une place est réservée la valeur dans le
tableau est à vrai (et est à faux dans le cas contraire). Définir les fonctions
suivantes :
 initialiser() qui permet de créer un tableau de booléen à faux ;
 réserver() qui permet de réserver m places consécutives dans le tableau ;
 placeLibre() qui affiche la liste des places libres ou occupées ;
 libérer() qui permet de libérer m places consécutives dans le tableau.
 Exercice 5
Un carre magique est une matrice (N,N) contenant des chiffres compris entre 1 et
N*N, de tel sorte que les sommes de chaque ligne de chaque colonne et de
chaque diagonale soient égales.
bisgambiglia@[Link] 243
 Programmation
Exercices

 Exercice 2 : Manipulation de chaines de char

1. Faire un programme qui lit un mot au clavier et qui affiche ses caractères
dans l’ordre inverse, en commençant par le dernier.
2. Lire un nom au clavier puis l’afficher en mettant un signe « - » entre chaque
lettre.
3. Lire un mot au clavier. Afficher ensuite combien il y a de ’a’ dans le mot.
4. Lire une phrase dans une variable et compter combien il y a de mots
(compter les espaces). Utiliser une boucle for, de 1 jusqu’à la fin de la phrase
(strlen). Si l’on trouve la constante espace, ’ ’, on incrémente la variable qui
compte les espaces.
5. Lire une chaîne au clavier (ou déposer une chaîne constante dans une
variable) et l’imprimer sans qu’apparaissent les lettres ’a’ qui seraient
contenues dans cette chaîne.

bisgambiglia@[Link] 244
 Programmation
Exercices

 Exercice 2 : Manipulation de chaines de char

6. Ecrire un programme qui vérifie qu’une chaîne de caractère est un

palindrome, c’est-à-dire que la première et la dernière lettre sont identiques,
la seconde et l’avant-dernière sont identiques, la troisième et
l’antépénultième sont identiques, etc (exemple « radar »).
7. Ecrire un programme qui vérifie qu’une chaîne de caractère contient la lettre
e.
8. Ecrire un programme qui vérifie qu’une chaîne de caractère NE contient PAS
la lettre e.

bisgambiglia@[Link] 245
void f2_1_inversChar()
{ #define MAX_SIZE 128
StringT str1, str2; // type pré défini
int longueur, i; typedef char StringT[MAX_SIZE];

/* Entree du mot */
printf("Entrez un mot : ");
fgets(str1, MAX_SIZE, stdin);

/* INITIALISATION !!! */
longueur = strlen(str1);
longueur--;
/* Boucle pricipale pour copier un par un les caracteres de
str1
dans str2 a l'envers */
for (i = 0; i < longueur; i++) {
str2[i] = str1[longueur - 1 - i]; //autre solution
}
/* ATTENTION !!! NE PAS OUBLIER LE '\0' FINAL */
for(i=longeur ; i<=0 ; i--)
str2[longueur] = '\0'; {
str2[longeur - i] = str1[i];
/* Affichage du resultat */ }
printf("A l'envers : %s\n", str2);
}

bisgambiglia@[Link] 246
 /* Boucle pricipale : pour chaque caractere
/ de str1 examiné, du premier (indice 0)
******************************* jusqu'à l'avant-dernier (indice
***************** longueur-2) on le copie dans str2 et on
Lire un nom au clavier puis l’afficher en met un caractère '-' comme caractère
mettant un signe « - » entre chaque lettre. suivant dans str2 */

********************************** j = 0;
***********/ for (i = 0; i <= longueur-2 ; i++)
void f2_2_afficheSign() {
{ str2[j] = str1[i];
StringT str1, str2; j++;
int longueur, i, j; str2[j] = '-';
j++;
/* Entree d'un mot */ }
printf("Entrez un mot : "); /* On copie le dernier caractère de
fgets(str1, MAX_SIZE, stdin); str1 dans str2 sans mettre de
caractère '-' après */
/* INITIALISATION !!! */
str2[j] = str1[longueur-1];
longueur = strlen(str1);
j++;
longueur--;
str2[j] = '\0';
/* On ignore le RETURN final */
/* ATTENTION !!! NE PAS OUBLIER LE
'\0' FINAL*/
/* Affichage du résultat */
printf("Avec des '-' entre chaque
lettre : %s\n", str2);
}
bisgambiglia@[Link] 247
 Sources

 Programmer avec un langage - Historique,

relations binaires, théorie des langages. Cours
informatique programmation Rm di Scala -
[Link]

 Une introduction au Langage C - Jean-Jacques

Girardot, Marc Roelens - Septembre 2005

 [Link]

bisgambiglia@[Link] 248
 Sommaire
1. Rappels : Le Codage de l’information (2h)
2. Algorithmique (13h)
3. Introduction à la programmation (6h)
4. Programmation Orientée Objet (6h)
1. Introduction
2. UML
3. Objet
4. Classe
5. Encapsulation
6. Héritage
7. Polymorphisme
8. Constructeur
9. Conclusion
10. Exemples en C#

bisgambiglia@[Link] 249
 POO
Exemple en C#
using System;
using [Link];
using [Link];
namespace ConsoleApplication1
{
public class Taxi
{
public bool isInitialized;
public Taxi()
{
isInitialized = true;
}
}
class TestTaxi
{
static void Main()
{
Taxi t = new Taxi();
[Link]([Link]);
}
}
}

bisgambiglia@[Link] 250
 POO
Introduction

 Les langages orientés objets sont une nouvelle

méthode de programmation qui tend à se rapprocher
de notre manière naturelle d'appréhender le monde.
Les L.O.O. se sont surtout posé la question "Sur quoi
porte le programme ?". En effet, un programme
informatique comporte toujours des traitements, mais
aussi et surtout des données. Si la programmation
structurée s'intéresse aux traitements puis aux
données, la conception objet s'intéresse d'abord aux
données, auxquelles elle associe ensuite les
traitements. L'expérience a montré que les données
sont ce qu'il y a de plus stable dans la vie d'un
programme, il est donc intéressant d'architecturer le
programme autour de ces données
bisgambiglia@[Link] 251
 POO Technique qui consiste à
restituer sous une forme
compréhensible par
Introduction l'ordinateur un objet ou
un phénomène
 Définitions : quelconque.
 La notion d'objet : la programmation orientée objet
consiste à modéliser informatiquement un ensemble
d'éléments d'une partie du monde réel (que l'on appelle
domaine) en un ensemble d'entités informatiques. Ces
entités informatiques sont appelées objets. Il s'agit de
données informatiques regroupant les principales
caractéristiques des éléments du monde réel (taille, la
couleur, ...).
 La difficulté de cette modélisation consiste à créer une
représentation abstraite, sous forme d'objets, d'entités ayant
une existence matérielle (chien, voiture, ampoule, ...) ou
bien virtuelle (sécurité sociale, temps, ...).
bisgambiglia@[Link] 252
 POO
Introduction

 Vocabulaire objet :
 Encapsulation : c’est le fait de réunir à l'intérieur d'une
même entité (objet) le code (méthodes) + données
(attributs). Deux niveaux d’encapsulation sont définis :
 Privé les champs et les méthodes masqués sont dans la partie
privée de l’objet.
 Public les champs et les méthodes visibles sont dans la partie
interface de l’objet.
 Une classe est une sorte de container à partir duquel sont
engendrés les objets réels qui s’appellent des instances de
la classe considérée. Elle contient :
 Des attributs (ou champs, ou variables d’instances). Les attributs
Membres de la classe décrivent la structure de ses instances (les objets).
 Des méthodes (ou opérations de la classe). Les méthodes décrivent
les opérations qui sont applicables aux instances de la classe.

bisgambiglia@[Link] 253
 POO
Introduction

 Vocabulaire objet :
 Héritage : C’est un mécanisme très puissant qui permet de décrire des
structures génériques en transmettant depuis l’intérieur d’une même
classe toutes les propriétés communes à toutes les "sous-classes" de
cette classe. Par construction toutes les sous-classes d’une même classe
possèdent toutes les attributs et les méthodes de leur classe parent.
 Propriétés de l'héritage :
 Les attributs et les méthodes peuvent être modifiés au niveau de la sous-
classe qui hérite.
 Il peut y avoir des attributs et/ou des méthodes supplémentaires dans une
sous-classe.
 Une classe A qui hérite d’une classe B dispose implicitement de tous les
attributs et de toutes les méthodes définis dans la classe B.
 Les attributs et les méthodes définis dans A sont prioritaires par rapport
aux attributs et aux méthodes de même nom définis dans

bisgambiglia@[Link] 254
 POO
UML

 UML (en anglais Unified Modeling Language, «

langage de modélisation unifié ») est un langage
graphique de modélisation des données et des
traitements. C'est une formalisation très aboutie et
non-propriétaire de la modélisation objet utilisée en
génie logiciel.
 Représentation :
EtreHumain inst
String nom anc
e
int taille a___
int poids Smith
enum sexe 1.82
int age 84
void dormir() M
void manger() 28
bisgambiglia@[Link] 255
 POO
Objet

 Notion d’objet :
 Attributs : Il s'agit des données caractérisant l'objet. Ce sont des
variables stockant des informations d'état de l'objet
 Méthodes (appelées parfois fonctions membres): Les méthodes d'un
objet caractérisent son comportement, c'est-à-dire l'ensemble des
actions (appelées opérations) que l'objet est à même de réaliser. Ces
opérations permettent de faire réagir l'objet aux sollicitations
extérieures (ou d'agir sur les autres objets). De plus, les opérations sont
étroitement liées aux attributs, car leurs actions peuvent dépendre des
valeurs des attributs, ou bien les modifier
 Nom : L'objet possède une identité, qui permet de le distinguer des
autres objets, indépendamment de son état. On construit généralement
cette identité grâce à un identifiant découlant naturellement du
problème (par exemple un produit pourra être repéré par un code, une
voiture par un numéro de série, ...)

bisgambiglia@[Link] 256
 POO
Objet
 Un objet est un groupe de données structurées caractérisé par un
identifiant unique (nom) représentant le monde réel.
 Exemple : un article en stock est un objet

 Un objet est constitué attributs qui caractérisent sa structure

 Exemple : un article en stock est un objet caractérisé par :
 référence
 désignation
 prix unitaire
 Quantité

 Un objet est manipulé par des procédures appelées méthodes qui sont
caractérisées par une entête définissant leur nom, les paramètres d'appel et
de retour pour chacune d'elle
 Exemple : Nous pouvons définir comme méthodes de l'objet ARTICLE
 PrixTtc : Méthode permettant de calculer le prix TTC d'un article
 SortieArticle : Méthode permettant de diminuer la quantité en stock
 EntreeArticle : Méthode permettant d'augmenter la quantité en stock  

bisgambiglia@[Link] 257
 POO
Objet

 Exemple d‘objet :  Exemple d‘objet :

 Nom :  Nom :
 Voiture  Chien
 Attributs :  Attributs :
 Couleur  Tatouage
 Type  Couleur
 Moteur  Age
 Immatriculation  Fonction :
 Fonction :  Manger()
 Rouler()  Sortir()
 Dormir

bisgambiglia@[Link] 258
 POO
Classe

 Notion de classe :
 On appelle classe la structure d'un objet, c'est-à-dire la
déclaration de l'ensemble des entités qui composeront un
objet. Un objet est donc "issu" d'une classe, c'est le produit
qui sort d'un moule. En réalité on dit qu'un objet est une
instanciation d'une classe, c'est la raison pour laquelle on
pourra parler indifféremment d'objet ou d'instance
(éventuellement d'occurrence).
 Une classe est composée de deux parties:
 Les attributs (parfois appelés données membres): il s'agit
des données représentant l'état de l'objet
 Les méthodes (parfois appelées fonctions membres): il
s'agit des opérations applicables aux objets

bisgambiglia@[Link] 259
 POO
Classe

 Exemple d‘objet :  Exemple de classe :

 Nom :  Nom :
 aaa  EtreHumain
 Attributs :  Attributs :
 Smith
 Nom
La définition des
la création d'objet  Taille
 1.82 caractéristiques
répondant à ladeclasse  Sexe
 M l'objet constitue la
s'appelle  Poids
 82 l'instanciation
classe de l'objet  Age
 28  Fonction :
 Fonction :  Dormir
 Dormir()  Manger
 Manger()  Travailler
 Travailler()
bisgambiglia@[Link] 260
 POO
Classe

 Classe en C# :
Les fonctions ont une
class EtreHumain { influence sur les
// Attributs attributs, par exemple la
string nom; fonction manger() peut
int age; augmenter la valeur de
int taille; l’attributs poids
int poids;
enum sexe{homme,femme};
// Fonctions
void dormir(int temps);
void manger(); // instanciation :
void travailler(); // type nom = new constructeur()
… …
} EtreHumain aaa = new EtreHumain();
EtreHumain aab = new EtreHumain();
…
bisgambiglia@[Link] 261
 POO
Encapsulation

 Définitions :
 L'encapsulation en général est la notion de mettre une chose dans une
autre.
 En programmation orientée objet, l’encapsulation est l'idée de protéger
l'information contenue dans un objet et de ne proposer que des
méthodes de manipulation de cet objet.
 La fusion d'un bloc de code et d'un bloc de données est un concept
nouveau, celui d'encapsulation.
 Principe :
 L'encapsulation est basée sur la notion de services rendus. Une classe
fournit un certain nombre de services et les utilisateurs de cette classe
n'ont pas à connaître la façon dont ces services sont rendus.
 Il faut donc distinguer dans la description de la classe deux parties :
 La partie publique, accessible par les autres classes,
 La partie privée, accessible uniquement par les méthodes de la classe.

bisgambiglia@[Link] 262
 POO
Encapsulation

 Classe en C# : Il est vivement recommandé

de mettre les attributs d'une
class EtreHumain { classe dans la partie privée,
// Attributs ainsi protégés, les membres
privés d'une classe ne sont
public string nom;
pas directement
private int age; modifiables.
private int taille;
private int poids;
public enum sexe{homme,femme};
// Fonctions
public void dormir(int temps); Un objet est donc une boîte
public void manger(); noire autonome possédant
public void travailler(); des liaisons avec le monde
… extérieur : ses attributs (si
} ils sont publiques) et ses
méthodes.

bisgambiglia@[Link] 263
 LOO C#

Encapsulation

bisgambiglia@[Link] 264
 POO
Héritage

 Définitions :
 L’héritage est un principe de la programmation orientée
objet, permettant entre autres la réutilisabilité et
l'adaptabilité des objets. Elle se nomme ainsi car le principe
est en quelque sorte le même que celui d’un arbre
généalogique.

 L'héritage est le fait de pouvoir, à partir d'une classe

donnée, créer une nouvelle classe possédant tout ou
seulement certaines des caractéristiques (attributs et
fonction) de cet objet plus des modifications et ajout sur
son comportement (c'est à dire sur ses méthodes). On créer
ainsi un deuxième objet qui dérive du premier et hérite
d'une partie de ces caractéristiques.
! bisgambiglia@[Link] 265
 POO
Héritage

 Concepts de l’héritage :
 L’héritage permet de créer de nouvelles classes à partir de
classes existantes.
 Les classes dérivées obtenues sont des « classes filles », «
classes dérivées » ou « sous classes ».
 Les classes d’origine sont dites des « super classes », «
classes de base » ou « classes parentes ».
 Les sous classes peuvent hériter des attributs de la super
classe dont elles sont issues.
 Les sous classes peuvent avoir des attributs et des
méthodes qui leur sont propres.
 Certaines méthodes d’une super classe peuvent être
redéfinies dans les sous classes issues de celle-ci.

bisgambiglia@[Link] 266
 POO
Héritage

 Notation  :
 ClasseDeBase : CLASSE
  Privé:
  // membres privés ne sont accessibles que par les membres de la
classe
  Public :
  // membres publics sont accessibles par tous les membres de
l’application qui utilisent la classe
EtreHumain
Enfant
 Représentation : int taille
int poids int taille
enum sexe int poids
int age enum sexe
void dormir() int age
void manger() string ecole
void dormir()
void manger()
void jouer()
bisgambiglia@[Link] 267
 POO
Héritage

 Classe en C# :

class EtreHumain { class Enfant : EtreHumain {

// Attributs // Attributs
public string nom; public string ecole
private int age; // Fonctions
private int taille; public void jouer(int temps)
private int poids; …
public enum }
sexe{homme,femme};
// Fonctions
La nouvelle classe - la classe
public void dormir(int temps); dérivée - gagne toutes les
public void manger(); données non privées et le
public void travailler(); comportement de la classe de
… base en plus de toutes les autres
} données ou comportements
qu'elle définit pour elle-même.
bisgambiglia@[Link] 268
 LOO C#

Héritage

bisgambiglia@[Link] 269
 POO
Polymorphisme

 Définitions :
 En informatique, le polymorphisme est l'idée d'autoriser le
même code à être utilisé avec différentes classes, ce qui
permet des implémentations plus abstraites et générales.
 Le polymorphisme est lié à l'héritage. Il permet aux
utilisateurs d'accéder à des objets différents comme s'ils
étaient identiques sans se préoccuper du comportement
interne qui lui peut différer. Le polymorphisme permet à
des objets dérivant d'une même racine d'avoir la même
interface avec le monde tout en ayant une structure interne
différente (attributs et méthodes). C'est aussi un des
éléments majeur dans la réutilisation du code.

bisgambiglia@[Link] 270
 POO
Polymorphisme

 Principe :
 Plusieurs classes peuvent posséder une méthode de même
nom. Suivant la nature de l'objet auquel elle doit
s'appliquer, on appliquera telle ou telle méthode. Le
polymorphisme consiste à appeler la bonne méthode
d'après le type de l'objet implémenté.
 Exemple :
public class A {
public void affiche() {
[Link]("type A"); } A v1 = new A();
} [Link]();
public class B : A { B v2 = new B();
public void affiche() { [Link]();
[Link]("type B"); }
}

bisgambiglia@[Link] 271
 POO
Constructeur et Destructeur

 En programmation orientée objet, le constructeur d'une classe

est une méthode particulière appelée lors de l'instanciation.
 Lors de la déclaration d'une instance de classe (EtreHumain H
= new EtreHumain()), une méthode est appelée
automatiquement. Cette méthode qui permet d'initialiser les
objets de la classe dont elle dépend est appelée constructeur.
Elle est appelée après l'allocation d'espace mémoire destiné à
l'objet.
 Inversement, dans la plupart des langages une méthode est
exécutée automatiquement quand l'instance devient hors de
portée. Cette méthode qui est appelée avant la libération de
l'espace mémoire associé à l'objet est appelée destructeur.
 L'instanciation d'une classe correspond à la création d'une
instance de cette classe, c'est-à-dire d'un objet.
bisgambiglia@[Link] 272
 POO
 Classe en C# : Constructeur et Destructeur

class EtreHumain {
// Attributs
public string nom;
private int age;
EtreHumain a = new EtreHumain(Dus,22,1.78,77,0)
private int taille;
private int poids;
EtreHumain b = new EtreHumain(Smith,42,1.64,52,1)
public enum sexe{homme,femme};
// Constructeur
public EtreHumain(string nom; int age, int taille, int poids, int sexe)
{
nom = nom;
age = age;
taille = taille;
poids = poids;
sexe = sexe;
}
// Fonctions
public void dormir(int temps);
…
}
bisgambiglia@[Link] 273
 POO
Conclusion

 Ce qu'il faut retenir :

 La différence entre « classe » et « objet ». Une classe,
c'est un ensemble de variables et fonctions (attributs et
méthodes). Un objet, c'est une copie de la classe pour
pouvoir l'utiliser.

 Le principe d'encapsulation. Tous vos attributs doivent

être privés. Pour les méthodes, peu importe leur visibilité.

 On déclare une classe avec le mot-clé class suivi du nom de

la classe, et enfin deux accolades ouvrantes et fermantes
qui encercleront la liste des attributs et méthodes.
bisgambiglia@[Link] 274
 LOO
C#

bisgambiglia@[Link] 275
 LOO
C#

bisgambiglia@[Link] 276
using System; Résultats d'exécution de ce programme :
using [Link]; x * y - z + t = 36
using [Link]; x * y - (z + t) = 22
namespace CsAlgorithmique x*y%z+t=9
{ (( x * y) % z ) + t = 9
class AppliOperat_Arithme x*y%(z+t)=2
{ x *( y % ( z + t)) = 32
static void Main(string[] args)
{
int x = 4, y = 8, z = 3, t = 7, calcul;
calcul = x * y - z + t;
[Link](" x * y - z + t = " + calcul);
calcul = x * y - (z + t);
[Link](" x * y - (z + t) = " + calcul);
calcul = x * y % z + t;
[Link](" x * y % z + t = " + calcul);
calcul = ((x * y) % z) + t;
[Link]("(( x * y) % z ) + t = " + calcul);
calcul = x * y % (z + t);
[Link](" x * y % ( z + t ) = " + calcul);
calcul = x * (y % (z + t));
[Link](" x *( y % ( z + t)) = " + calcul);
}
}
}

bisgambiglia@[Link] 277
namespace CsAlgorithmique
{
class Application1
{
static void Main(string[] args)
{ /* inverse d'une suite de caractère dans un tableau
par permutation des deux extrêmes */
char[] Tablecar ={ 'a', 'b', 'c', 'd', 'e', 'f' };
int i, j;
[Link]("tableau avant : "
+ new string(Tablecar));
for (i = 0, j = 5; i < j; i++, j--)
{
char car;
car = Tablecar[i];
Tablecar[i] = Tablecar[j];
Tablecar[j] = car;
}
[Link]("tableau après : "
+ new string(Tablecar));
}
}
}
bisgambiglia@[Link] 278
namespace CsAlgorithmique
{
class Application2
{
static void Main(string[] args)
{ // recherche séquentielle dans un tableau
int [ ] table= {12,-5,7,8,-6,6,4,78};
int elt = 4, i;
for ( i = 0 ; i<8 ; i++ )
if (elt==table[i]) break ;
if (i == 8)
[Link]("valeur : " 
+elt+" pas trouvée.");
else
[Link] ("valeur : " 
+elt+" trouvée au rang :"+i);
}
}
}

bisgambiglia@[Link] 279
 POO en PHP

 [Link]
[Link]

 [Link]
rs-complet/[Link]

 [Link]
6-programmez-en-oriente-objet-en-php

bisgambiglia@[Link] 280
 POO en PHP

<?php
class SimpleClass
{
    // déclaration d'une propriété
    public $var = 'une valeur par défaut';
    // déclaration des méthodes
    public function displayVar() {
        echo $this->var;
    }
}
?>
bisgambiglia@[Link] 281
 POO en PHP

<?php
declare(strict_types=1);
class SimpleClass
{
    // déclaration d'une propriété
    public $var = 'une valeur par défaut';
    // déclaration des méthodes
    public function displayVar() {
        echo $this->var;
    }
}
?> bisgambiglia@[Link] 282
 Sources
1. [Link]
2. [Link]/docs/net3d/[Link]
3. [Link]
html

4. [Link]
n_informatique%29

5. [Link]
%[Link]

6. [Link]
-[Link]

7. [Link]
8. [Link]
9. Le langage C# dans bisgambiglia@[Link]
.Net [Link] 283
 A Savoir !!!
Notions complémentaires

 Pointeur (passage par valeur et par référence)

 Algorithmes de tri
 Gestion (écriture / lecture) des fichiers
 Pile et File (structure de donnée)
 Les arbres (structure de donnée)
 Les listes (type de donnée)
 La complexité des algorithmes
 Algorithmes fonctionnels
 Programmation fonctionnelle
 Makefile

bisgambiglia@[Link] 284