chapitre 1 rappel
TRANSCRIPT
![Page 1: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/1.jpg)
ALGORITHMIQUE & STRUCTURES
DE DONNÉES (ASD)
Université Saad Dahlab – Blida1
Faculté des Sciences
Département d’Informatique
Licence d’Informatique
Semestre 3 (2ème année)
Mme AROUSSI
2016-2017
Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/
![Page 2: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/2.jpg)
PRÉAMBULE
Pré-requis: Cours (Algo1, S1) + (Algo 2, S2).
Volume horaire hebdomadaire: 3H Cours + 3H
TD/TP
Évaluation: 2 Interrogations (I1, I2) + Test TP + Examen
final.
I1 noté sur 7,5 points; I2 noté sur 7,5 points et 5 points
assiduité
Un test TP noté sur 15 points et 5 points assiduité
Moyenne = (Examen x 2 + (TD + TP)/2) / 3
Coefficient 6; Crédits 6
2
![Page 3: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/3.jpg)
OBJECTIFS DU COURS
Comprendre les notions d’algorithme, de structures de données
et de complexité :
Élaborer des algorithmes performants et efficaces
Acquérir la connaissance des structures de données séquentielles
(LLC, Files et Piles), hiérarchiques (arbres) et des algorithmes de
base sur les tris.
Maîtriser la récursivité (simple, multiple, mutuelle, imbriquée)
Comprendre la notion de complexité d’un algorithme
Savoir estimer la complexité d’un algorithme itératif ou récursif 3
![Page 4: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/4.jpg)
CONTENU DU COURS
I. Rappels
II. Complexité des Algorithmes
III. Structures Séquentielles (Listes, Files, Piles)
IV. Récursivité
V. Structures Hiérarchiques (Arbres, ABR, AVL, Tas)
VI. Algorithmes de Tri
VII. Ensembles 4
![Page 5: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/5.jpg)
CHAPITRE I:
RAPPELS
Université Saad Dahlab – Blida 1
Faculté des Sciences
Département d’Informatique
Licence d’Informatique
Semestre 3 (2ème année)
Algorithmique & Structures de Données
Mme AROUSSI
2016-2017
Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/
![Page 6: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/6.jpg)
PLAN DU CHAPITRE I
Généralités sur l’Algorithmique
Algorithmique et Programmation
Qualités d’un Bon Algorithme
Langage Algorithmique utilisé
Tableaux
Pointeurs
Langage C 6
![Page 7: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/7.jpg)
7
Définition: Un algorithme est suite finie d’opérations
élémentaires constituant un schéma de calcul ou de résolution d’un
problème.
Historique : L’algorithmique est un terme d’origine arabe,
hommage à Al Khawarizmi (780-850) auteur d’un ouvrage décrivant
des méthodes de calculs algébriques.
GÉNÉRALITÉ SUR L’ALGORITHMIQUE
![Page 8: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/8.jpg)
8
GÉNÉRALITÉ SUR L’ALGORITHMIQUE
ÉTAPES DE CONCEPTION D’UN ALGORITHME
Analyse
Conception
Programmation
Test
Définition du problème en terme
de séquences d’opérations de calcul, de stockage de données
Définition précise des données,
des traitements et de leur séquencement
Traduction et réalisation de
l’algorithme dans un langage précis
Vérification du bon
fonctionnement de l’algorithme
![Page 9: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/9.jpg)
9
Définition : Un programme est la traduction d’un algorithme
dans un langage de programmation.
ALGORITHMIQUE & PROGRAMMATION
Langage de bas niveau
Langage de haut niveau
Évolution
Binaire, Assembleur
Procédural (Pascal, C),
Logique (Prolog), ....
Orienté Objet (C++, C#, Java),
....
![Page 10: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/10.jpg)
10
ALGORITHMIQUE & PROGRAMMATION DÉMARCHE DE PROGRAMMATION
Énoncé du problème
Analyse du problème
Algorithme Choisir un langage de
programmation
Programmation (traduction
l’algorithme en programme)
Programme (code source)
Compilation (traduction du code source en
code objet)
Traduction du code objet en code
machine exécutable, compréhensible par
l'ordinateur
Programme binaire
exécutable
Exécution du programme
Résultats
![Page 11: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/11.jpg)
11
QUALITÉ D’UN BON ALGORITHME
Correct: Il faut que le programme exécute correctement ses
tâches pour lesquelles il a été conçu.
Complet: Il faut que le programme considère tous les cas
possibles et donne un résultat dans chaque cas.
Efficace: Il faut que le programme exécute sa tâche avec
efficacité de telle sorte qu’il se déroule en un temps minimal et
qu’il consomme un minimum de ressources.
![Page 12: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/12.jpg)
12
ALGORITHME Nom_de_l’algorithme
DEBUT
manipulation des objets et modules déclarés
FIN
Entête
Environnement
Corps
Déclarations des objets et Modules utilisés
dans l’algorithme
LANGAGE ALGORITHMIQUE UTILISÉ
![Page 13: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/13.jpg)
13
SI expression logique ALORS
DSI
Bloc
FSI
SI expression logique ALORS
DSI
Bloc1
FSI
SINON
DSINON
Bloc2
FSINON
_
LANGAGE ALGORITHMIQUE UTILISÉ
LA CONDITIONNELLE ET L’ALTERNATIVE
![Page 14: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/14.jpg)
14
POUR var ALLANT DE vinit A vfinale FAIRE
DPOUR
bloc
FPOUR
TANT QUE condition FAIRE
DTQ
Bloc
FTQ
REPETER
Bloc
JUSQU'A condition
LANGAGE ALGORITHMIQUE UTILISÉ
LES BOUCLES
![Page 15: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/15.jpg)
Tout algorithme utilise des objets qui seront déclarés
dans son environnement.
A chaque objet, il faudra faire correspondre :
Un NOM qui permettra de le désigner et de le distinguer des autres
éléments,
Un TYPE qui indique la nature de l'ensemble dans lequel l'objet
prend ses valeurs,
Une VALEUR affectée à cet objet à un moment donné.
LANGAGE ALGORITHMIQUE UTILISÉ
LES OBJETS
15
![Page 16: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/16.jpg)
ALGORITHME nom_algorithme
Déclarations des étiquettes
Déclarations des constantes
Déclarations des types
Déclarations des variables
Déclarations des sous-programmes (fonctions)
DEBUT
corps de l'algorithme
FIN 16
![Page 17: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/17.jpg)
17
Un type définit l'ensemble des valeurs que peut prendre un objet
qui y est défini ainsi que les opérations autorisées sur cet objet
LANGAGE ALGORITHMIQUE UTILISÉ
DÉCLARATION DE TYPES
Scalaire ( Entier, Booléen et
caractère)
Standard
Enuméré
Intervalle
Simple
TYPE
Structuré
Non Scalaire (Réel)
Non
Standard
Tableau
Enregistrement (structure)
Chaine de caractère
Ensemble
![Page 18: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/18.jpg)
18
Exercice 1: Ecrire un algorithme qui
permet de résoudre une équation du second
degré ax2 +bx+c = 0
LANGAGE ALGORITHMIQUE UTILISÉ
EXERCICE
![Page 19: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/19.jpg)
19
L'algorithme de résolution de l'équation ax2 + bx + c = 0
(a 0) dans l'ensemble des réels est le suivant:
1. Calcul du discriminant, soit = b2 - 4 a.c
2. Si > 0 alors il y a deux solutions données par les
formules:
x1 = -b + / 4 a . c
x2 = -b - / 4 a. c
3. Si = 0, alors il y a une racine double donnée par
la formule:
x = - b / 2 a
4. Si < 0, alors il n y a pas de solution.
LANGAGE ALGORITHMIQUE UTILISÉ
SOLUTION
![Page 20: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/20.jpg)
20
ALGORITHME Equation
VAR a, b, c, Delta : REEL
DEBUT
LIRE(a, b, c)
Delta ← b*b – (4*a*c)
SI (Delta > 0) Alors
DSI
ECRIRE( "la première racine est ", - b +Racine(Delta)/(4*a*c))
ECRIRE( "la deuxième racine est ", - b - Racine(Delta)/(4*a*c))
FSI
SINON
DSIN
SI (Delta = 0) alors ECRIRE( " Une racine double ", - b / (2*a)
SINON ECRIRE( " Pas de racine réelle " )
FSIN
FIN
LANGAGE ALGORITHMIQUE UTILISÉ
SOLUTION
![Page 21: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/21.jpg)
PLAN DU CHAPITRE I
Généralités sur l’Algorithmique
Algorithmique et Programmation
Qualités d’un Bon Algorithme
Langage Algorithmique utilisé
Tableaux
Pointeurs
Langage C 21
![Page 22: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/22.jpg)
C’est un objet décomposé en plusieurs éléments de même
type et dont chacun de ces éléments est repéré par un
indice (ou index).
Le nombre d'éléments du tableau constitue sa taille.
Le nombre d’indices qui permet de désigner un élément particulier
est appelée dimension du tableau.
Le type de l’indice est souvent intervalle [0 .. Taille-1].
TABLEAUX
NOTIONS DE BASE
22
7 5 6 3 2 1 1 4 éléments
0 1 2 3 4 5 6 7 Indices
![Page 23: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/23.jpg)
La déclaration d’un tableau se fait en précisant le mot
TABLEAU, suivi de sa taille entre crochets et du type des
éléments.
Type Type_tableau = TABLEAU [taille] DE type_des_éléments, et
Nom_du_tableau : Type_Tableau, ou
Nom_du_tableau : TABLEAU [taille] DE type_des_éléments
L’accès à un élément du tableau s’effectue en précisant le nom du
tableau suivi de la valeur de l’indice entre crochets, e.g: Tab[1].
L'accès à un élément du Tableau peut être direct ou séquentiel.
TABLEAUX
NOTIONS DE BASE
23
![Page 24: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/24.jpg)
On distingue généralement deux classes d’algorithmes:
Les algorithmes de parcours en vu de réaliser un traitement
donné
Les algorithmes de parcours en vu de rechercher une valeur
donnée.
Parmi les algorithmes traitant les tableaux à une
dimension:
Rechercher une valeur dans un tableau
si tableau ordonné alors recherche dichotomique
si tableau non ordonné alors recherche séquentielle
TABLEAUX
ALGORITHMES
24
![Page 25: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/25.jpg)
Parmi les algorithmes traitant les tableaux à une
dimension:
La recherche d’une valeur
L’insertion d’une valeur
La suppression (logique ou physique) d’une valeur
Le remplacement d’une valeur par une autre (la modification)
L’interclassement de deux tableaux ordonnés.
L’union et l’intersection de deux tableaux.
Le tri d’un tableau: tri par sélection, tri par Bulles, tri par
insertion, tri par fusion, tri rapide, …..
TABLEAUX
ALGORITHMES
25
![Page 26: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/26.jpg)
Un tableau multidimensionnel est considéré comme étant un
tableau dont les éléments sont eux mêmes des tableaux.
Il se définit de la manière suivante :
Type Type_tableau = TABLEAU [N1, N2, ....., Nd] DE
type_des_éléments, et Nom_du_tableau : Type_Tableau,
ou
Nom_du_tableau: TABLEAU [N1, N2, ....., Nd] DE
type_des_éléments
d est la dimension du tableau et Ni désigne le nombre d’éléments
dans chaque dimension.
Le nombre de dimensions n'est pas limité .
TABLEAUX MULTIDIMENSIONNELS
26
![Page 27: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/27.jpg)
L'accès à un élément du tableau se fera par l'expression
Nom_du_tableau[i1][i2] …[id] ou
Nom_du_tableau[i1, i2, …, id] .
Exemple: un tableau d'entiers positifs à deux dimensions
(3 lignes, 4 colonnes) se définira avec la syntaxe suivante :
Tab : tableau[0..2, 0..3] d’entier
Le rangement en mémoire centrale du tableau se fait ligne par ligne.
TABLEAUX MULTIDIMENSIONNELS
27
Représentation du tableau
Tab[0,0] Tab[0,1] Tab[0,2] Tab[0,3]
Tab[1,0] Tab[1,1] Tab[1,2] Tab[1,3]
Tab[2,0] Tab[2,1] Tab[2,2] Tab[2,3]
![Page 28: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/28.jpg)
Recherche séquentielle dans un tableau non ordonné
Recherche séquentielle dans un tableau ordonné
Recherche dichotomique dans un tableau ordonné
On parle d'un tableau ordonné quand l'ensemble des valeurs
possibles est muni d'une relation d'ordre. De plus, un
tableau est dit ordonné ou trié en ordre croissant si quelque
soit i dans [0, n-1] : T[i] <= T[i+1].
TABLEAUX
EXERCICES
28
![Page 29: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/29.jpg)
PLAN DU CHAPITRE I
Généralités sur l’Algorithmique
Algorithmique et Programmation
Qualités d’un Bon Algorithme
Langage Algorithmique utilisé
Tableaux
Pointeurs
Langage C 29
![Page 30: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/30.jpg)
Une variable est destinée à contenir une valeur du type
avec lequel elle est déclarée. Physiquement, cette valeur se
situe en mémoire.
Exemple:
x: entier;
x 10;
POINTEURS
VERSUS VARIABLES
30
![Page 31: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/31.jpg)
Un pointeur est aussi une variable destinée à contenir une
adresse mémoire, c.-à-d. une valeur identifiant un
emplacement en mémoire.
Pour différencier un pointeur d'une variable ordinaire, on fait
précéder son nom du signe '*' lors de sa déclaration.
Tout pointeur est associé à un type d’objet. Ce type est celui
des objets qui sont manipulables grâce au pointeur.
Les opérations les plus simples sur un pointeur sont les
suivantes :
affectation d’une adresse au pointeur ;
utilisation du pointeur pour accéder à l’objet dont il contient l’adresse.
POINTEURS
DÉFINITIONS ET OPÉRATIONS
31
![Page 32: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/32.jpg)
Exemple:
x: entier; x 10; px: * entier;
px &x; // affectation d’une adresse au pointeur ;
*px 20
POINTEURS
DÉFINITIONS ET OPÉRATIONS
32 20
![Page 33: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/33.jpg)
La déclaration de variables réserve de l'espace en
mémoire pour ces variables pour toute la durée de vie du
programme c’est ce qu’on appelle l’allocation statique.
Elle impose par ailleurs de connaître avant le début de
l'exécution l'espace nécessaire au stockage de ces
variables et en particulier la dimension des tableaux.
Or dans de nombreuses applications, le nombre
d'éléments d'un tableau peut varier d'une exécution du
programme à l'autre d’où l’allocation dynamique.
POINTEURS
ALLOCATION DYNAMIQUE DU MÉMOIRE
33
![Page 34: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/34.jpg)
Pour ce faire, on utilise des pointeurs.
Quand on fait une allocation dynamique de mémoire, on
obtient en retour un pointeur sur la zone mémoire allouée.
(fonction allouer(): pointeur)
Exemple:
X: *entier;
X(*entier) Allouer();//réserver de la mémoire pour un entier
Libérer(X); // libérer la mémoire précédemment réservée.
POINTEURS
ALLOCATION DYNAMIQUE DU MÉMOIRE
34
![Page 35: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/35.jpg)
Le tableau est de grandeur statique, i.e. qu’il est
impossible de les changer de taille après la compilation.
Il est cependant possible de changer la taille après la
compilation. C’est ce qu’on appelle les tableaux
dynamiques.
Pour faire des tableaux dynamiques, il faut réserver un
espace mémoire d’une taille donnée puis d’assigner un
pointeur à cet espace mémoire.
POINTEURS
& LES TABLEAUX
35
![Page 36: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/36.jpg)
Pour faire des tableaux dynamiques, il faut réserver un
espace mémoire d’une taille donnée puis d’assigner un
pointeur à cet espace mémoire.
Exemple:
Tab: *entier;
Tab (*entier)Allouer_Tableau(n);
X Tab[0];
Libérer(tab);
POINTEURS
& LES TABLEAUX
36
![Page 37: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/37.jpg)
Un pointeur sur caractère peut pointer sur un seul caractère
isolé ou sur les éléments d'un tableau de caractères. Ce type
de pointeur peut en plus contenir l'adresse d'une chaîne de
caractères constants et il peut même être initialisé avec une
telle adresse.
Exemple:
C: * caractère;
C "Ceci est une chaîne de caractères constante";
Pour une chaîne de caractères, on peut tester la présence du
caractère de fin de chaîne ‘\0’.
POINTEURS
& CHAÎNES DE CARACTÈRES
37
![Page 38: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/38.jpg)
Une autre utilité des pointeurs est de permettre à des
fonctions d'accéder aux données elles même et non à des
copies.
Exemple:
Procedure permuter(x, y: *entier)
Var
Tmp; entier;
Debut
Tmp *x;
*x *y;
*y tmp;
Fin
POINTEURS
COMME PARAMÈTRES DE PROCÉDURES
38
![Page 39: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/39.jpg)
Les objets de type structure (enregistrement) possèdent
une adresse, correspondant à l'adresse du premier élément
du premier membre de la structure.
Exemple:
Eleve : structure {
nom: tableau de caractère [20];
Date: entier;
};
P: * eleve; // déclarer un pointeur vers structure
(*p).date // accéder à un élément de structure
POINTEURS
& STRUCTURES
39
![Page 40: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/40.jpg)
On a souvent de modèles de structure dont un des
membres est un pointeur vers une structure de même
modèle. On parle de l’auto-référence
Cette représentation permet de construire des listes
chaînées et des arbres.
Exemple:
POINTEURS
& STRUCTURES
40
Listes chainées Arbres binaires
maillon: structure {
valeur: entier;
suivant: * maillon;
};
noeud: structure {
valeur: entier;
Fils_gauche: * noeud;
Fils_droit: * nœud;
};
![Page 41: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/41.jpg)
PLAN DU CHAPITRE I
Généralités sur l’Algorithmique
Algorithmique et Programmation
Qualités d’un Bon Algorithme
Langage Algorithmique utilisé
Tableaux
Pointeurs
Langage C 41
![Page 42: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/42.jpg)
Le langage C est né au début des années 1970 dans les
laboratoires AT&T aux Etats-Unis dans le but d’améliorer le
langage existant « B ».
C’est un langage de bas niveau dans le sens où il permet
l’accès aux données (bits, octets, adresses) que manipulent les
machines et qui ne sont pas souvent disponibles à partir de
langages évolués tels que Fortran, Pascal ou ADA
Il a été conçu pour l’écriture de systèmes d’exploitation et du
logiciel de base; Plus de 90% du noyau du système UNIX est
écrit en langage C.
LANGAGE C
PRÉSENTATION
42
![Page 43: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/43.jpg)
Sa popularité : Il possède une communauté très importante
et de nombreux tutoriels et documentations. De plus, il existe
beaucoup de programmes et de bibliothèques développés en C.
Sa rapidité : ce qui en fait un langage de choix pour tout
programme où le temps de réponse (exécution) est crucial.
Sa légèreté : ce qui le rend utile pour les programmes
embarqués où la mémoire disponible est faible.
Sa portabilité : un programme développé en C marche
théoriquement sur n’importe quelle plateforme (Windows,
Linus, Unix, Mac, …)
LANGAGE C
POURQUOI L’APPRENDRE?
43
![Page 44: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/44.jpg)
C est un langage qui possède des règles. Ces règles ont été
définies par des informaticiens professionnels et sont toutes
regroupées dans ce que l’on appelle la norme du langage.
Cette norme sert de référence à tous les programmeurs.
Il existe plusieurs normes : l’ANSI en 1989 (C89 ), l’ISO en
1990 (C90), le C99 et le C11.
Dans ce cours, nous allons nous servir de la norme utilisé C89
(http://flash-gordon.me.uk/ansi.c.txt).
En effet, même si c’est la plus ancienne et qu’elle semble restrictive à
certains, elle permet néanmoins de développer avec n’importe quel
compilateur sans problème, contrairement aux normes C99 et C11.
De plus, il est très facile ensuite de passer aux normes plus récentes.
LANGAGE C
NORME
44
![Page 45: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/45.jpg)
Le strict minimum pour programmer en C se résume en
trois points:
Un éditeur de texte: pour écrire le code source.
Un compilateur: pour transformer le code en un fichier
exécutable compréhensible par le processeur.
Un débogueur: fondamentalement, il n’est pas indispensable,
mais il est très utile pour chasser les bugs et vérifier le
comportement de son programme.
LANGAGE C
OUTILS
45
![Page 46: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/46.jpg)
Il existe deux moyens de récupérer tous ces logiciels :
On les prend séparément, et dans ce cas il faut compiler par
soi-même via l’invite de commande,
On utilise un environnement ou logiciel qui intègre les trois
logiciels: un Environnement de Développement Intégré (EDI)
ou Integrated Development Environment (IDE).
De nombreux IDE sont disponibles pour Windows:
Code::Blocks, Dev-C++, Visual C++,.....
Dans les TPs, nous allons nous servir du Code::Blocks
(http://www.codeblocks.org/downloads/binaries)
LANGAGE C
OUTILS
46
![Page 47: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/47.jpg)
Les “mots” du langage C peuvent être classés en 6
groupes élémentaires auxquels il convient d’ajouter les
commentaires au code source.
les mot-clés,
les constantes,
les identificateurs,
les chaines de caractères,
les opérateurs,
les signes de ponctuation,
LANGAGE C
CONCEPTS DE BASE: COMPOSANTS
47
![Page 48: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/48.jpg)
Le langage C contient 32 mots-clés qui ne peuvent pas
être utilisés comme identificateurs :
les spécificateurs de stockage : auto, register, static,
typedef
les spécificateurs de type :char, double, float, int, long,
short, signed, unsigned, struct, enum, union, void
les qualificateurs de type :const, volatile
les instructions de contrôle :break, case, continue, default,
for, while, do, if, else, goto, switch
les autres : return, sizeof, extern
LANGAGE C
CONCEPTS DE BASE: COMPOSANTS
48
![Page 49: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/49.jpg)
Le rôle des identificateurs est de donner un nom à une
entité du programme.
Un identificateur peut désigner le nom d’une variable, d’une
fonction, ou d’un type défini par typedef, struct, union ou
enum.
Quelques règles pour le choix des identificateurs :
Ils ne doivent pas être choisi parmi les mots clés
Un identificateur est une chaîne de caractères choisis parmi
les chiffres et les lettres NON ACCENTUEES, en tenant
compte de leur casse (Majuscule ou minuscules). On peut aussi
utiliser le tiret bas (_)
LANGAGE C
CONCEPTS DE BASE: COMPOSANTS
49
![Page 50: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/50.jpg)
Quelques règles pour le choix des identificateurs :
Ils ne doivent pas être choisi parmi les mots clés
Un identificateur est une chaîne de caractères choisis parmi
les chiffres et les lettres NON ACCENTUEES, en tenant
compte de leur casse (Majuscule ou minuscules).
On peut aussi utiliser le tiret bas (_)
Le premier caractère de la chaîne ne doit cependant pas être un chiffre
et il vaut mieux que qu’il ne soit pas le tiret bas car il est souvent
employé pour les variables globales de l’environnement C.
Il se peut que le compilateur tronque les identificateurs au de là d’une
certaine longueur (supérieure en général à 31 caractères).
LANGAGE C
CONCEPTS DE BASE: COMPOSANTS
50
![Page 51: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/51.jpg)
Un commentaire dans le code source débute par /* et se
termine par */ :
/* ceci est un petit commentaire dans un code source */
On peut également mettre des commentaires courts en une
seule ligne en utilisant //, mais il vaut mieux d’utiliser /* */ qui
permet d’écrire des commentaires sur plusieurs lignes.
Les commentaires, bien optionnels, sont fondamentaux. En
effet, ils permettent une compréhension plus facile d’un code
laissé de coté pendant des semaines et sont utiles lors de la
maintenance des programmes
LANGAGE C
CONCEPTS DE BASE: COMPOSANTS
51
![Page 52: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/52.jpg)
Une expression est une suite de composants
élémentaires qui est syntaxiquement correcte.
x=1 ou (i>=1)&&(i<11)&&(i%2 !=0)
Une instruction est une expression suivie par un point-
virgule (;).
Plusieurs instructions peuvent être réunies entre
accolades pour former une instruction composée ou
bloc, syntaxiquement équivalent à une instruction.
if(x!=0)
{z=y/x;
t=y%x;}
LANGAGE C
CONCEPTS DE BASE: COMPOSANTS
52
![Page 53: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/53.jpg)
Une instruction composée d’un spécificateur de type et
d’une liste d’identifiant séparés par une virgule est une
déclaration.
int a, b;
double c;
char message[256];
float d=1.5, x ;
Toute variable utilisée en C doit faire l’objet d’une
déclaration avant d’être utilisée.
LANGAGE C
CONCEPTS DE BASE: COMPOSANTS
53
![Page 54: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/54.jpg)
Tout programme C doit contenir au moins une fonction :
C’est la fonction main (fonction principale). L’exécution
du programme commence par l’appel à cette fonction.
LANGAGE C
CONCEPTS DE BASE: STRUCTURE D’UN PROGRAMME
54
![Page 55: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/55.jpg)
La fonction main retourne un objet du type type via une
instruction return resultat ; où resultat doit être
l’identificateur d’une variable de type type .
LANGAGE C
CONCEPTS DE BASE: STRUCTURE D’UN PROGRAMME
55
![Page 56: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/56.jpg)
Un programme C est composé d’un ensemble de
fonctions, appelées fonctions secondaires ou auxiliaires
qui sont décrite de la manière suivante :
type FonctionAuxiliaire (arguments ) {
déclaration des variables internes
instructions
return resultat ;}
LANGAGE C
CONCEPTS DE BASE: STRUCTURE D’UN PROGRAMME (FONCTIONS)
56
![Page 57: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/57.jpg)
type FonctionAuxiliaire (arguments )
La première ligne donne le prototype de la fonction. Elle
spécifie :
le nom de la fonction,
le type des paramètres qui doivent lui être fournis séparés par
des virgules
le type de la valeur qu’elle retourne.
Les prototypes des fonctions secondaires doivent être
placés avant la fonction main. On parle de déclaration de
fonctions.
LANGAGE C
CONCEPTS DE BASE: STRUCTURE D’UN PROGRAMME (FONCTIONS)
57
![Page 58: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/58.jpg)
type FonctionAuxiliaire (arguments ) {
déclaration des variables internes
instructions
return resultat ;}
Le corps de la fonction (entre les accolades) est la suite
d’instructions qui doivent être accomplies lorsque la
fonction est appelée.
Les corps de fonctions peuvent quant à eux être placés
indifféremment avant ou après la fonction principale.
LANGAGE C
CONCEPTS DE BASE: STRUCTURE D’UN PROGRAMME (FONCTIONS)
58
![Page 59: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/59.jpg)
Les directives au préprocesseur indiquent quelles bibliothèques de
fonctions prédéfinies on souhaite pouvoir utiliser dans le programme.
Le plus souvent, la forme des directives au préprocesseur est sous la
forme :
#include<chemin/vers/la/bibliotheque.h>
#include<stdio.h> pour utiliser les fonctions qui permettent de lire et
d’écrire dans les entrées/sorties standard
#include<math.h> pour utiliser les fonctions qui permettent de lire et
d’écrire dans les entrées/sorties standard
#include<stdlib.h> pour utiliser des fonctions traitant de l’allocation
mémoire, de conversion des chaines de caractères en type numériques
ou de tirages à l´aléatoire.
LANGAGE C
CONCEPTS DE BASE: STRUCTURE D’UN PROGRAMME (DIRECTIVES)
59
![Page 60: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/60.jpg)
LANGAGE C
CONCEPTS DE BASE: STRUCTURE D’UN PROGRAMME (EXEMPLE)
60
![Page 61: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/61.jpg)
Le langage C est un langage typé : toutes les variables et
les constantes, ainsi que les valeurs retournées par les
fonctions sont d’un type spécifié.
Les types de base en C concernent :
les caractères,
les nombres entiers,
les nombres flottants ou réels,
le void, qui représente le vide (on rien). Il n’est pas possible de
déclarer une variable de type void mais ce type est utile,
notamment pour spécifier qu’une fonction ne prend pas
d’argument ou qu’elle ne revoie pas de valeur.
LANGAGE C
CONCEPTS DE BASE: TYPES DE DONNÉES PRÉDÉFINIS
61
![Page 62: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/62.jpg)
Le type caractère ou char (de l’anglais “character”)
permet de représenter les caractères de la machine
utilisée qui sont représentés sous forme d’entiers
conforme au jeu de caractères ISO-8859.
Ce jeu de caractère est codé sur 8 bits (un octet) dont les
128 premiers caractères correspondent au code ASCII, les
128 derniers étant utilisés pour coder les caractères
spécifiques (accentués, cyrilliques, de la langue arabe,
etc...)
LANGAGE C
CONCEPTS DE BASE: TYPES DE DONNÉES PRÉDÉFINIS
62
![Page 63: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/63.jpg)
Le mot-clé désignant une donnée de type entier est int
(de l’anglais integer).
On peut faire préceder le mot-clé int par un attribut de
précision (short ou long) et/ou d’un attribut de
représentation (signed ou unsigned).
LANGAGE C
CONCEPTS DE BASE: TYPES DE DONNÉES PRÉDÉFINIS
63
![Page 64: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/64.jpg)
Remarque à propos des booléens : Le langage C
(jusqu’à la norme C99) ne fournit pas de type booléen. La
valeur entière 0 prend la valeur de vérité FAUX et toutes
les autres valeurs entières prennent la valeur de vérité
VRAI. Autrement dit :
toute expression utilisant des opérateurs booléens, retourne 0
si l’expression est fausse, et retourne quelque chose de non
nul si l’expression est vraie
LANGAGE C
CONCEPTS DE BASE: TYPES DE DONNÉES PRÉDÉFINIS
64
![Page 65: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/65.jpg)
Les types float, double et long double sont utilisés
pour représenter des nombres à virgule flottante, qui
correspondent à des approximations de nombres réels à
des degrés de précision différents.
LANGAGE C
CONCEPTS DE BASE: TYPES DE DONNÉES PRÉDÉFINIS
65
![Page 66: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/66.jpg)
Une expression est une suite de symboles formée à
partir de constantes littérales, d’identificateurs et
d’opérateurs:
-x,
– x+12,
– (x>4)&&(x<10).
Une expression est destinée à être évaluée. Elle a
toujours un type et une valeur.
LANGAGE C
CONCEPTS DE BASE: EXPRESSIONS
66
![Page 67: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/67.jpg)
L’affectation en C est symbolisée par le signe =.
variable = expression
Cet opérateur évalue l’expression « expression » et affecte
le résultat à la variable « variable » .
L’affectation effectue une conversion de type implicite : si
la variable et le résultat de l’expression ne sont pas du
même type, alors le résultat de l’expression est converti
dans le type de variable .
Si la conversion est impossible, alors un message d’erreur
est renvoyé.
LANGAGE C
CONCEPTS DE BASE: OPÉRATEURS (AFFECTATION)
67
![Page 68: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/68.jpg)
Puisque tous les types sont représentés sous forme
binaire (0 et 1), on peut convertir un objet d’un certain
type dans un autre type. On parle de l’opération de
transtypage (cast en anglais).
Cette opération peut être réalisée de deux manières :
Conversion implicite : qui consiste en une modification du
type de donnée effectuée automatiquement par le compilateur
int x;
x = 8.324;
x contiendra après affectation la valeur 8.
LANGAGE C
CONCEPTS DE BASE: OPÉRATEURS (TRANSTYPAGE)
68
![Page 69: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/69.jpg)
Cette opération peut être réalisée de deux manières :
Conversion implicite : qui consiste en une modification du type
de donnée effectuée automatiquement par le compilateur
int x; x = 8.324; //x contiendra après affectation la valeur 8.
Conversion explicite (appelée aussi opération de cast) consiste
en une modification du type de donnée forcée. L’opérateur de cast
est tout simplement le type de donnée dans lequel on désire
convertir une variable, entre des parenthèses précédant la
variable.
int x; x = (int) 8.324;//x contiendra après affectation la valeur 8.
La conversion explicite est à privilégier car elle n’est
pas ambigüe.
LANGAGE C
CONCEPTS DE BASE: OPÉRATEURS (TRANSTYPAGE)
69
![Page 70: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/70.jpg)
Les opérateurs arithmétiques classiques sont :
l’opérateur unaire de changement de signe : -,
les quatre opérations usuelles : +, -, *, /,
l’opérateur modulo : % qui donne le reste de la division entière
Les opérateurs d’affectation composée usuels sont
les suivants : += , -= , *= , /= , %=
Ce “raccourcis” (exp1 op= exp2) est équivalent à exp1 =
exp1 op exp2
L’avantage de ces notations est que exp1 n’est évaluée qu’en
seule fois lorsqu’on utilise l’opérateur composé, alors qu’elle
est évaluée 2 fois sinon.
LANGAGE C
CONCEPTS DE BASE: OPÉRATEURS (ARITHMÉTIQUES)
70
![Page 71: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/71.jpg)
Les opérations du type i=i+1 ou j=j-1 apparaissent très
souvent dans des boucles. Le langage C mis à notre
disposition l’opérateur d’incrémentation ++ et
l’opérateur de décrémentation - -.
Ces deux opérateurs s’utilisent en suffixe ou en préfixe :
les instructions i=i+1;, i++; et ++i; incrémente i de 1.
La différence réside dans la valeur de l’expression :
int i=5,j,k; int i=7,l,m;
j=i++; /* j=5 puis i=6 */ l=i--; /* l=7 puis i=6 */
k=++i; /* i=7 puis k=7 */ m=--i; /* i=5 puis m=5 */
LANGAGE C
CONCEPTS DE BASE: OPÉRATEURS (ARITHMÉTIQUES)
71
![Page 72: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/72.jpg)
Pour comparer deux expressions exp1 et exp2 , on dispose
des opérateurs booléens de comparaison classiques :
Egalité : exp1 == exp2 ,
Inégalités strictes : exp1 < exp2 et exp1 > exp2 ,
Inégalités larges : exp1 <= exp2 et exp1 >= exp2 ,
Différence : exp1 != exp2 .
Les deux expressions exp1 et exp2 sont évaluées puis
comparées. Si la relation est fausse, alors cet opérateur
renvoie false (équivalent à l’entier 0) et renvoie true
(équivalent à un entier non nul) si la relation est vérifiée.
LANGAGE C
CONCEPTS DE BASE: OPÉRATEURS (DE COMPARAISON)
72
![Page 73: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/73.jpg)
Les opérateurs logiques sont
la négation : !(exp ),
le ET logique : exp1 && exp2 ,
le OU logique : exp1 || exp2.
De même que les opérateurs de comparaison, les deux
expressions exp1 et exp2 sont évaluées puis comparées.
Si la relation est fausse, alors cet opérateur renvoie false
(équivalent à l’entier 0) et renvoie true (équivalent à un
entier non nul) si la relation est vérifiée.
LANGAGE C
CONCEPTS DE BASE: OPÉRATEURS (LOGIQUES)
73
![Page 74: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/74.jpg)
L’opérateur d’affectation conditionnel ternaire
exp1 ? exp2 : exp3
Cet opérateur renvoie exp2 si exp1 est vraie et renvoie
exp3 sinon.
Exemple : l’instruction m= a>b? a:b; affecte à m le
maximum de a et de b
LANGAGE C
CONCEPTS DE BASE: OPÉRATEURS
74
![Page 75: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/75.jpg)
L’opérateur sizeof permet de calculer la taille
correspondant à un type.
sizeof (descripteur-de-type) représente la taille
(exprimée en octet) qu’occuperait en mémoire un objet
possédant le type indiqué
sizeof exp représente la taille qu’occuperait en
mémoire un objet possédant le même type que exp.
sizeof tab où tab est un tableau de type t de taille n.
Cette formule exprime le nombre d’octets (n * sizeof(t)
) qu’occuperait le tableau.
LANGAGE C
CONCEPTS DE BASE: OPÉRATEURS
75
![Page 76: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/76.jpg)
Ordre de priorité des opérateurs (par ordre décroissant) :
1. ( ), [ ]
2. - unaire, !, ++, - - , sizeof
3. * , / , %
4. +, -
5. <, >= , <= , >
6. == , !=
7. &&
8. ||
9. ?:
10.=, *= , /= , += , -= , %=
LANGAGE C
CONCEPTS DE BASE: OPÉRATEURS (PRIORITÉS)
76
![Page 77: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/77.jpg)
Une instruction de branchement conditionnel a la forme
suivante :
if( test ){
instructionsIF }
else{
instructionsELSE }
Les accolades ne sont pas nécessaires si le bloc d’instruction IF
ou ELSE ne contient qu’une seule instruction.
Toutes les tests doivent être entre parenthèses.
Le bloc else est optionnel
LANGAGE C
CONCEPTS DE BASE: STRUCTURES DE CONTRÔLE (CHOIX)
77
![Page 78: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/78.jpg)
Le bloc switch est une instruction de choix multiple qui
permet de choisir un bloc d’instructions à réaliser parmi un
ensemble d’instructions possibles, en fonction de la valeur
d’une expression.
switch( exp ){
case val-1 : instructions-1
break ;
case val-2 : instructions-2
break ;
...
case val-N : instructions-N
break ;
default : instructions
}
LANGAGE C
CONCEPTS DE BASE: STRUCTURES DE CONTRÔLE (CHOIX MULTIPLE)
78
![Page 79: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/79.jpg)
Si l’évaluation de l’expression exp donne
une valeur v parmi val-1 , val-2 , ... val-
N alors les instructions instructions-v
relatives à cette valeurs sont effectuées.
L’instruction break fait ensuite sortir le
programme du block switch.
Le cas default permet d’englober toutes
les cas où exp donne une valeur qui n’est
pas parmi val-1 , val-2 , ... val-N
LANGAGE C
CONCEPTS DE BASE: STRUCTURES DE CONTRÔLE (CHOIX MULTIPLE)
79
![Page 80: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/80.jpg)
Le langage C offre trois structures pour exécuter une boucle :
LANGAGE C
CONCEPTS DE BASE: STRUCTURES DE CONTRÔLE (BOUCLES)
80
Tant que Pour
while( exp ){
instructions
}
do{
instructions
} while( exp ) ;
for( exp1 ; exp2 ; exp3 ){
instructions
}
exp est le test de continuation qui renvoie un booléen
exp1: l’initialisation, exp2: la condition de continuation,
exp3: l’´evolution de la variable dont
dépend la condition de continuation
Tant que le test de continuation est
vrai, le corps de la
boucle est effectué.
Faire le corps de la boucle tant que le
test de
continuation est
vrai
Une formulation équivalente plus intuitive est la suivante :
exp1 ;
while(exp2 ){
exp3 ;
instructions }
![Page 81: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/81.jpg)
Ces trois instructions sont équivalentes. Cependant,
Lorsque le nombre d’itérations dépend d’un paramètre dont les
valeurs initiale et finale et l’incrémentation sont connus avant
l’exécution de la boucle, on utilise plutôt une boucle for.
Dans le cas où le test de sortie, et donc le nombre d’itérations,
dépendent d’un calcul fait dans le corps de la boucle ou que celui-ci ne
peut s’apparenter à une incrémentation simple, on utilisera un boucle
while ou do ... while plutôt que for.
La boucle do ... while permet d’effectuer une fois les instructions
avant de faire le test alors que while effectue en premier lieu le test
(les instructions peuvent ne jamais être effectuées).
LANGAGE C
CONCEPTS DE BASE: STRUCTURES DE CONTRÔLE (BOUCLES)
81
![Page 82: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/82.jpg)
Instructions de branchement non conditionnel dans les
boucles: break et continue
LANGAGE C
CONCEPTS DE BASE: STRUCTURES DE CONTRÔLE (BOUCLES)
82
break continue
Rôle Permet d’interrompre l’exécution des instructions du
bloc et termine la boucle.
Permet d’interrompre l’exécution des instructions du bloc et de
retourner au test de
continuation.
Exemple for( i=1;i<5;i++){
if(i==3) break;
printf("i=%d, ",i);
}
printf("\n valeur de i en sortie
de boucle: %d",i);
for(i=1;i<5;i++){
if(i==3) continue;
printf("i=%d, ",i);
}
printf("\n valeur de i en sortie
de boucle: %d",i);
Exécution i=1, i=2 valeur de i en sortie de boucle: 3
i=1, i=2, i=4, i=5 valeur de i en sortie de boucle: 5
![Page 83: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/83.jpg)
Chaque unité d’entrée ou de sortie constitue un flux de
données.
L’entête <stdio.h> (abréviation de standard in-out) fournit
trois flux que l’on peut utiliser directement :
stdin, l’entrée standard qui envoie au programme les données
issues du clavier,
stdout, la sortie standard qui envoie les données que le programme
génère à l’écran,
stderr, la sortie standard des erreurs qui seront affichées sur l’écran.
LANGAGE C
FONCTIONS D’ENTRÉES-SORTIES
83
![Page 84: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/84.jpg)
La fonction d’écriture sur l’unité de sortie standard avec
conversion et mise en forme des données est :
printf (format, exp1, exp2, ... expn)
Le paramètre « format » contient les caractères à afficher et les
spécifications de format d’écriture correspondants aux paramètres exp1,
exp2 , ..., expn .
Ces spécifications sont introduites par le signe % (pour afficher
simplement le signe pourcentage à l’écran, on utilisera %%).
Les chaines du type %zz seront remplacées à l’impression par les valeurs
des expressions exp1, exp2, ... expn.
Si la valeur d’une expression n’est pas du type indiqué par le format,
celle-ci sera convertie.
LANGAGE C
FONCTIONS D’ENTRÉES-SORTIES (PRINTF)
84
![Page 85: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/85.jpg)
LANGAGE C
FONCTIONS D’ENTRÉES-SORTIES (PRINTF)
85
code conversion réalisée
% écrit un %
d entier signé exprimé en base décimale
i entier signé exprimé en base décimale
o entier non signé exprimé en base octale
u entier non signé exprimé en base décimale
x, X entier non signé exprimé en hexadécimal
e, E nombre avec partie décimale en notation exponentielle
f nombre avec partie décimale en notation point décimal
g, G nombre avec partie décimale, printf choisit le format f ou e
c caractère
s chaîne de caractères
p la valeur passée est une adresse
![Page 86: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/86.jpg)
On peut préciser certains paramètres du format d’impression
en insérant une précision entre le symbole % et le ou les
caractères précisant le format :
Pour les entiers, on peut spécifier la largeur du champs minimal
d’impression (e.g. %10d, %-10d)
Pour les flottants, on peut raffiner l’utilisation de %f et %lf en
choisissant le nombre de chiffres après la virgule (e.g. %.4f, %6.4f).
Pour les chaînes de caractères, on peut spécifier la plage réservée à
l’écriture des caractères d’une chaîne ainsi que le nombre des
caractères qui seront imprimés (e.g. %30.4s)
LANGAGE C
FONCTIONS D’ENTRÉES-SORTIES (PRINTF)
86
![Page 87: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/87.jpg)
LANGAGE C
FONCTIONS D’ENTRÉES-SORTIES (PRINTF)
87
Exercice: Donner les messages qui seront affichés après
l’exécution de ce programme:
![Page 88: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/88.jpg)
La fonction « scanf » permet de lire des valeurs sur l’unité
d’entrée standard, selon un format spécifié en argument et les
inscrire dans des cases mémoires dont les adresses sont
fournies en arguments.
Son appel a la forme suivante :
scanf (format, arg1,arg2,...,argn)
Souvent, les arguments argi présentent des adresses mémoires
où sont stockées des variables et sont donc de la forme &vari
où vari est l’identificateur d’une variable et & est l’opérateur
d’adressage:
scanf (format, &var1, &var2,..., &varn)
LANGAGE C
FONCTIONS D’ENTRÉES-SORTIES (SCANF)
88
![Page 89: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/89.jpg)
Comme pour printf, la chaine « format » contient les
spécifications de format des caractères à récupérer à partir du
flux d’entrée
LANGAGE C
FONCTIONS D’ENTRÉES-SORTIES (SCANF)
89
code conversion réalisée
% lit un %
d entier signé exprimé en base décimale
i entier signé exprimé en base décimale
o entier non signé exprimé en base octale
u entier non signé exprimé en base décimale
x entier non signé exprimé en hexadécimal
e ou f ou g nombre avec partie décimale en notation point décimal, ou avec exposant
c caractère
s mots ou chaîne de caractères sans blanc
p adresse, pour faire l'opération inverse de l'écriture avec %p
![Page 90: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/90.jpg)
LANGAGE C
FONCTIONS D’ENTRÉES-SORTIES
90
Déclaration lecture écriture format externe
int i; scanf("%d",&i); printf("%d",i); décimal
int i; scanf("%o",&i); printf("%o",i); octal
int i; scanf("%x",&i); printf("%x",i); hexadécimal
unsigned int i; scanf("%u",&i); printf("%u",i); décimal
short j; scanf("%hd",&j); printf("%d",j); décimal
short j; scanf("%ho",&j); printf("%o",j); octal
short j; scanf("%hx",&j); printf("%x",j); hexadécimal
unsigned short j; scanf("%hu",&j); printf("%u",j); décimal
long k; scanf("%ld",&k); printf("%d",k); décimal
long k; scanf("%lo",&k); printf("%o",k); octal
long k; scanf("%lx",&k); printf("%x",k); hexadécimal
unsigned long k; scanf("%lu",&k); printf("%u",k); décimal
![Page 91: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/91.jpg)
LANGAGE C
FONCTIONS D’ENTRÉES-SORTIES
91
Déclaration lecture écriture format externe
float l; scanf("%f",&l); printf("%f",l); point décimal
float l; scanf("%e",&l); printf("%e",l); exponentielle
float l; printf("%g",l); la plus courte des deux
double m; scanf("%lf",&m); printf("%f",m); point décimal
double m; scanf("%le"&m); printf("%e",m); exponentielle
double m; printf("%g",m); la plus courte
long double n; scanf("%Lf"&n); printf("%Lf",n); point décimal
long double n; scanf("%Le"&n); printf("%Le",n); exponentielle
long double n; printf("%Lg",n); la plus courte
char o; scanf("%c",&o); printf("%c",o); caractère
char p[10]; scanf("%s",p); printf("%s",p);
chaîne de caractères
scanf("%s",&p[0]);
![Page 92: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/92.jpg)
La déclaration d’un tableau monodimensionnel a la forme
suivante :
type Nom_Tab [Nbr_elt] ;
Cette déclaration crée du tableau, composé de « Nbr_elt »
éléments de type « type » et désigné par l’identificateur «
Nom_Tab ».
« Nbr_elt » est la taille du tableau et doit être un entier
strictement positif.
Une telle déclaration alloue un espace mémoire de
sizeof(type)*Nbr_elt octets consécutifs pour stocker le tableau.
LANGAGE C
TABLEAUX STATIQUES
92
![Page 93: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/93.jpg)
type Nom_Tab [Nbr_elt] ;
Les éléments du tableau sont numérotés de 0 à Nbr_elt -1.
On peut accéder à chaque élément en utilisant l’opérateur [ ].
Exemple: int Tab[10];
for(int i=0; i<10 ; i++) Tab[i] = 1;
On peut également initialiser un tableau lors de sa déclaration
par une liste de constantes :
type Nom_Tab [N] = {const-1,const-2,...,const-N};
Si le nombre de données dans la liste d’initialisation est
inférieur à la taille du tableau, seuls les premiers éléments
seront initialisés.
LANGAGE C
TABLEAUX STATIQUES
93
![Page 94: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/94.jpg)
Exemple: int Tab[10];
for(int i=0; i<10 ; i++) Tab[i] = 1;
On peut également initialiser un tableau lors de sa déclaration
par une liste de constantes :
type Nom_Tab [N] = {const-1,const-2,...,const-N};
Si le nombre de données dans la liste d’initialisation est
inférieur à la taille du tableau, seuls les premiers éléments
seront initialisés.
On peut omettre la taille du tableau dans le cas d’une
déclaration avec initialisation et utiliser l’instruction suivante
: type Nom_Tab [] = {const-1,const-2,...,const-N};
LANGAGE C
TABLEAUX STATIQUES
94
![Page 95: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/95.jpg)
Le langage C permet également de déclarer des tableaux
multidimensionnels:
type Nom_Tab [taille-1][taille-2][taille-3]……[taille-m];
Exemple: L’initialisation d’un tableau bidimensionnel,
comme représentant la matrice ci contre se fait pas le
biais d’une liste de listes comme suit:
int TAB[2][3] = {{1,2,3},{4,5,6}};
Ou simplement: int TAB[2][3] = {1,2,3,4,5,6};
LANGAGE C
TABLEAUX STATIQUES
95
1 2 3
4 5 6
![Page 96: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/96.jpg)
Une chaîne de caractère est un tableau de caractères
dont la fin est marquée par le symbole \0.
Elle est donc désignée par l’adresse de son premier
caractère ou par l’adresse du caractère \0 si la chaine est
vide.
Exemple: une chaine s contenant le mot “Bonjour” est
initialisée ainsi : char s[8] = {’B’,’o’,’n’,’j’,’o’,’u’,’r’,’\0’};
char s[] = {’B’,’o’,’n’,’j’,’o’,’u’,’r’,’\0’};
char s[8] = "Bonjour";
char s[] = "Bonjour";
LANGAGE C
CHAÎNES DE CARACTÈRES
96
![Page 97: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/97.jpg)
Si on déclare une chaine de caractère sans l’initialiser
char s[8]; on ne pourra PAS effectuer à posteriori une
affectation du type : s = "Bonjour"; car s est le nom d’un
tableau et donc chaque lettre doit être affectée
séparément.
Pour comparer deux chaines de caractères, il faudra les
comparer caractère par caractère... Ou bien se bénéficier
des fonctions utiles de la bibliothèque standard
string.h : calculer leur longueurs (strlen), les
comparer (strcmp), les concaténer (strcat), etc...
LANGAGE C
CHAÎNES DE CARACTÈRES
97
![Page 98: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/98.jpg)
Une structure est une suite finie d’objets de différents types,
stockées de manières contigüe. Chacun de ces objets est appelé
champs ou membre de la structure et possède un
identificateur.
La déclaration d’un modèle de structure permet de définir le
nom du modèle ainsi que les types et les identificateurs des
différents champs que comporte le modèle.
LANGAGE C
STRUCTURES
98
struct Nom_Structure { type1 Nom champs-1 ;
type2 Nom champs-2 ;
...
typeN Nom champs-N ;
}; …..
struct Nom_Structure Nom _variable ;
struct Nom_Structure { type1 Nom champs-1 ;
type2 Nom champs-2 ;
...
typeN Nom champs-N ;
} Nom_variable ;
![Page 99: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/99.jpg)
Lorsqu’une variable d’un type structuré est déclarée, on
peut accéder à ses différents champs via l’opérateur
champs de structure, matérialisé par un point “.”:
Nom variable.Nom champs-i
On peut initialiser les variables structurées lors de leur
déclarations. Par exemple:
struct Point {
char nom;
float x, y;
};
struct Point p1 = {’A’,2.5,1.};
LANGAGE C
STRUCTURES
99
![Page 100: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/100.jpg)
Un pointeur est un objet dont la valeur est égale à
l’adresse d’un autre objet.
On déclare un pointeur en utilisant l’instruction :
type *ptr ;
L’identificateur «ptr» est associé à un entier (en général de
type unsigned long int) dont la valeur pourra être l’adresse
d’une variable de type « type ».
On dit que le pointeur « ptr » pointe vers un objet de type «
type » .
Exemples: int *p1; char *p2; struct personne *p3;
LANGAGE C
POINTEURS
100
![Page 101: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/101.jpg)
Par défaut, lorsqu’on définit un pointeur sans l’initialiser,
il ne pointe sur rien : la valeur d’un pointeur est alors
égale à une constante symbolique noté NULL (définie
dans l’en-tête <stdio.h>) qui vaut ’\0’ en général.
Le test ptr == NULL permet donc de savoir si un pointeur
pointe vers quelque chose ou pas.
Les pointeurs peuvent également être des éléments d’un
tableau, ou un champs d’une structure. Par exemple:
struct personne *liste[50];
LANGAGE C
POINTEURS
101
![Page 102: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/102.jpg)
L’utilisation des pointeurs permet également de déclarer
un type de structure de manière récursive
(autoréférence).
Exemple : struct personne {
char nom[30];
struct personne *mere;
struct personne *pere;
}
Les pointeurs peuvent également être passés comme
arguments ou comme type de retour de fonctions.
LANGAGE C
POINTEURS
102
![Page 103: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/103.jpg)
Pour accéder à la valeur d’une variable pointée par un
pointeur, on utilise l’opérateur unaire d’indirection : *.
Exemple: double *p;
double n;
n=3;
p=&n;
printf("*p= %d\n",*p); //imprimera à l’écran 3.
LANGAGE C
POINTEURS
103
![Page 104: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/104.jpg)
L’initialisation d’un pointeur peut s’effectuer:
Par une affectation (ptr=&variable), si on souhaite faire
pointer sur une variable existant déjà dans le programme,
Par une réservation d’un espace mémoire de taille adéquate,
puis en lui affectant directement une valeur.
L’allocation dynamique est l’opération consistant à
réserver une place mémoire pour stocker l’objet pointé
par ptr.
Elle s’effectue à l’aide des fonctions disponibles dans la
bibliothèque <stdlib.h> tel que: malloc, calloc, free, …...
LANGAGE C
POINTEURS
104
![Page 105: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/105.jpg)
void* malloc (size_t size ) ;
Cette fonction renvoie un pointeur pointant vers un objet de
taille size octets.
Le type void* est un passe-partout, il permet de remplacer
n’importe quel autre type.
Pour initialiser les pointeurs vers des objets de type
différents, on effectue un transtypage au moment de
l’initialisation.
type * ptr =(type *) malloc(sizeof(type)) ;
LANGAGE C
POINTEURS (MALLOC)
105
![Page 106: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/106.jpg)
Pour initialiser les pointeurs vers des objets de type
différents, on effectue un transtypage au moment de
l’initialisation.
type * ptr =(type *) malloc(sizeof(type)) ;
Pour allouer une plage mémoire à un tableau de N
éléments de type « type », on appelle la fonction malloc
ainsi : type *Tab= (type *) malloc(N *sizeof(type )) ;
LANGAGE C
POINTEURS (MALLOC)
106
![Page 107: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/107.jpg)
void* calloc(size_t Nb Elements, size_t Taille Element ) ;
La fonction calloc permet d’allouer dynamiquement de la place
mémoire mais initialise également toutes les valeurs de
cet espace mémoire à zéro.
Elle renvoie un pointeur sur une plage mémoire de taille Nb
Elements *Taille Element .
Pour allouer une plage mémoire à un tableau de N
éléments de type « type » qui sera pointé par « ptr » et
dont les valeurs sont initialisées à zéro:
type *ptr = (type *)calloc(N,sizeof(type)) ;
LANGAGE C
POINTEURS (CALLOC)
107
![Page 108: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/108.jpg)
void free(void *Nom_Pointeur )
La fonction « free » permet de libérer l’espace mémoire
alloué à un pointeur « Nom_Pointeur ».
Cette fonction doit être utilisée lorsqu’on n’a plus besoin
d’utiliser les données vers lesquelles pointent le pointeur «
Nom_Pointeur » et permet à les cases mémoires contenant
*Nom_Pointeur de pouvoir être de nouveau utilisées en cas
d’autre affectation.
Le pointeur *Nom Pointeur existe toujours et peut être
réutilisé dans le programme. Par contre la valeur de *Nom
Pointeur n’est pas conservée.
LANGAGE C
POINTEURS (FREE)
108
![Page 109: Chapitre 1 rappel](https://reader033.vdocuments.net/reader033/viewer/2022042513/58d105761a28ab823e8b4c8f/html5/thumbnails/109.jpg)
SOURCES DE CE COURS
109
N. EL-ALLIA , Cours d’Algorithmique et Structures de données
dynamiques, Ecole nationale Supérieure d’Informatique (ESI), 2010.
Djamel Eddine ZEGOUR, Cours de Structures de Données, Ecole nationale
Supérieure d’Informatique (ESI), Disponible sur
http://zegour.esi.dz/Cours/Cours_sdd.htm
M. Le Gonidec, Introduction à la Programmation – Pratique du Langage C
–, Université du Sud, disponible sur http://legonidec.univ-tln.fr/0-Cours.pdf
Maude Manouvrier, Initiation à la Programmation Procédurale, à
L'algorithmique Et aux structures de Données par le Langage C,
Université Paris Dauphine, 2015, disponible sur
http://www.lamsade.dauphine.fr/~manouvri/C/Polys_C_MM.pdf
Christian Bac, Support de Cours de Langage C; 2013; Disponible sur
http://picolibre.int-evry.fr/projects/svn/coursc/Index.pdf