PROGRAMMATION EN C

PROGRAMMATION
EN C
Objectifs du cours

EHTP / Filière GI
Malika ADDOU
2010 -2011 1 2
M. ADDOU

PROGRAMMATION EN C PROGRAMMATION EN C
ƒ Maîtriser un langage de programmation Module Élément de module Quota Horaire
structuré
Programmation en Langage C 52
ƒ Acquérir les bonnes pratiques de la Techniques de Programmation
Projet C 12
programmation structurée et les grands
principes de la programmation impérative
Note Module = 75% * Programmation + 25% * Projet
ƒ Se familiariser avec le langage C
ƒ Se familiariser avec un environnement de
développement intégré C/C++ Programmation = 30% * Contrôle + 40% * Examen + 30% TP
ƒ Être capable de s’adapter à un langage de
programmation impératif autre que C.
3 4
M. ADDOU M. ADDOU

1
 PROGRAMMATION EN C PROGRAMMATION EN C
Plan
INTRODUCTION À LA PROGRAMMATION
PRÉSENTATION DU LANGAGE C
CONCEPTS DE BASE
OPERATEURS ET EXPRESSIONS
INTRODUCTION À LA PROGRAMMATION
STRUCTURES DE CONTROLE
VARIABLES STRUCTURÉES
CHAÎNES DE CARACTÈRES
PRÉPROCESSEUR
NOTION DE SOUS-PROGRAMME
STRUCTURES DE DONNÉES
5 6
M. ADDOU TRAITEMENT DES FICHIERS M. ADDOU

INTRODUCTION À LA PROGRAMMATION INTRODUCTION À LA PROGRAMMATION

1) Notion de programme
ƒ Logiciel :
ƒ Programme : Application ou ensemble de programmes permettant à un
Suite de commandes, de directives ou d’instructions ordinateur ou à un système informatique d'assurer une
permettant de définir et d’exécuter sur ordinateur un tâche ou une fonction donnée
traitement pour résoudre un problème donné
Rq.
ƒ Programmation : Qualités des programmes : clarté, simplicité, modularité,
Ensemble d’activités permettant d’écrire des programmes réutilisabilité,
é tili bilité extensibilité
t ibilité
(ou des logiciels ) à l’aide d’un langage de programmation
ƒ Phases de production d’un logiciel :
Autre appellation : codage (rédaction du code source d’un Analyse , conception, programmation, test, validation
logiciel) 7 8
M. ADDOU M. ADDOU

2
 INTRODUCTION À LA PROGRAMMATION INTRODUCTION À LA PROGRAMMATION
ƒ Exemples de logiciels : ƒ Organisation des logiciels sur ordinateur :
- Systèmes d’exploitation : Unix, Linux, Windows XP, Vista, Compilateurs
((de Pascal,, C/C++,, Java,, …))
…
- Compilateurs : Pascal, C, C++, Java, …
Système d’exploitation
- Progiciels : Traitement de texte Ex. Word
Tableur Ex. Excel
Interpréteur de
Présentation assistée Ex. PowerPoint macro instruction
Dessin assisté Ex. Autocad
Multimédia Ex.
Ex Photoshop Machine
Navigateur Web Ex. Explorer
- Applications spécifiques:
Logiciel de gestion de la relation client
Logiciel de comptabilité Interpréteurs (de commandes du système
Logiciel de gestion des stocks 9 d’exploitation, Java Virtual Machine, …) 10
M. ADDOU
… M. ADDOU

INTRODUCTION À LA PROGRAMMATION INTRODUCTION À LA PROGRAMMATION

2) Méthodologies de programmation 3) Environnement de programmation

ƒ Années 50 et 60 : Programmation non structurée Ensemble d'outils utilisés pour développer un logiciel
(principale préoccupation : rapidité d'exécution)
ƒ Fin des années 60 : Programmation procédurale Ex.
(Programmation structurée, analyse descendante , raffinement
progressif) ƒSystème d’exploitation
ƒ Fin des années 70: Programmation orientée données
(usage de structures de données abstraites)
(Unix, Linux, Windows XP, Vista, …)
ƒ Milieu des années 80: Programmation orientée objets
(Données abstraites, attachement dynamique, héritage, ƒEnvironnement de développement intégré (IDE)
polymorphisme)
(intégrant des outils Ex. système de gestion de fichier,
ƒ Années 90 : Programmation orientée processus
(Programmation parallèle) éditeur de texte, linker, compilateur, utilitaires de correction
ƒ Milieu des années 90 : Programmation orientée agents
de programme, aide à la programmation d’interfaces
(intelligence artificielle, systèmes distribués) 11 graphiques, …) 12
M. ADDOU M. ADDOU

3
 INTRODUCTION À LA PROGRAMMATION INTRODUCTION À LA PROGRAMMATION
Exemples d’IDE : 4) Langages de programmation

ƒ Langage : Ensemble d’éléments et de règles permettant d’écrire des

• Micro Soft Visual Studio (Visual C/C++
C/C++, Visual C/C++ programmes compréhensibles par un ordinateur
Express, C#, J#, [Link], …)
ƒ Niveau d’un langage suivant sa proximité de la machine :
• CodeBlocks (C/C++, …)
- langage « bas niveau » proche du hardware, difficile à écrire, code
fastidieux (Ex. langage machine, langage symbolique, bytecode de
• Dev C++ (C/C++, …) JVM)

• Borland C++ (C/C++, …) - langage « haut niveau » (ou évolué) proche de la langue naturelle,
programmation facile, lisible, modulaire, portable (Ex. C/C++, Java,
• Netbeans (C/C++, Java SE, Java EE, Java ME, Pascal, …)
JavaScript, PHP, UML, XML, AJAX, …)
Rq. C et C++ peuvent se comporter aussi comme des langages « bas
13 niveau » pour interagir directement avec la partie hardware 14
M. ADDOU
• … M. ADDOU

INTRODUCTION À LA PROGRAMMATION INTRODUCTION À LA PROGRAMMATION

ƒ Catégorie d’un langage :
• Langage de balisage
• Impératif :
(basé sur les variables
variables, affectations
affectations, séquences et itérations)
Ex. HTML,, XHTML
Ex. C, Pascal • Langage de script
• Fonctionnel : Ex. PHP, JavaScript
(basé sur la récursivité : application d’une fonction à des
paramètres pouvant faire appel à cette même fonction)
Ex. LISP, Scheme
ƒ Domaines d’application d’un langage :
• Logique
• Scientifique : Ex. Fortran
(b é sur d
(basé des relations
l ti llogiques
i é
écrites
it d dans un ordre
d • Gestion : Ex.
Ex COBOL
quelconque)
Ex. Prolog
• Intelligence artificielle : Ex. LISP, Prolog
• Orienté objet
• Programmation système : Ex. C/C++
(basé sur la notion d’héritage) • Web : Ex. XHTML, PHP, JavaScript, Java
Ex. C++, Java
15 16
M. ADDOU M. ADDOU

4
 INTRODUCTION À LA PROGRAMMATION INTRODUCTION À LA PROGRAMMATION
5) Implémentation d’un programme
ƒ Portabilité d’un langage Vs généralité :
ƒ Compilation
C il ti : le
l programme ((code
d source)) é
écrit
it en
• Langage portable : possibilité d’utiliser un même
langage de haut niveau est traduit en code
programme sur des plateformes différentes Unix/Linux,
compréhensible par la machine (langage machine) avant
Windows, …
l'exécution
(standardisation)
(trad ction lente,
(traduction lente exécution
e éc tion rapide)
• Langage général : possibilité d’utiliser un même Ex. de langages compilés :
programme pour une large gamme d'applications Pascal, C/C++, Fortran, Java, …
17 18
M. ADDOU M. ADDOU

INTRODUCTION À LA PROGRAMMATION INTRODUCTION À LA PROGRAMMATION

Compilation ƒ Interprétation : les instructions du programme sont
Programme interprétées une à une et exécutées par un programme
source
spécial
é i l « l'interpréteur
l'i é » (exécution
( é i plus l llente, espace
Compilateur
mémoire requis plus grand)
Analyse
Ex. de langages interprétés :
Traduction
Basic, Lisp, Prolog, PHP, JavaScript, …
Rq.
Programme
Données
compilé - Un interpréteur crée (simule) une machine virtuelle
- En exécution, une machine reçoit un langage bas niveau
Machine
(langage machine), par contre la machine virtuelle
(simulée par l’interpréteur) reçoit un langage haut niveau
Résultats 19 20
M. ADDOU M. ADDOU (langage évolué)

5
 INTRODUCTION À LA PROGRAMMATION INTRODUCTION À LA PROGRAMMATION
Interprétation
ƒ Implémentation hybride : le programme est traduit dans

Programme
P
un langage intermédiaire (bytecode) facilement
Données
source
interprétable
Interpréteur
(Machine Virtuelle) (Compromis entre le compilé et l’interprété, plus rapide
Analyse qu’une simple interprétation)

Ex Java Virtual Machine

Ex.
Interprétation

Résultats
21 22
M. ADDOU M. ADDOU

INTRODUCTION À LA PROGRAMMATION PROGRAMMATION EN C

Implémentation hybride

Programme
P B t C d
ByteCode Données
source

Compilateur Interpréteur
(Machine Virtuelle)
PRÉSENTATION DU LANGAGE C
Analyse Analyse

Traduction Interprétation

Résultats
23 24
M. ADDOU
M. ADDOU

6
 PRÉSENTATION DU LANGAGE C PRÉSENTATION DU LANGAGE C

1) Caractéristiques du langage C 2) Jeu de caractères

ƒ Langage de programmation conçu en 1972 par Dennie ƒ 26 lettres de l'alphabet (A … Z et a … z)
Ritchie ƒ 10 chiffres (0 … 9)
ƒ Langage évolué qui permet d'exécuter des opérations de ƒ Des caractères spéciaux :
bas niveau et de haut niveau + - * / % = > < ! | &
ƒ Langage
L structuré,
t t é portable,
t bl efficace,
ffi puissant
i t (espace) . , : ; ‘ " _ \ $ ? # ( ) [ ] { }
ƒ Langage polyvalent (programmation système, \n (retour à la ligne) \t (tabulation) \b (backspace)
développement de systèmes d'exploitation, d’applications …
scientifiques et de gestion) 25 26
M. ADDOU M. ADDOU

PRÉSENTATION DU LANGAGE C PRÉSENTATION DU LANGAGE C

3) Identificateurs ƒ Les mot-clés suivants sont réservés :
ƒ Identificateur : nom donné dans un p
programme
g à: auto extern sizeof break float static case for
• une variable struct char goto switch const if typedef
• un tableau continue int union default long unsigned
• une fonction do register void double return volatile
ƒ Un identificateur est formé de lettres, de chiffres et/ou du else short while enum signed
caractère ‘‘_’’ pour plus de lisibilité (au maximum 31
caractères minuscules et majuscules). ƒ Les variables du préprocesseur C sont généralement
ƒ Le 1er caractère doit obligatoirement être une lettre ou le écrites entièrement en majuscules.
27 28
M. ADDOU
caractère ‘‘_’’. M. ADDOU

7
 PRÉSENTATION DU LANGAGE C PRÉSENTATION DU LANGAGE C

4) Structure d’un programme C

ƒ à l'intérieur du bloc principal
Écriture d
d’un
un programme C - des
d dé déclarations
l ti ou défi
définitions
iti d
de variables/fonctions
i bl /f ti
Un programme C est formé de : (locales au programme principal)
ƒ directives de pré-compilation ou du préprocesseur (lignes - des instructions ou des blocs d'instructions délimités par
commençant par #) { et }
ƒ commentaires (limités par /* et */)
Rq.
ƒ déclarations ou définitions globales de variables/fonctions
Les instructions, les déclarations ou définitions de
(visibles par toutes les parties du programme)
variables/fonctions sont terminées par un point virgule (";")
ƒ une fonction principale main
(qui lance l’exécution d’un programme)
ƒ un bloc principal lié à main et délimité par { et } 29 30
M. ADDOU M. ADDOU

PRÉSENTATION DU LANGAGE C PRÉSENTATION DU LANGAGE C

Structure générale d’un programme C
Ex.
[
[#include <Fichiers ou bibliothèques
q externes>]]
[#define <Constantes ou macros fonctions>]
[const <Définition de constantes externes> ;] #include <stdio.h>
[typedef <Définition de types de données externes> ;] int main ()
[<Définition de variables externes> ;]
[<Prototypes de fonctions externes> ;] {
[<Définition de fonctions> ;]
int main ( ) printf (‘‘Ceci est mon premier programme C. \n’’) ;
{
[<Définition de variables> ;]
[<Prototypes de fonctions > ;] return 0;
<Corps du Programme Principal> ; }
return 0;
}
[<Définition de fonctions> ;] 31 32
M. ADDOU M. ADDOU

8
 PRÉSENTATION DU LANGAGE C PRÉSENTATION DU LANGAGE C
Choix de la platforme et de la version C
5) Exemple de programme C
ƒ Choisir la plateforme Unix/Linux ou Windows Recherche du minimum et du maximum de deux nombres réels en utilisant
deux fonctions Min et Max. [#include <Fichiers ou bibliothèques externes>]
[#define <Constantes ou macros fonctions>]

/******** Programme MinMax *****/

[const <Définition de constantes externes> ;]

ƒ Les instructions du programme source sont enregistrées

[typedef <Définition de types de données externes> ;]
[<Définition de variables externes> ;]
#include <stdio.h> [<Prototypes de fonctions externes> ;]
[<Définition de fonctions> ;]

dans un fichier texte /******** Fonction Principale ******/

int main ( )
{
[<Définition de variables> ;]

Extension : « .c » si programme C int main ()

[<Prototypes de fonctions > ;]
<Corps du Programme Principal> ;
return 0;

ou « .cpp » si programme C++ { }

[<Définition de fonctions> ;]

float xx, y;
float Min(float a, float b), Max(float a, float b);
ƒ Dans nos TPs, nous utiliserons un IDE (Environnement printf (" Donner x et y : \n" ) ;
de Développent Intégré : compilateur + éditeur intégré) scanf (" %f %f " , &x , &y) ;
/*** Affichage des résultats: 6 caractères maximum, 2 chiffres après la virgule ***/
sous Windows comme Visual C++ (propriétaire) ou printf (" Minimum de x et y : %6.2 f \n " , Min (x,y)) ;
CodeBlocks (gratuit) 33 printf (" Maximum de x et y : %6.2 f \n " , Max (x,y)) ; 34
M. ADDOU M. ADDOU }

PRÉSENTATION DU LANGAGE C PRÉSENTATION DU LANGAGE C

/********************* Fonction Max **********************/ 6) Implémentation d’un programme C

[#include <Fichiers ou bibliothèques externes>]

float
oat Max
a ((float
oat a, float
oat b) ; [#define <Constantes ou macros fonctions>]
[[const <Définition de constantes externes> ;]
[typedef <Définition de types de données externes> ;]
Editeur de texte
Ré lt t
Résultats
{ [<Définition de variables externes> ;]
[<Prototypes de fonctions externes> ;]
[<Définition de fonctions> ;] Code source
if (a>b) return a ; int main ( )
{
[<Définition de variables> ;]

else return b ; [<Prototypes de fonctions > ;]

<Corps du Programme Principal> ;
return 0;
Compilateur
Machine
} }
[<Définition de fonctions> ;]

Code objet
/********************* Fonction Min **********************/
Editeur de liens
float Min (float a, float b) ; Données
{ Fonctions externes
Code exécutable
if (a<b) return a ;
else return b ; Chargeur
}
35 Code en mémoire 36
M. ADDOU M. ADDOU

9
 PRÉSENTATION DU LANGAGE C PRÉSENTATION DU LANGAGE C
6) Implémentation d’un programme C 6) Implémentation d’un programme C
Editeur de texte Editeur de texte
Ré lt t
Résultats Ré lt t
Résultats
Erreurs de référence
Erreurs de syntaxe Code source à une fonction Code source

Traduction en Compilateur Compilateur

code objet Machine Machine
Code objet Liaison avec les
Code objet
fonctions (ou
références))
Editeur de liens Données externes Editeur de liens Données

Fonctions externes Fonctions externes

Code exécutable Code exécutable

chargeur chargeur

Code en mémoire 37 Code en mémoire 38

M. ADDOU M. ADDOU

PRÉSENTATION DU LANGAGE C PRÉSENTATION DU LANGAGE C

6) Implémentation d’un programme C 6) Implémentation d’un programme C
Editeur de texte Editeur de texte Erreurs d’exécution
Ré lt t
Résultats Ré lt t
Résultats
Code source Code source

Compilateur Compilateur
Machine Machine
Code objet Code objet
Exécution

Editeur de liens Données Editeur de liens Données

Fonctions externes Fonctions externes

Code exécutable Code exécutable

Mise du code chargeur chargeur

exécutable en
mémoire pour
Code en mémoire 39 Code en mémoire 40
exécution
M. ADDOU M. ADDOU

10
 PROGRAMMATION EN C CONCEPTS DE BASE
1) Notion d ’environnement (Déclarations)
Environnement : ensemble d ’objets nécessaires
à la résolution d ’un problème
(déclaration des objets)
Ex. modèle Surface-Disque
Paramètres : R, S
CONCEPTS DE BASE Relation : S = πR2
Environnement : R , S

En conclusion :
Pour programmer un problème sur ordinateur:
Il faut commencer par définir son environnement

41
(déclarer ses objets) 42
M. ADDOU
M. ADDOU

CONCEPTS DE BASE CONCEPTS DE BASE

11) Objets de base 12) Représentation physique en mémoire :
- Variable ⇒ 3 éléments nécessaires :
Deux sortes d ’objets
objets - Variables
- Constantes * nom ou identificateur
(pour référencer la variable en mémoire)
* Type
Ex. Calcul de S à partir de la formule : (pour définir sa forme ou sa taille en MC)
PI * R * R * Valeur
(pour définir sa situation à un moment
Variables : R , S donné)
Constante : PI (3.14)

43 44
M. ADDOU M. ADDOU

11
 CONCEPTS DE BASE CONCEPTS DE BASE
Ex. - Constante ⇒ 2 ou 3 éléments
Rayon R ⇒ nom =R * nom (optionnel)
type = réel (float) * Type
* Valeur
valeur = r (à préciser)

Rq. Ex.
3.14 ⇒ nom = PI
- Le nom et le type sont fixes
fixes.
type = réel (float)
- La valeur est variable. valeur = 3.14
- Le nom est sensible à la casse :
différence entre minuscules et majuscules Rq.
M. ADDOU
(R ≠ r, S ≠ s). 45 Le nom, le type et la valeur sont fixes. 46
M. ADDOU

CONCEPTS DE BASE CONCEPTS DE BASE

13) Les types d ’objets : 14) Déclaration des variables
- entier (int) ƒ En C, les variables sont déclarées au début d’un
d un bloc
ƒ Numérique - réel (float) ƒ Un bloc est limité par { et }
- double précision (double) ƒ Un bloc est composé éventuellement de déclarations et/ou
d’instructions.
ƒ Caractère ou chaîne de caractères (char) Algorithmique C
ƒ Logique (ou booléen) (non défini en C) <Nom-variable> : <Type-données> <Type-données> <Nom-variable> [=<valeur>] ;

ƒ Pointeur (*) Ex.

Algorithmique C
x, y, z : réels float x, y=1.5, z ;
y=1.5
47 48
M. ADDOU M. ADDOU

12
 CONCEPTS DE BASE CONCEPTS DE BASE
15) Déclaration des Constantes
Deux cas : Rq.
ƒ déclarer la constante dans la section « const » ƒ valeur d’une constante entière notée en octal
ƒ la définir par la directive #define qui permet de remplacer ⇒ faire précéder ses chiffres octaux du chiffre 0 (Ex. 013)
constamment un symbole par la chaîne de caractères qui
ƒ valeur d’une constante entière notée en hexadécimal
définit sa valeur
⇒ faire précéder ses chiffres hexadécimaux du chiffre 0
(utiliser « #define » aussi pour remplacer un appel de et de la lettre x ou X (Ex. 0x1FF3)
fonction ou de procédure)
ƒforcer le compilateur à générer la valeur d’une
d une constante
Algorithmique C entière sur une double longueur
<Nom-constante> = <valeur> const <Type-données> <Nom-constante> = <valeur> ;
⇒ la faire suivre de la lettre l ou L
#define <Nom-constante> <valeur> (Ex. 55L, 012L, 0xBF8L)

49 50
M. ADDOU M. ADDOU

CONCEPTS DE BASE CONCEPTS DE BASE

Ex.
ƒ Les constantes réelles sont toujours représentées en Algorithmique C
d bl précision
double é i i
Constante C1 = ‘a’ const char C1 = ‘a’ ;
ƒ Aucun message d’erreur n’est affiché si une constante ou
#define C1 ‘a’
réelle dépasse la limite inférieure ou supérieure, (elle sera
C2 = ‘#13’ (RETURN) const char C2 = ‘\13’ ;
forcée à la valeur 0) ou
ƒ Une constante caractère est limitée par deux apostrophes #define C2 ‘\13’
C3 = ’abc’ const char C3 = ’’abc’’ ;
ƒ Le caractère peut être représenté par son code ASCII ou
précédé par « \ » entre apostrophes #define C3 ’’abc’’
Nmax = 100 const int Nmax = 100 ;
ƒ Une constante chaîne de caractères est limitée par deux
ou
guillemets. #define Nmax 100
#define fin printf(‘’ Fin de procedure‘’)
51 52
M. ADDOU M. ADDOU

13
 CONCEPTS DE BASE CONCEPTS DE BASE
2) Les types d’objets simples Ex.
21) Type Entier Algorithmique C
C Valeur sur des mots 16 bits n : octet unsigned char n ;
char -128 … 127
x, y, z : entiers int x,y,z ;
unsigned char 0 … 255

int / short int / short -32768 … 32767

Rq.
unsigned int / unsigned 0 … 65535 - Aucun
A test
t t de
d dépassement
dé t de
d capacité
ité n’est
’ t effectué
ff t é par
le compilateur dans une opération sur des entiers
long int ou long -2147483648 … 2147483647 - En cas de dépassement, les bits les plus significatifs du
résultat (les plus à gauche) seront perdus
unsigned long int 0 … 4294967295 53 54
M. ADDOU M. ADDOU

CONCEPTS DE BASE CONCEPTS DE BASE

22) Type réel Exemples d’opérateurs : arithmétiques et relationnels
C Valeur sur des mots 16 bits Algorithmique C
Float 3 4 E -38…
3.4 38 33.4
4 E 38
+ - * / div + - * / %
long float / double 1.7 E -308 … 1.7 E 308
long double 3.4 E -4932 … 1.1 E 4932 = <> < <= > >= == != < <= > >=

Ex. Exemples de fonctions :

Algorithmique C
Algorithmique C
x : réel float x ; |x| abs (x),
(x) fabs(x)
y : double précision double y ; x*x pow (x, 2)
x sqrt (x)
Rq.
Sin (x) sin (x)
En cas de dépassement de capacité dans une opération Cos (x) cos (x)
sur des réels, l’exécution est interrompue par l’émission 56
55
M. ADDOU
d’un message d’erreur M. ADDOU

14
 CONCEPTS DE BASE CONCEPTS DE BASE
23) Type Caractère Ex.
Algorithmique C
Caractère char L code
Le d ASCII de
d ‘A’ estt 97
Posons :
Ex.
#include <stdio.h>
Algorithmique C int main ()
c : Caractère char c ; { char c =’A’ ;
c ← ’b’ c = ’b’ ;
c=c+1
c c+1 ;
Rq. printf(‘’%c \n’’, c) ; /* Le résultat est ‘B’ */
Le type « char » représente en même temps le caractère printf(‘’%d \n’’, c) ; /* Le résultat est le code ASCII 98*/
et son code.
return 0;
57 58
M. ADDOU M. ADDOU
}

CONCEPTS DE BASE CONCEPTS DE BASE

Valeurs et opérateurs logiques :
24) Type Booléen Algorithmique C
Vrai 1
Algorithme C Faux 0
Booléen non défini Non Et Ou ! && ||

25) Type Énuméré

Rq.
Algorithmique C
Les valeurs booléennes « Vrai » et « Faux » sont définies Type typedef
respectivement par les entiers 1 et 0 pour évaluer des <Nom type>=(valeur1 valeur2,
<Nom-type>=(valeur1, valeur2 …)) enum <Nom
<Nom-type>
type> {valeur1[=…],
{valeur1[= ]
valeur2 [=…],
conditions formulées sous forme d’expressions logiques …} ;
avec éventuellement des opérateurs logiques
Rq.
Par défaut, (valeur1, valeur2, …) : une liste ordonnée (0, 1, …).
59 60
D’où la relation d’ordre : valeur1< valeur2< …
M. ADDOU M. ADDOU

15
 CONCEPTS DE BASE CONCEPTS DE BASE
3) Les instructions de base
Ex.
31)) Affectation
Algorithmique C
Algorithme C
<Variable> ← <Expression> <variable> = <expression> ;
Type typedef
Jour=(Lundi, Mardi, …, Dimanche) enum jour {Lundi, Mardi,…, Dimanche } ; Ex.
… …
j : jour jour j ; Algorithmique C
i←i+1 i=i+1;

61 62
M. ADDOU M. ADDOU

CONCEPTS DE BASE CONCEPTS DE BASE

32) Lecture Type Format du type
Algorithmique C
int %d %X /* affiché en décimal ou en hexadécimal */
Lire (<Variable1>, scanf(<spécification-format>, <adresse-variable1>,
unsigned int %u %o %x /* affiché en décimal, en octal ou en hexadécimal */
<Variable2>, …) <adresse-variable2>, …) ;
ou long %ld
<Variable-Caractère> = getchar(); unsigned long %lu
ou float %f %e %E /* notations décimale, exponentielle avec e ou E */
gets(<Variable-Chaîne>) ; double %lf %le %lE /*notations décimale, exponentielle avec e ou E*/
long double %lf %le %lE
char %c /* caractère */
Rq.
char * %s /* chaîne de caractèress */
- La spécification de format en C est une variable ou constante chaîne
de caractères qui précise le format des variables à lire dans l’ordre.
- Le format de chaque variable est décrit par un code commençant par
le caractère « % » suivi d’un symbole qui dépend du type de la
variable décrite. 63 64
M. ADDOU M. ADDOU

16
 CONCEPTS DE BASE CONCEPTS DE BASE
- L’adresse de la variable à lire est notée par le caractère « & » suivi
du nom de cette variable
33)) Ecriture
- Des séparateurs peuvent être utilisés comme l’espace et la virgule
Algorithmique C
Ex. Écrire printf (< spécification-format>, <expression1>,
(<Expression1>[:<format>], <expression2>, ...) ;
Soient x et y deux réels. <Expression2>[:<format>], ou
...) putchar(<VariableCaractère>);
Algorithmique C ou
puts(<Variable
p ( Chaîne>)) ;
Lire (x, y) scanf (‘‘%f %f’’, &x , &y);
scanf (‘‘%f, %f’’, &x , &y);

65 66
M. ADDOU M. ADDOU

CONCEPTS DE BASE CONCEPTS DE BASE

Rq. %[<drapeaux>][<largeur>][.<précision>][l]<type format>
- La spécification de format en C est une variable ou <drapeaux> : - (justification à gauche)
constante chaîne de caractères qui précise le format des + (signe toujours présent)
valeurs à afficher. ^ (affichage d’un espace blanc au lieu du signe +).
<largeur> : n (constante entière positive : n caractères affichés,
- Le format de chaque valeur est décrit par la structure
éventuellement complétés par des blancs à gauche).
suivante : 0n (n caractères affichés, éventuellement complétés
par des zéros à gauche).
%[<drapeaux>][<largeur>][.<précision>][l]<type format> * (largeur effective donnée par l’expression à afficher).
<précision> : .n
n (constante entière positive ; avec ff, e
e, E : n chiffres
après la virgule).
.* (précision effective donnée par l’expression à
afficher).
<type format> : format correspondant au type de l’expression (comme
indiqué dans la remarque du paragraphe précédent
67 dans le tableau des spécifications de format dans 68
M. ADDOU M. ADDOU
l’instruction de lecture en C.

17
 CONCEPTS DE BASE CONCEPTS DE BASE
Rq. Ex.
- Des séparateurs peuvent être utilisés
- Si l’on
l on place l’un
l un des séparateurs suivants entre deux valeurs Soient x et y deux réels.
consécutives, on a :
Algorithmique C
Séparateur signification Écrire (‘La somme de’, printf (‘‘La somme de %6.2f et %6.2f
<espace> Caractère « espace » entre les deux valeurs consécutives. X :6:2, ‘et’, y :6:2, est : %8.2f \n ’’, x, y, x+y) ;
\t Caractère « tabulation ». ‘ est :’, x + y :8:2)

\b Caractère « curseur arrière ».

\r Caractère « retour début de ligne »..
\n Caractère « fin de ligne ».
\’’ Caractère « ’’ ».
\\ Caractère « \ ».
\0 Caractère « NULL » ou vide.
\a Caractère « Bip sonore ». 69 70
M. ADDOU M. ADDOU

CONCEPTS DE BASE CONCEPTS DE BASE

Exemples /* Surface disque */
#include <stdio
<stdio.h>
h>

Ex1. Calcul de la surface d’un disque de rayon R. int main ()

{ float r,s;
printf (‘‘Donner la valeur de r :’’) ;
Solution : donnée : R (réel)
scanf (‘‘%f’’, &r);
Ré lt t : S (réel)
Résultant ( é l)
s=3.14*r*r;
printf (‘‘la surface du disque est : %5.2f \n’’, s) ;
return 0;
71 } 72
M. ADDOU M. ADDOU

18
 CONCEPTS DE BASE CONCEPTS DE BASE
/* Division Euclidienne */
Ex2. #include <stdio.h>
Connaissant le dividende X et le diviseur Y, int main ()
écrire un programme C qui permet de calculer le quotient Q { int x,y,q,r;
et le reste de la division Euclidienne de X par Y printf (‘‘donner x :’’) ;
scanf (‘‘%d’’, &x);
printf (‘‘donner y :’’) ;
Solution : scanf (‘‘%d’’, &y);
q= x / y;
données : X , Y (int).
r= x % y;
Résultats : Q , R (int) printf (‘‘le quotient est : %d \n’’, q) ;
printf (‘‘le reste est : %d \n’’, r) ;
return 0;
73 74
M. ADDOU M. ADDOU }

CONCEPTS DE BASE PROGRAMMATION EN C

Exercices

1) Ecrire un programme qui permute les valeurs de trois

variables données X, Y et Z.
X⇒Y⇒Z⇒X OPERATEURS ET EXPRESSIONS
2) Ecrire un programme qui permet d’afficher le code ASCII
correspondant à une touche ou un caractère frappé au
clavier

75 76
M. ADDOU
M. ADDOU

19
 OPERATEURS ET EXPRESSIONS OPERATEURS ET EXPRESSIONS
Ex.
1) Opérateurs Algorithmique C
11) Opérateurs
O é t arithmétiques
ith éti x ← <reste de : 9 div 4> x=9%4; /* x= 1 */

Algorithmique C
12) Opérateurs booléens
+ +
Algorithmique C
- - et &&
* * ou ||
non !
/ /
xou non défini
div (division entière) / (si les 2 opérandes sont des entiers)
Ex.
Reste : Opérateur non défini % (reste de division entière)
Algorithmique C
77 Si (x = v[i]) ou (i=n) … If (x == v[i] || i==n) … 78
M. ADDOU M. ADDOU

OPERATEURS ET EXPRESSIONS OPERATEURS ET EXPRESSIONS

13) Opérateurs logiques pour traitement des bits
14) Opérateurs relationnels
Algorithmique C
et & Algorithmique C
ou | < <
xou ^
<= <=
non ~
> >
décalage droit : Opérateur non défini >> (décalage à droite)
>= >=
décalage gauche: Opérateur non défini << (décalage à gauche)
= ==
Ex.
<> !=

Algorithmique C
x ← <Décalage de 2 à gauche de 7 bits> x = 2 << 7; /* x=256 */

79 80
M. ADDOU M. ADDOU

20
 OPERATEURS ET EXPRESSIONS OPERATEURS ET EXPRESSIONS
15) Opérateurs spécifiques Ex.
(151) L
L’opérateur
opérateur conditionnel « ? » a = (i<n) ? 0 : 1 ;
Une condition peut être traitée dans une affectation
comme suit : Ú
Si i<n Alors a ← 0
<variable> = <condition> ? <expression1> : <expression2> ; Sinon a ← 1
FinSi

<condition> est une expression logique à évaluer :

Si <condition> Alors <variable> ← <expression1>

Sinon <variable> ← <expression2>
FinSi 81 82
M. ADDOU M. ADDOU

OPERATEURS ET EXPRESSIONS OPERATEURS ET EXPRESSIONS

(152) Les affectations
Tableau descriptif des opérateurs ++ et -- :
Une affectation simple s’écrit :
Opérateur Notation Notation Signification Exemple
<variable> = <expression> ; équivalente

++ ++i i=i+1 n=++i ⇔ i=i+1 i=2; n=++i-2;

Le nom de la variable (référence mémoire) où sera rangée (préfixé) puis n=i ⇒ i=3 et n=1
la valeur de l’expression est appelée « Lvalue ». i++ i=i+1 n=i++ ⇔ n=i i=2; n=i++ -2;
(postfixé))
(p puis i=i+1
p ⇒ n=0 et i=3
ƒLL’opérateur
opérateur ++ (incrément)
L’opération d’incrémentation i=i+1 peut être réalisée par -- --i i=i-1 n=--i ⇔ i=i-1 i=2; n=--i-2;
(préfixé) puis n=i ⇒ i=1 et n=-1
un opérateur unaire portant sur la lvalue « i », soit ++i
i-- i=i-1 n=i-- ⇔ n=i i=2; n=i-- -2;
ƒ L’opérateur - - (décrément) (postfixé) puis i=i-1 ⇒ n=0 et i=1
L’opération de décrémentation i=i-1 peut être réalisée
par un opérateur unaire portant sur la lvalue « i », soit --i 84
M. ADDOU 83 M. ADDOU

21
 OPERATEURS ET EXPRESSIONS OPERATEURS ET EXPRESSIONS
Tableau descriptif des opérateurs d’affectations élargies :

ƒ Les opérateurs d’affectation

d affectation élargie
opérateur Notation Notation équivalente
Une affectation peut être « élargie »
+= n += i n=n+i
Ex. n=n+i *= n *= i n=n*i
en utilisant des opérateurs unaires portant sur la lvalue, /= n /= i n=n/i
comme n += i %= n %= i n=n%i
<<=
<< n <<
<<= i n = n << i
>>= n >>= i n = n >> i
&= n &= i n=n&i
|= n |= i n=n|i
^= n ^= i n=n^i
85 86
M. ADDOU M. ADDOU

OPERATEURS ET EXPRESSIONS OPERATEURS ET EXPRESSIONS

ƒ Une expression peut être :
2) Expressions - une constante
ƒ Une expression est formée à partir : - une variable
i bl
- d’opérandes - un appel de fonction
- d’opérateurs - une expression arithmétique, logique ou chaîne

ƒ Une expression intervient dans des instructions : ƒ Une expression possède une valeur et un type
- d’affectation ƒ Les variables dans une expression peuvent être :
-dd’affichage
affichage - simples (entiers,
(entiers réels,
réels caractères,
caractères pointeurs)
-… - structurées (tableaux, structures, unions)

87 88
M. ADDOU M. ADDOU

22
 PROGRAMMATION EN C STRUCTURES DE CONTROLE

1) Schémas conditionnels
11) Schéma
S hé Si

Algorithmique C

Si <Condition> If ( <condition> )
STRUCTURES DE CONTROLE alors <action1> <action1> ;
[sinon <action2>] [else <action2> ;]
FinSi

89 90
M. ADDOU
M. ADDOU

STRUCTURES DE CONTROLE STRUCTURES DE CONTROLE

Rq. Ex1.
- <action1> et <action2> peuvent correspondre à :
* une action simple (une seule action) Algorithmique C
* une action composée Si taxe <1000 if (taxe <1000.)
alors taux ← O taux = 0 ;
<Action1> ; sinon else if (taxe <2000.)
<Action2> ; si taxe <2000 taux = 1 ;
… alors taux ←1 else taux = 2 ;
sinon taux ← 2
<Action n> ; FinSi
- placer la liste des instructions d’une
d une action composée FinSi
dans un bloc limité par :
{
...
}
91 92
M. ADDOU M. ADDOU

23
 STRUCTURES DE CONTROLE STRUCTURES DE CONTROLE
/* Recherche du maximum */
Ex2.
#include <stdio.h>
Ranger le maximum de trois nombres X, Y, Z
void main ()
dans une variable Max. {
float X, Y, Z, Max;
printf (‘‘Données :’’);
Solution scanf (‘‘%f %f %f’’,&X,&Y,&Z);
Max = X;
Données : X, Y, Z (float) if (Y > Max) Max = Y;
Résultat : Max (float) if (Z > Max) Max = Z;
printf (‘‘Max = %f \n’’, Max);
93
} 94
M. ADDOU M. ADDOU

STRUCTURES DE CONTROLE STRUCTURES DE CONTROLE

Ex1.
12) Schéma Cas (ou choix multiple) Suivant la valeur de la variable « choix », on exécute une
procédure p
p parmi les p
procédures « saisie »,, « modification »,,
Algorithmique C « suppression » et « Edition »
Cas <Variable > de : switch (<variable>) { Algorithmique C
<Valeur1> :<actions1> ; case <Valeur1>: <actions1>;
choix : entier Int choix ;
<Valeur2> :<actions2> ; [break ;]
… case <Valeur2>: <actions2>; Cas choix de : switch (choix) {
<Valeurn> : <actionsn> ; [break ;] 1 : saisie case 1 : saisie ( ) ;
[sinon <actions>] … 2 : modification break ;
FinCas case <Valeurn>: <actionsn>; 3 : suppression case 2 : modification ( ) ;
[break ;] 4 : Edition break ;
[default : <actions> ;] FinCas case3 : suppression ( ) ;
} break ;
case 4 : Edition ( ) ;
}

95 96
M. ADDOU M. ADDOU

24
 STRUCTURES DE CONTROLE STRUCTURES DE CONTROLE
/* Nombre de jours par mois */
#include <stdio.h>
Ex2. void main ()
{
Ecrire pour une année donnée et un mois donné int Annee, Mois, Nbjours;
printf (‘‘Année : \n’’);
le nombre de jours de ce mois. scanf (‘‘%d’’,&Annee);
printf (‘‘Mois : \n’’);
scanf (‘‘%d’’,&Mois);
switch (Mois) {
case 1: case 3: case 5: case 7: case 8: case 10: case 12 : Nbjours=31;
break;
case 4: case 6: case 9: case 11 : Nbjours = 30;
Solution break;
case 2 : if (Annee % 400 == 0 || (Annee % 4 == 0 && Annee % 100 != 0))
Données : année, mois (int) Nbjours = 29;
else Nbjours = 28;
Résultat : Nbjours (int) }
/* ou Nbjours = (Annee % 400 == 0 || (Annee % 4 == 0 && Annee % 100 != 0)) ? 29 : 28; */

printf (‘‘Nombre de jours : %d \n’’, Nbjours);

97 98
}
M. ADDOU M. ADDOU

STRUCTURES DE CONTROLE STRUCTURES DE CONTROLE

Exercices 2) Itérations (boucles)
21) Schéma Répéter (Boucle do)
1) Soient X, Y et Z trois réels donnés. Classer les
valeurs correspondantes dans l’ordre croissant Algorithmique C
Répéter : do
de façon à avoir X < Y < Z. <Action> <Action> ;
Jusqu’à : <condition> while (non <condition>) ;
2) Afficher le type du caractère tapé au clavier
( hiff lettre
(chiffre, l tt ou autre).
t ) R
Rq.
<Action> peut être une action simple ou composée
3) Ecrire un programme qui imprime le type de (et dans ce dernier cas, elle sera limitée par :
lettre tapée au clavier (voyelle ou consonne) en « { » et « } »)

M. ADDOU
transformant les majuscules en minuscules. 99 M. ADDOU
100

25
 STRUCTURES DE CONTROLE STRUCTURES DE CONTROLE
Ex. 22) Schéma Tant que (Boucle while)
Algorithmique C Algorithmique C

i←0 i=0; Tant que <condition> faire : while (<condition>)

Répéter : do <action> <action> ;
i←i+1 i=i+1; Fin tant que
Jusqu’à : i = 10 while (i != 10) ;

Rq.
<Action> peut être une action simple ou composée
(et dans ce dernier cas, elle sera limitée par :
« { » et « } »)

101 102
M. ADDOU M. ADDOU

STRUCTURES DE CONTROLE STRUCTURES DE CONTROLE

Ex. 23) Schéma Pour (Boucle for)
Algorithmique C
Algorithmique
g q C
Pour <var> allant de for ([<var>=<val initiale>] ; [<var> <= <val finale>] ;
i←0 i=0; <val initiale> à <val finale> faire [<var>=<var> + <pas-variation>] )
s←0 <action>
s=0; <action> ;
Fin Pour
Tant que i <= 10 faire : while (i <=10)
i←i+1 {
s←s+i i=i+1; Ex.
Fin tant que s= s + i ;
} Algorithmique C
S←0 s=0;
Pour i allant de 1 à 10 faire for (i = 1 ; i <= 10 ; i = i + 1)
s←s+i {
Écrire (‘i = ’ , i , ‘ et ‘ , s=s+i;
‘s = ‘ , s) printf(‘‘i = %d et s = %d \n’’, i , s) ;
FinPour }
103 104
M. ADDOU M. ADDOU

26
 STRUCTURES DE CONTROLE STRUCTURES DE CONTROLE
Rq.
Ex.
ƒ <Action> peut être une action simple ou composée
ƒ La
L conditionditi d’
d’arrêt
êt peutt êt
être une expression
i llogique
i
Ecrire la somme des n premiers nombres impairs
quelconque
ƒ l’expression d’initialisation peut être quelconque Solution
ƒ les expressions du « for » peuvent être absentes
Ex. for ( ; i<=10 ; ) Données : n (int)
n
- L’initialisation de i peut se faire juste avant « for » et Résultat : S=∑ (2*i – 1)
i=1
ll’incrémentation
incrémentation à l’intérieur
l intérieur de la boucle
- Si la condition est absente, elle est considérée comme
vraie
ƒ on peut grouper plusieurs actions dans les expressions Rq.
du « for »
105
Nb d’itérations connu : n fois ⇒ Boucle for 106
M. ADDOU
Ex. for (i=0, j= 1 ; i<=10 ; i++, j++) M. ADDOU

STRUCTURES DE CONTROLE STRUCTURES DE CONTROLE

3) branchements inconditionnels :
/* Somme des n premiers nombres impairs */
#include <stdio
<stdio.h>h>
sortie ou saut au début d’une séquence
q
void main () - Les branchements inconditionnels sont déconseillés dans
{ une programmation dite « structurée »
int n,i,s;
printf (‘‘n = ’’); - Néanmoins, on peut citer les instructions suivantes :
scanf (‘‘%d’’,&n);
s=0; Algorithmique C
for ((i=1 ; i<=n ; i=i+1)) interrompre break
s = s + (2 * i - 1); continuer continue
printf (‘‘S = %d \n’’, s) Aller à goto
}
retourner return
sortir exit

107 108
M. ADDOU M. ADDOU

27
 STRUCTURES DE CONTROLE STRUCTURES DE CONTROLE
Devoir libre Exercices

Donner la définition des instructions de branchement 1) Calculer xn (x : réel et n : entier algébrique)

inconditionnel suivantes avec illustration à travers un exemple :
2) Calculer la racine carrée d’un nb A en utilisant la suite récurrente :
Définition : … x1 = 1
break xn = ½*(xn-1+A/xn-1)
Exemple : …
On arrêtera les calculs qd |xn-xn-1| ≤ EPS (EPS donné <<1)
Définition : …
continue
Exemple : … 3) Calcul de la racine carrée d’un nombre x > 0 par la méthode
dichotomique :
Définition : …
goto
t - chercher
h h un encadrement
d de √x
[[a, b] d √ :
Exemple : … x ≥ 1 ⇒ 1 ≤ √x < x sinon x < √x < 1
Définition : … - chercher à réduire l’amplitude de [a, b] en posant :
return
Exemple : … m = (a + b)/2
Définition : … et en comparant m2 et x
exit - itérer le procédé jusqu’à obtenir un encadrement d’amplitude < EPS
Exemple : … 109 110
(EPS donné)
M. ADDOU M. ADDOU

PROGRAMMATION EN C TP
1) Environnement de développement
Code-Blocks : IDE (Integrated Development Environment)
libre et open source
(compilateur installé avec Code-Blocks : GNU GCC Compiler.)

TP

111 112
M. ADDOU
M. ADDOU

28
 TP TP
2) Différentes phases de vie d’un programme 3) Espace de travail
- édition du code source (File/New) - fenêtre “espace
espace de travail”
travail ou workspace
- compilation du programme (Build/Compile) (différents constituants du programme : fichiers,
avec l’édition des liens fonctions, classes, …)
- débogage (Build/Start) - fenêtre “édition de programmes sources”
- eexécution
écu o (Build/Run)
( u d/ u ) ((affichage
c ge du contenu
co e u des programmes
p og es sources)
sou ces)
- fenêtre “sortie” ou output
(messages de compilation, d’édition de liens, ...)

113 114
M. ADDOU M. ADDOU

TP TP
4) Notion d’application console
programme ss’exécutant
exécutant sur une fenêtre Windows comme ss’il
il
s’agit d’une fenêtre DOS.

5) Notion de projet
C’est un [Link] pour Code-Blocks Project
( t
(contenant
t les
l infos
i f utiles
til pour créer
é un programme exécutable
é t bl :
noms de fichiers sources, en-têtes, modules objets)

116
M. ADDOU 115 M. ADDOU

29
 TP TP
7) TP1 7) TP2
Génération de nombres aléatoires
On veut chercher le PGCD de deux nombres entiers x et y donnés
Initialisation
en utilisant la méthode de recherche d’Euclide qui consiste à faire
des divisions successives des dénominateurs par les restes - inclusion de la bibliothèque stdlib.h
jusqu’à obtenir un reste nul. - utilisation de rand() comme générateur de nombres aléatoires.

Écrire un programme qui permet de chercher et d’afficher le Écrire un programme C qui fournit :
PGCD de x et y.
(1) un nombre entier tiré au hasard entre 0 et 32767 : constante
RAND_MAX (Faire 10 tirages).

(2) un nombre réel tiré au hasard entre 0 et 1 (Faire 10 tirages).

(3) un nombre entier tiré au hasard entre 0 et une valeur n donnée

(Faire 10 tirages).
117 118
M. ADDOU M. ADDOU

PROGRAMMATION EN C VARIABLES STRUCTURÉES

1) Notion de tableau
ƒ Tableau : Collection de variables de même type
ƒ Un tableau est déclaré par :
- son nom
- son type
VARIABLES STRUCTURÉES - ses dimensions
- ses bornes
ƒ Chaque élément du tableau est représenté par :
- le nom du tableau
- un ou plusieurs indices placés chacun entre crochets

119 120
M. ADDOU
M. ADDOU

30
 VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES
2) Notion de vecteur Ex2.
Tableau à 1 dimension
Algorithmique C
Algorithmique C
Constante : Nmax = 10 #define Nmax 10
Constante: Nmax = <valeur> #define Nmax <valeur>
ou ou
const int Nmax = <valeur>; const int Nmax = 10;
Table:vecteur de Nmax <Type-données> <Type-données> Table [Nmax];
T : vecteur de Nmax réels float T[Nmax] ; /*premier indice : 0 */
(indice : 0 … Nmax-1)
(indice : 0 … Nmax-1)
ou /* en cas d’initialisation */
Ex1. float T[Nmax]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10} ;
X : Vecteur de 10 réels (indice : 0 … 9) ou /* en cas de qq initialisations */
float T[Nmax]={1, , , ,0, , , 0, ,1} ;
X est déclaré par :
float X[10]; /* premier indice : 0 */ 121 122
M. ADDOU /* dernier indice : 9 */ M. ADDOU

VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES

/* Max et Min d’un vecteur */
Exemple #include <stdio.h>
void main()
Soit
S it V un vecteur
t à n éléments
élé t réels.
é l {
Écrire un programme C qui calcule le maximum int n, i;
float V[100], Max, Min;
et le minimum sur les n éléments du vecteur V. printf(‘‘Dimension :’’);
scanf(‘‘%d’’,&n);
for (i=0; i<n; i++)
scanf(‘‘%f’’,&V[i]);
Max = V[0];
Données : dimension n (int) Min = V[0];
for (i=1; i<n; i++)
vecteur V de n réels (float) if (V[i] > Max) Max = V[i];
else if (V[i] < Min) Min = V[i];
printf (‘‘Maximum : %6.2f’’, Max);
Résultats : Max, Min (float) printf (‘‘Minimum : %6.2f’’, Min);
123 } 124
M. ADDOU M. ADDOU

31
 VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES
3) Notion de matrice Ex2.
Tableau à plusieurs dimensions
Algorithmique C
Algorithmique C
Constante : Nmax = 10 #define Nmax 10
Constante : Nmax = <valeur> #define Nmax <valeur>
ou ou
const int Nmax = <valeur>; const int Nmax = 10;
Table : matrice de Nmax *Nmax <Type- <Type-données> Table [Nmax] [Nmax];
données> M : matrice de Nmax * float M[Nmax][Nmax]; /*premiers indices : 0, 0*/
(indice:0 … Nmax-1,0 … Nmax-1) Nmax réels
ou /* en cas d’initialisation */
(indices : 0 … Nmax-1,
Nmax 1
Ex1. 0 … Nmax-1) float M[Nmax][Nmax]={{1,2,3,4,5,6,7,8,9,10},
{1,2,1,4,1,6,1,8,1,10},
M : Matrice de 10*20 réels (indice : 0 … 9, 0 … 19) …};

M est déclaré par : ou /* en cas de qq initialisations */

float M[Nmax][Nmax]={{1,0,1,,,,,,,0}, {0,,,,1,,,,, 0},
float M[10][20]; /* premiers indices : 0, 0 */ 125 ,,,…}; 126
M. ADDOU /* derniers indices : 9, 19 */ M. ADDOU

VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES

/* Produit Matriciel */
Exemple #include <stdio.h>
#define Nmax 50
Calculer le produit de deux matrices A(n, p) void main()
{
et B(p, q) dans C. int n, p, q, i, j, k;
float A[Nmax][Nmax] , B[Nmax][Nmax] , C[Nmax][Nmax];
puts (‘‘Dimensions n, p, q :’’);
scanf (‘‘%d %d %d’’, &n, &p, &q);
puts (‘‘Matrice A :’’);
for ((i=0;; i<n;; i++))
D
Données
é : n, p, q (i
(int)
t) for (j=0; j<p; j++)
scanf (‘‘%f’’, &A[i][j]);
A(n, p), B(p, q) (float) puts (‘‘Matrice B :’’)
for (i=0; i<p; i++)
Résultats : C(n, q) (float) for (j=0; j<q; j++)
scanf (‘‘%f’’, &B[i][j]);
127 128
M. ADDOU M. ADDOU

32
 VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES

puts (‘‘Matrice produit C :’’);

Exercices
for (i=0; i<n; i++)
{ 1) V vecteur de réels à éclater en Vpositif et Vnégatif.
for (j=0; j<q; j++)
{ 2) Recherche séquentielle et recherche dichotomique d’un
C[i][j] = 0; élément x dans un vecteur V.
for (k=0; k<p; k++)
C[i][j] = C[i][j] + A[i][k] * B[k][j];
printf (‘‘%6.2f’’, C[i][j]); 3) Insertion d’un élément x dans un vecteur V trié.
} /* Fin
i Boucle j */
printf (‘‘\n’’); /* retour à la ligne */
} /* Fin Boucle i */ 4) Calcul du triangle de Pascal.

129 130
M. ADDOU M. ADDOU

VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES

3) Notion d’enregistrement/structure (1) Type structure

A
Autres noms : Variable
i bl composée
é , Structure
S Algorithmique C
Type typedef struct
• Enregistrement : Ensemble d’infos <Nom de type> = Enregistrement
<Nom de champ1> :<Type de
{
<Type de données> <Nom de
données> champ1> ;
de types différents <Nom de champ2> :<Type de <Type de données> <Nom de
données> champ2> ;

• 1 info ⇒ un champ (désigné par un nom et un type) … …

} <Nom de type> ;
FinEnregistrement

131 132
M. ADDOU M. ADDOU

33
 VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES
ou
Algorithmique C
struct <Nom de type>
Ex1.
{ Un abonné au téléphone :
<Type de données> <Nom de
champ1> ;
- code (entier)
<Type de données> <Nom de - nom (20c)
champ2> ;
… - prénom (20c)
} ; - adresse (40c)
- téléphone (9c)

133 134
M. ADDOU M. ADDOU

VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES

Ex2.
Abonné est déclaré ppar : Calculer la somme de deux nombres complexes
typedef struct { représentés en coordonnées cartésiennes.
int code;
char *nom; /* ou char nom[20] */
Solution
char *prenom; /* ou char prenom[20] */
char *adresse; /* ou char adresse[40] */
char
h *telephone;
* l h /* ou char telephone[10] */
Données : z1, z2 (complexes)
} abonne;

Résultat : z (complexe)
135 136
M. ADDOU M. ADDOU

34
 VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES
/* Somme Complexe */
#include <stdio.h> Exercices
typedef struct {
float Re
Re, Im;
} complexe;
void main() 1) Etant donnés 2 points A et B, calculer le milieu de
{ [A, B] sachant qu’un point est décrit par : un nom
complexe z1, z2, z;
puts (‘‘Partie réelle et partie imaginaire de z1 :’’); (1c) et deux cordonnées x et y (réelles ).
scanf (‘‘%f %f’’, &[Link], &[Link]);
puts (‘‘Partie réelle et partie imaginaire de z2 :’’);
scanf ((‘‘%f %f’’,, &[Link],, &[Link]); );
[Link] = [Link] + z2. Re;
2) Les n élèves d’une
d une classe sont définis dans un vecteur
[Link] = [Link] + [Link]; par un nom (20c), un prénom (20c), une note (réel).
printf (‘‘z = ’’);
if ([Link] == 0.) printf(‘‘%5.2f’’, [Link]); - Donner la moyenne de la classe
else { if ([Link] != 0.) printf (‘‘%5.2f’’, [Link]); - Classer les élèves dans l’ordre décroissant de leur
printf (‘‘%+5.2f i \n’’, [Link]);
} 137 note. 138
M. ADDOU } M. ADDOU

VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES

(2) Type structure : champs de bits
Syntaxe
• Les champs
h ddans une structure peuvent êêtre des
d champs
h dde bi
bits.
• Un champ de bit est un ensemble de bits contigus à l’intérieur struct <nom>
{
d’un même mot mémoire.
unsigned int <champ1> : <longueur1>;
• On peut définir une structure avec un découpage mémoire en unsigned int <champ2> : <longueur2>;
...
champs de bits en déclarant chacun de ses éléments avec le type
unsigned int <champn> : <longueurn>;
unsigned int et un nombre indiquant le nombre de bits du };
champ.

139 140
M. ADDOU M. ADDOU

35
 VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES
Ex. représentation d’un nombre réel (float)
Rq.
Rq
Signe (0/1) Exposant sur 8 bits Mantisse NORMALISEE sur 23 bits • Un champ peut ne pas avoir de nom. Sa longueur
indique alors le nombre de bits que l'on veut ignorer.
typedef struct • Une longueur égale à 0 permet de forcer l'alignement
{unsigned int signe : 1;
unsigned int exposant : 8; sur le début du mot mémoire suivant.
unsigned int mantisse : 23;
} reel;
141 142
M. ADDOU M. ADDOU

VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES

Ex.
Rq.
code (6 bits) 10 bits quantite (16 bits)
• Un champ de bits n'a pas d'adresse (on ne peut lui
appliquer l'opérateur adresse &).
typedef struct
• Les champs de bits sont évalués de gauche à droite sur
{unsigned int code : 6;
unsigned int : 0; certaines machines et de droite à gauche sur d'autres.
unsigned int quantite : 16;
• Ce type de données n'est donc pas portable.
} article;

143 144
M. ADDOU M. ADDOU

36
 VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES
(3) Type union
ou
L’union en C, permet d’interpréter l’espace mémoire d’une
variable de plusieurs façons différentes (économie d’espace
d espace
union <Nom de type>
mémoire) :
{
réserver un seul espace pour toutes les interprétations <Type de données> <Nom de champ1> ;
au lieu de <Type de données>: <Nom de champ2> ;
un espace pour chacune des interprétations …
Le type « union » est défini par : } ;
t
typedef
d f union
i
{
<Type de données> <Nom de champ1> ;
<Type de données> <Nom de champ2> ;
…
145 146
M. ADDOU
} <Nom de type> ; M. ADDOU

VARIABLES STRUCTURÉES VARIABLES STRUCTURÉES

Ex.
typedef union
{ Exercice
long entier ;
float reel ;
} EntierOuReel;
void main() Écrire un programme C qui :
{ long n;
EntierOuReel nombre; - définit une union pouvant contenir un caractère,
printf ("taper un nombre entier : ") ; un entier ou un réel
scanf ("%d", &n);
if (n>32767) - lit la
l valeur
l du
d membre
b au clavier
l i
{[Link]= (float) n;
printf ("Reel correspondant : %11.4e\n", [Link]) ; - affiche cette valeur ainsi que son adresse
}
else {[Link]= n; en vérifiant les 3 types pour une même valeur puis
printf ("Entier correspondant : %d\n", [Link]) ; les 3 valeurs pour un même type (le caractère).
}
147 148
M. ADDOU
} M. ADDOU

37
 PROGRAMMATION EN C CHAÎNES DE CARACTÈRES
Déclaration

Algorithmique C
chaîne char * <Nom d’un pointeur sur chaînes>

chaîne (<entier>) char tableau [<entier>]

CHAÎNES DE CARACTÈRES Ex.

Al
Algorithmique
ith i C
Ch1 : chaîne char * ch1 ;
Ch2 : chaîne (20) char ch2[20] ;

149 150
M. ADDOU
M. ADDOU

CHAÎNES DE CARACTÈRES CHAÎNES DE CARACTÈRES

Exemples d’opérateurs sur chaînes :
Rq. concaténation et opérateurs de comparaison.
Une chaîne de caractères est un vecteur de caractères Algorithmique C
terminé par le caractère spécial ‘\0’ ( ou NULL) ch1 + ch2 (+ : opérateur) strcat (ch1, ch2) (strcat : fonction)
= <> < <= > >= == != < <= > >=
Ex.
Exemples de fonctions sur chaînes (string.h) :
char c[ ] = ‘‘bonjour’’ ; ⇔ char c[ ] = {‘b’, ‘o’, ‘n’, ‘j’, ‘o’,
Algorithmique C
‘u’, ‘r’, ‘\0’} ;
Longueur (ch) strlen (ch)
(taille calculée par le compilateur)
Ch2=Copie(ch1,position,longueur) strncpy(ch2,ch1,longueur)
P=PositionChaine(Sch,ch) strstr(ch, sch)

Rq.
On peut copier dans une variable chaîne, une autre variable chaîne
151
ou une constante chaîne en utilisant la fonction « strcpy ».
M. ADDOU M. ADDOU Ex. strcpy (ch, ‘’bonjour’’) ; /** pour initialiser ch à ‘’bonjour’’ **/ 152

38
 VARIABLES STRUCTURÉES PROGRAMMATION EN C
Exercices
1) Écrire un programme qui lit un verbe
régulier en "er" au clavier et qui en affiche
la conjugaison au présent de l'indicatif de
ce verbe. Contrôlez s'il s'agit bien d'un
verbe en "er" avant de conjuguer.
TP
Utiliser les fonctions ggets,, pputs,, strcat et strlen.
2) On se donne une chaîne de caractères qui
représente un nombre en chiffres romains
et on demande de la convertir au nombre
décimal correspondant. 154
M. ADDOU
M. ADDOU
153

TP PROGRAMMATION EN C
TP3
(à rendre au plus tard le jeudi 02/12/10)
Reprendre l’exercice de conjugaison.
Écrire un programme qui lit un verbe quelconque du
premier groupe au clavier et qui en affiche la conjugaison NOTION DE SOUS-PROGRAMME
au présent de l'indicatif de ce verbe. Contrôlez s'il s'agit
bien d'un
d un verbe en "er"
er avant de conjuguer.
conjuguer
Utiliser les fonctions gets, puts, strcat et strlen.

155 156
M. ADDOU
M. ADDOU

39
 NOTION DE SOUS-PROGRAMME NOTION DE SOUS-PROGRAMME
1) Définition
Rq.
q.
C’ t une partie
C’est ti de
d programme quii : (1) Bien distinguer entre :
• possède un nom - définition du s/programme
- appel du s/programme
• peut être appelée (par ce nom) pour exécuter
une tâche bien déterminée (2) Bien distinguer entre :
- paramètres formels du s/programme
Deux cas : - paramètres effectifs (réels) du s/programme
- procédure
157 158
M. ADDOU
- fonction M. ADDOU

NOTION DE SOUS-PROGRAMME NOTION DE SOUS-PROGRAMME

2) Structure générale d’un programme C 3) Définition d’une procédure
Algorithmique C
[#include <Fichiers ou bibliothèques externes>]
[#define <Constantes ou macros fonctions>] Procédure<nom procédure> void <nom-procédure>([<type> <paramètre1>]
[const <Définition de constantes externes> ;] ([variable] <paramètre1> [, <type> <paramètre2>]
[typedef <Définition de types de données externes> ;] [,<paramètre2>] [, ...] : [, ...])
[<Définition de variables externes> ;] <type> ; ...) {
[<Prototypes de fonctions externes> ;] [déclarations locales] [déclarations locales> ;]
Début : <actions> ;
[<Définition de fonctions> ;]
<actions> }
void main ( ) Fin
{
[<Définition de variables> ;]
[<Prototypes de fonctions > ;]
<Corps du Programme Principal> ; Rq.
}
[<Définition de fonctions> ;]
Un tableau peut être déclaré par un identificateur dans la liste des
159 arguments ou suivi de crochets [ et ] 160
M. ADDOU M. ADDOU

40
 NOTION DE SOUS-PROGRAMME NOTION DE SOUS-PROGRAMME
Ex. Rq.
La procédure sera appelée par son nom de la même façon dans les
Algorithmique C trois écritures avec des p
paramètres effectifs.
Type vect=vecteur de 20 réels <Nom procédure> (<paramètre 1> [, ...])
(indice : 1 ...20)
Procédure Insertion (x : réel ; void insertion (float x, float v[ ], int n) <Nom procédure> (<paramètre 1> [, ...]);
variable v :vect ; variable n : {
entier) int i ; Ex.
variable i : entier i = n-1 ;
début : i ←n while ( i>=1 && x <v[i] ) On pose : T = {0, 1, 2, 3, 4, 5}
tant qque ((i>=1)) et ((x<v(i))
( )) { xo = 2.5
v(i+1) ← v(i) v[i+1] = v [i] ; no = 6
i← i –1 i = i – 1;
fin tant que } n0 doit être déclaré comme variable globale (n0 sera modifié)
v(i+1) ← x v[i+1] = x ;
n←n+1 n=n+1; Algorithmique C
fin } Insertion (xo , T , no) insertion (xo , T , no) ;
161 162
M. ADDOU M. ADDOU

NOTION DE SOUS-PROGRAMME NOTION DE SOUS-PROGRAMME

Rq.
4) Définition d’une fonction • En C, un argument lors d’un appel est « dit » transmis par valeur mais il peut
Algorithmique
g q C
s’agir de :
- la
l valeur
l de
d l’argument
l’ (passage
( par valeur)
l )
Fonction<nom fonction> [<type valeur de fonction>] <nom fonction> - ou de la valeur de l’adresse de l’argument (passage par adresse)
([variable] <paramètre1> ([<type> <paramètre1>]
[,<paramètre2>] [, ...] : [, <type> <paramètre2>]
• Dans la liste des paramètres formels, un paramètre peut être déclaré sous
<type> ; ...) : <type valeur [, ...]) forme de pointeur pour pouvoir modifier la valeur de l’argument dans la
de la fonction> { fonction appelée
[déclarations locales] [déclarations locales>;] Ex. float *p; (notation : p pointeur sur un réel ou adresse d’un réel)
Début : <actions> ;
<actions> return <expression> ; • Dans la fonction appelante,
pp , l’argument
g sera transmis sous forme d’une
<nom fonction>← } référence mémoire
<expression> • Pour un tableau, cette référence correspond au nom du tableau
Fin
• Pour une variable simple, cette référence correspond au nom de la variable
précédé du caractère « & »

163
Ex. Définition : int f (flaot x, float *y) {… y=…; …} 164
M. ADDOU M. ADDOU Appel : z=f(x0,&y0);

41
 NOTION DE SOUS-PROGRAMME NOTION DE SOUS-PROGRAMME
Ex.
Rq. Algorithmique C

Fonction factorielle (n :entier) : entier long factorielle (int n)

Pour appeler une fonction, on l’utilise dans une expression: Variable F,i : entiers {
- affectation Début : int i ;
F←1 long F = 1 ;
Ex. Y = <nom-fonction>(<paramètres réels>); For i allant de 1 à n for (i = 1 ; i < = n ; i ++)
- écriture faire F=F*i;
F←F * i return F ;
Ex. printf (‘‘ …’’, <nom-fonction>(<paramètres réels>)); Fin pour }
Factorielle ←F
Fin
Ex. Fonction fact (n :entier) : entier long fact (int n)
Début : {
Si n=0 alors Fact ← 1 if (n==0) return 1;
y = f(x1) + f(x2); Sinon Fact ←n * Fact(n-1) else return n * fact(n-1);
printf (‘‘f(x1)=%6.2f, f(x2)=%6.2f, y=%6.2f \n’’, f(x1), f(x2), y); FinSi }
Fin
165 166
M. ADDOU M. ADDOU

NOTION DE SOUS-PROGRAMME NOTION DE SOUS-PROGRAMME

5) classes d’allocation des variables en C Ex. float f(float x)

⇒ quatre manières différentes pour allouer de l’espace à une {static int n ; // n: compteur (nombre d’appels de la fonction f)
variable
i bl (l
(lors d
de sa dé
déclaration)
l ti ) : n++;
...
• la variable appartient à la classe automatique
}
- variable locale à un bloc ou à une fonction
Rq.
- variable temporaire
- emplacement mémoire alloué à chaque entrée dans le - variables initialisées par défaut à zéro
bloc/fonction - emplacement mémoire alloué au moment de l’édition des liens
- emplacement mémoire libéré à chaque sortie • la variable appartient à la classe externe
• la
l variable
i bl appartient
ti t à lla classe
l statique
t ti ⇒ variable globale définie dans un fichier source
⇒ variable permanente définie durant toute l’exécution du (Sa définition reste limitée à ce fichier).
programme source : Si un autre fichier source, compilé à part, utilise cette variable,
- variable globale il déclare cette variable précédée du mot-clé « extern »
- variable locale à un bloc ou à une fonction déclarée à l’aide - aucune réservation mémoire n’est effectuée
du mot-clé « static » (valeur connue uniquement dans le - juste préciser que la variable globale est définie ailleurs en
167
M. ADDOU
bloc/fonction où la variable est définie) M. ADDOU précisant son type 168

42
 NOTION DE SOUS-PROGRAMME NOTION DE SOUS-PROGRAMME
Ex.
float y=5;
…
Exercice
f1 ()
{extern float y ; // ici y=5 Écrire un programme C qui :
…
- définit une fonction réelle f(x) donnée
}
• la variable appartient à la classe registre - calcule l’intégrale de f(x) sur un intervalle donné.
- variable très utilisée appartenant à la classe automatique
p
- variable temporaire
- sert à accélérer l’exécution du programme
- variable déclarée à l’aide du mot-clé « register »
⇒ Le compilateur placera cette variable dans un registre et non
en mémoire
Ex.
169 170
M. ADDOU register int n ; M. ADDOU

PROGRAMMATION EN C TP
TP4
Écrire un programme C qui permet de gérer une bibliothèque de livres
sous forme d’un vecteur de livres, à travers le menu suivant :
Bibliothèque

1 – Ajout
2 – Modification
3 –Suppression
TP 4 – Recherche
5 –Tri
6 – Edition
7 – Fin

Choix :

Chaque livre est décrit par un numéro de livre, un titre , un ou deux mots
clés, un auteur, un nom d’éditeur, une date d’édition, un numéro ISBN.
171 La recherche peut se faire par numéro de livre, par mots clés, par auteur
M. ADDOU
M. ADDOU ou par éditeur .

43
 PROGRAMMATION EN C STRUCTURES DE DONNÉES DYNAMIQUES
1) Les allocations mémoires
Comment allouer de l’espace mémoire à une variable ?
• Variable statique : espace alloué à la variable pendant sa
déclaration au début du programme et libéré à la fin du
programme,
STRUCTURES DE DONNÉES DYNAMIQUES • Variable automatique : espace alloué à la variable pendant sa
déclaration au début d’une unité de programme (Ex. une
fonction) et libéré à la fin de cette unité de programme,
• Variable dynamique : espace alloué à la variable et/ou libéré
pendant l’exécution du programme.
Les variables dynamiques sont gérées par des outils spéciaux :
173 174
M. ADDOU M. ADDOU les pointeurs.

STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

2) Structures de données statiques 4) Les pointeurs

Deux usages possibles :
Taille fixe pendant toute leur durée de vie - La
L valeur
l d’une
d’ variable
i bl est stockée
ké en mémoire
é i à une
adresse donnée. Pour y accéder, on utilise un pointeur.
Ex. Ex.
Variables scalaires, tableaux, enregistrements, …
Algorithmique C
x : entier int x, *p ;
3) Structures de données dynamiques p : ↑entier …
(* pointeur sur un entier *) …
Taille variable et durée de vie gérées par le programmeur … p=&x ; /* référence à x */
p ← @ x (*p=adresse de x*) /* ou adresse de x */
p↑ ← x (*contenu de p=x*) /* ou int *p=&x; */
Ex. *p=x; /* contenu de p */
Les listes, les graphes, les arbres
M. ADDOU 175 M. ADDOU
176

44
 STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

- Un pointeur permet de gérer une variable dynamique Ex.

(c’est à dire créer et détruire cette variable pendant Algorithme C
Type
T t d f struct
typdef t t {
l’exécution du programme chaque fois que le programmeur Etudiant=enregistrement int : code ;
le désire). Code :entier …
… } Etudiant ;
Le pointeur indique toujours l’adresse de la variable. FinEnregistrement -------------------------------------------------------------------
ptr = ↑Etudiant typdef struct Etudiant *ptr ;
variable p : ptr ptr p ;
(a) Déclaration d’un pointeur ou -------------------------------------------------------------------
variable p : ↑Etudiant ou
Algorithmique C Etudiant *p p;

↑<Type de données> * <Nom du pointeur> x : réel float x, *p ;

p : ↑réel …
(*pointeur sur un réel*) …
… p=&x ; /*référence à x*/
p ← @ x (*p=adresse de x*) *p=1.5 ;
p↑ ← 1.5 (*contenu de p=1.5*)
177 178
M. ADDOU M. ADDOU

STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

Ex.
(b) Pointeurs et tableaux int V[10] ;
ou
int V[10] ;
int i,, *p
p; int i,
i *pp;
nom d’un
d’ ttableau
bl = adresse
d d
du ttableau
bl /* V ≡ &V[0] */ /* V ≡ &V[0] */
= adresse de son premier élément /* V+1 ≡ &V[1] */ /* V+1 ≡ &V[1] */
/* V[1] ≡ *(V+1) */ /* V[1] ≡ *(V+1) */
Ce nom est considéré comme un pointeur du même type ... ...
for (i=0; i<10; i++)
que celui du tableau. V[i] = 1 ;
for (i=0; i<10; i++)
*(V+i) = 1 ;
ou
int V[10] ;
int i, *p ;
/* V ≡ &V[0] */
/* V+1 ≡ &V[1] */
/* V[1] ≡ *(V+1) */
...
for(p=V,i=0; i<10; i++,p++)
179 180
M. ADDOU M. ADDOU *p= 1 ;

45
 STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

(c) Tableau transmis en argument dans un sous-programme

ou
void
id P
Proc (int
(i t n, iintt V[ ])
ou { void Proc (int n, int *p)
void Proc (int V[10]) {
{ void Proc (int *p) int i ;
{ for (i=0; i<n; i++) int i ;
int i ; for (i=0; i<n; i++, p++)
for (i=0; i<10; i++) int i ; V[i] = 1 ;
for (i=0; i<10; i++, p++) } *p = 1 ;
V[i] = i*i ; }
} *pp = ii*ii ;
}
Appel : int T[100], n0;
Appel : int T[10]; …
… Proc ( n0, T);
Proc (T); …
181 182
M. ADDOU … M. ADDOU

STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

(d) Pointeurs et chaînes char p[10] ;

...
nom de
d lla chaîne
h î = adresse
d d
de lla chaîne
h î p = ‘‘bonjour’’ ;
= adresse de son premier caractère puts(p);
printf (‘‘2 ème caractère de p : %c \n’’, p[1]);
Ce nom est considéré comme un pointeur de type
caractère.
ou
char *pp;
...
p = ‘‘bonjour’’ ;
puts(p);
printf (‘‘2 ème caractère de p : %c \n’’, *(p+1));
183 184
M. ADDOU M. ADDOU

46
 STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES
/** Esquisse du programme « Intégrale d’une fonction » **/
(e) Pointeurs et fonctions /** f est un pointeur contenant l’adresse d’une fonction à 1 argument **/
/** g=(*f) sera l’adresse de la valeur d’une fonction à 1 argument **/
nom de
d la
l ffonction
ti = adresse
d d
de la
l ffonction
ti en mémoire.
é i /** g(x)=(*f)(x) est une fonction à 1 argument **/
float integrale (float (*f)(float x), float A, float B, int N)
Ce nom est considéré comme un pointeur sur cette {
…
fonction. }
/** Fonction Principale **/
main()
{ float aa, b;
int n;
float f1(float x), f2(float x) ; /* prototypes */
...
result1 = integrale (f1, a, b, n);
result2 = integrale (f2, a, b, n);
185 ... 186
M. ADDOU M. ADDOU
}

STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

(a) Gestion d’une liste
5) Les listes
- Gestion statique : gestion par tableau
Liste : suite d
d’éléments
éléments (ou cellules) chaînés entre eux
⇒ représentation simplifiée
(Ces éléments sont des variables toutes de même type)
Ex.
Nommons ce type « objet » #define Nmax …
…
type
yp simple
p ((caractère, entier, réel, …)) objet liste [Nmax];
Rq.
objet
- Nmax et objet doivent être définis
type structuré (tableau ou enregistrement) - la mise à jour de la liste n’est pas pratique
- Gestion dynamique : utilisation des pointeurs
187 188
M. ADDOU M. ADDOU
⇒ méthode plus efficace

47
 STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

Ex.
Rq. Type pointeur
typedef objet *lien; /*définition du type pointeur
Pointeur sur un objet*/
bj t*/
Variable de type pointeur lien p1; /*définition d’un pointeur
objet *p2; sur un objet*/
- Le type pointeur est un type simple
Rq.
(Mais ce n’est pas un type prédéfini) • L’astérisque indique que :
- Une variable de type
yp ppointeur ((ou un p
pointeur)) est une - « lien » est un type pointeur
- « p2 » est une variable de type pointeur
adresse ou une référence à un élément en mémoire • p1 occupe une seule case mémoire
(idem pour p2)
• Une variable de type « objet » peut être associée à p1,
elle sera notée : *p1
189 190
M. ADDOU M. ADDOU (idem pour p2, elle sera notée : *p2)

STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

- Quand p1 n’est associé à aucun objet, il renferme

- Schéma : la valeur « NULL ».
Ex. p1 = NULL;
objet cet objet est nommé *p1
p1 (objet pointé par p1) Schéma :
• ou •
cet objet est nommé *p2 p1 p1 terre
objet
p22 ((objet
bj t pointé
i té par p2)
2)
- Il faut bien distinguer entre le pointeur
et
l’objet qu’il pointe
191 192
M. ADDOU M. ADDOU

48
 STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

Ex. typedef objet *lien;

x = y; ⇒
lien x, y ; /* équivalent à : objet *x, *y; */
/* x pointe sur un objet (x : destiné à référencer un objet) */ x
/* y pointe sur un objet (y : destiné à référencer un objet) */

… y
x=UnCarre; /* création de x (UnCarre déjà défini) */
y=UnCercle ; /* création de y (UnCercle déjà défini) */

Soient : et /* duplication de y */
x y 193
194
M. ADDOU M. ADDOU

STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

(b) Gestion de l’espace dynamique
Comment créer puis libérer des variables dynamiques pendant
y; ⇒
*xx = *y;
l’exécution d’un programme ?
x
Utiliser : #include <malloc.h>
- Allocation dynamique
y
p=[(<type pointeur> *)]
p=[(<type-pointeur> )] malloc (<taille en octets>) ;

Ou (pour variable de taille variable Ex. tableau )

/*duplication de UnCercle */
p=[(<type-pointeur> *)] calloc (<nb-vars>,<taille par var>);
195
M. ADDOU M. ADDOU 196

49
 STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES
Ex1.
Algorithmique C
char *p1;
p ; /* pp1 : destiné à référencer une chaine de caractères*/
Variable
V i bl
p:↑<type de données> <type de données> *p ; p1= (char*) malloc(10); /* création de p1 */
p1="bonjour"; /* initialisation de la chaine */
P ← nil (*initialisation*) p = NULL ; /*initialisation */ puts(p1);
(* p ne pointe rien *) /* p ne pointe rien */
Ex2.
Allouer (p) p=[(<type-pointeur> *)]malloc
((<taille en octets>)) ; int i,
i *p2;
p2; //* p2 : référence à un entier *//
p=[(<type-pointeur> *)]calloc p2=(int*) calloc(4, 2); /* création de p2 */
(<nb-vars>,<taille par var>); for (i=1;i<=4;i++,p2++)
/* pour variable dont la taille est variable Ex. { *p2=i*i; /* affectation de valeur à l’entier référencé par p2 */
tableau */
printf("p2 pointe sur %d \n",*p2);
197 }
M. ADDOU M. ADDOU 198

STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

Ex3. - Réservation d’espace
typedef struct { Création du pointeur et de l’objet pointé ⇒ 3 étapes :
int code;
• Le système cherche une zone en mémoire pour une variable de
char nom[20], pren[20];
char adr[40]; type « Etudiant »
int age; • Une fois trouvée, il retourne son adresse dans la case mémoire p
float notes[10];
• La variable (de type « Etudiant ») pointée par p sera notée *p
float moy;
int class;
Ex.
} Etudiant;
scanf (‘‘%d %d %s’’, &(*[Link]), &(*[Link]), *[Link]);
Etudiant *p;
/* ou scanf (‘‘%d %d %s’’, &p->code, &p->age, p->nom); */
…
p->code = 10;
p=(Etudiant *) malloc (sizeof(Etudiant)) ;
…
… 199
M. ADDOU M. ADDOU 200

50
 STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

- Libération d’espace Ex.

Libérer l’espace
p alloué ppour une variable ppointée ppar p :
Algorithmique C
free (p) Variable float *p ;
p:↑réel
… ...
Algorithmique C Allouer (p) p=(float *)malloc(4) ; /* allocation */
p↑ ← 1.5 *p = 1.5;
Variable <type de données> *p ;
... ...
p:↑<type
p yp de données>
Libérer (p) free (p) ; Libérer (p) free (p) ; /* Libération */

201 202
M. ADDOU M. ADDOU

STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

(c) Listes particulières Ex. Insertion de E1, puis E2, puis E3 dans une pile.
- La pile
• Technique de gestion : LIFO (Last In First Out) Sommet E3 E2 E1
⇒ Traitement au sommet de la pile
• Caractéristique : Sommet de la pile (1 pointeur) - La file
• Technique
T h i de
d gestion
ti : FIFO (First
(Fi t In
I First
Fi t Out)
O t)
⇒ Insertion à la fin et suppression
au début de la file
• Caractéristiques : Début de la file (1 pointeur)
203 Fin de la file (1 pointeur) 204
M. ADDOU M. ADDOU

51
 STRUCTURES DE DONNÉES DYNAMIQUES STRUCTURES DE DONNÉES DYNAMIQUES

Ex. Insertion de E1,, puis

p E2,, puis
p E3 dans une file.
E Insertion
Ex. I ti dans
d une pile.
il

Fin Données : liste des étudiants à insérer dans la pile.

Début E1 E2 E3

205 206
M. ADDOU M. ADDOU

52