Programmation L C

Universite Paris Ouest Nanterre La dfense
Licence MIA
Programmation en langage C
Notes de Cours
Emmanuel Hyon
27 novembre 2009
Rsum
Ce document archive lensemble des notes du cours de langage C donn en premire anne de la
licence MMIA.
Table des matires

I Semestre 1
1
Gnralits
1.1 Apprentissage de linformatique et buts poursuivis par ce cours
1.1.1 But du cours et prrequis . . . . . . . . . . . . . . . .
1.2 LOrdinateur . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3 Programme . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.4 Le Langage de Programmation . . . . . . . . . . . . . . . . .
1.4.1 Gnralits . . . . . . . . . . . . . . . . . . . . . . .
1.4.2 Smantique et syntaxe dun langage . . . . . . . . . .
1.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6
6
6
7
8
10
10
12
13
Structure gnrale dun programme C

2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1.1 Identificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1.2 Mots rservs du langage . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Structure dun programme . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.1 Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.2 Organisation gnrale . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.3 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 Les expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.1 Oprateurs arithmtiques . . . . . . . . . . . . . . . . . . . . . . . .
2.3.2 Oprateurs de comparaisons . . . . . . . . . . . . . . . . . . . . . .
2.3.3 Oprateurs affectation compose et dincrmentation dcrmentation
2.3.4 Oprateur dadresse . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.5 Sens de lvaluation dune expression . . . . . . . . . . . . . . . . .
2.3.6 Transtypage ou conversion de type . . . . . . . . . . . . . . . . . . .
2.4 Exercices Thoriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
14
14
14
14
15
15
16
16
19
20
20
21
22
22
23
24
Les instructions structures ou Structures de contrles

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . .
3.2 Les conditionnelles . . . . . . . . . . . . . . . . . .
3.2.1 Smantique : Traduction en suite dactions .
3.2.2 Syntaxe . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
25
25
25
26
26
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3.3
3.4
3.2.3 Les boucles : Introduction

3.2.4 la boucle for . . . . . . .
3.2.5 La boucle while . . . . . .
Quelques erreurs classiques . . . .
Exercices Thoriques . . . . . . .
3.4.1 Boucles . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
30
30
33
35
37
37
Les tableaux
Premire partie
4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Manipulation du tableau en C . . . . . . . . . . . . . . . . . . . .
4.2.1 Dclaration dun tableau . . . . . . . . . . . . . . . . . .
4.2.2 Initialisation dun tableau . . . . . . . . . . . . . . . . .
4.2.3 Accs une entre du tableau . . . . . . . . . . . . . . .
4.3 Manipulations de tableau : Quelques Exemples . . . . . . . . . .
4.3.1 Affectation, copie et affichage de tableaux de taille donne
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
39
39
40
40
40
41
42
42
Quelques principes de bases de lalgorithmique

5.1 Introduction . . . . . . . . . . . . . . . . . . . . .
5.2 Accumulateur . . . . . . . . . . . . . . . . . . . .
5.2.1 Un exemple daccumulateur simple . . . .
5.2.2 Le maximum des lments dun tableau . .
5.3 Suites rcurrentes . . . . . . . . . . . . . . . . . .
5.3.1 Exemple introductif . . . . . . . . . . . .
5.3.2 Modlisation et exemple de calcul . . . . .
5.3.3 Suite rcurrente dordre suprieur 1 . . .
5.4 Equivalence entre accumulateur et suite rcurrente .
5.4.1 Gnralisation . . . . . . . . . . . . . . .
5.5 Invariant de boucle . . . . . . . . . . . . . . . . .
5.5.1 Raisonnement par rcurrence . . . . . . . .
5.5.2 Invariant de boucle et accumulateur . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
44
44
44
45
46
47
47
48
49
50
51
51
52
52
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
II Semestre 2
54
55
55
55
56
56
60
60
62
Les fonctions
6.1 Introduction . . . . . . . . . . . .
6.1.1 But dune fonction . . . .
6.2 Fonctions non paramtres . . . .
6.2.1 Dfinition dune fonction .
6.2.2 Le cas spcifique du main
6.3 Fonctions paramtres . . . . . .
6.4 Visibilit des variables . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
62
63
65
65
66
Les Pointeurs
7.1 Introduction . . . . . . . . . . . . . . . . . . . . .
7.2 Adresse Mmoire . . . . . . . . . . . . . . . . . .
7.2.1 Oprateur adresse . . . . . . . . . . . . . .
7.2.2 (Non) Manipulations des adresses mmoire
7.3 Les pointeurs . . . . . . . . . . . . . . . . . . . .
7.3.1 Manipulation de pointeurs . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
69
69
69
70
70
70
70
Structure de donnes 2
8.1 Les tableaux deux dimensions . . . . . .
8.2 Les structures . . . . . . . . . . . . . . . .
8.2.1 Manipulation de structures . . . . .
8.2.2 Structure plus complexes . . . . . .
8.2.3 Structures comportant des tableaux
8.2.4 Structure comportant des structures
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
74
74
76
77
80
80
80
.
.
.
.
.
.
.
.
.
81
81
81
82
82
82
82
83
83
84
6.5
6.4.1 Variables globales . . . . . . . . .

6.4.2 Variables locales . . . . . . . . . .
Passage des paramtres . . . . . . . . . . .
6.5.1 Passage par valeur . . . . . . . . .
6.5.2 Passage des paramtres par adresse
Maniement des fichiers

9.1 Introduction . . . . . . .
9.2 Diffrents types de fichier
9.2.1 Fichiers textes .
9.2.2 Fichiers binaires
9.3 Oprations . . . . . . . .
9.3.1 Ouverture . . . .
9.3.2 Fermeture . . . .
9.3.3 Lecture criture
9.3.4 Exemple . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Premire partie
Semestre 1
Chapitre 1
Gnralits
1.1
Apprentissage de linformatique et buts poursuivis par ce

cours
1.1.1 But du cours et prrequis

Buts du cours
Les buts de ce cours sont multiples.
Apprendre les principes gnraux de programmation.
Apprendre les rudiments de lalgorithmique. Cest dire la manire dont on organise et
conoit un programme.
Apprendre la syntaxe dun langage de programmation.
Besoin de Rigueur
Lapprentissage de linformatique ne ncessite pas dtre extrmement dou mais ncessite par
contre de la rigueur. Cest pourquoi il faut : crire avec soin ces programmes : deux instructions
priori similaires (ou qui vous semblent identiques) ne donnent parfois pas les mmes rsultats.
Oublier certains signes peut rendre un programme non fonctionnable.
Besoin de travail sur machine
Une ncessit de travailler sur la machine pour comprendre les phnomnes qui entrent en
jeu. Cela permet de confronter la thorie la pratique. De plus, la programmation ne sapprend
concrtement quavec de la pratique
Environnement Lenvironnement de travail, cest dire linfrastructure qui vous est offerte,
consiste en un compilateur et en environnement de dveloppement.
Le compilateur : Compilateur GNU.
Lenvironnement de dveloppement DEV C++.
6
MMIA, Langage C
Ces deux logiciels sont largement rpandus et si vous souhaitez les installer chez vous, ceux-ci
peuvent tre trouvs ladresse
http ://www.01net.com/telecharger/windows/Programmation/langage/
Justification du choix du Langage C
Largement rpandu Le langage C est un langage qui a t et reste largement utilis par nombre
de programmeurs mme si actuellement il tend tre supplant. Ainsi Windows ( partir de windows 95) a t crit en C (les versions de maintenant en C++). En tout cas il savre comme
ncessaire de le connaitre pour bon nombre dinformaticiens.
Langage de haut niveau Ce langage est aussi un langage volu qui permet de rdiger les programmes sous une forme lisible humainement.
Possibilit dvolutions Une fois le langage C connu et les principes dalgorithmique compris,
cela donne les moyens, chacun de pouvoir apprendre (avec un certain travail nanmoins) dautres
langages tels que
Le C++
Le JAVA
Un bmol Le langage C est ardu apprendre et nest pas forcment le plus pdagogique car :
Cest un langage syntaxiquement complexe.
Cest un langage dont le compilateur est trs souple. Il peut donc laisser beaucoup derreurs.
Aussi le cadre de travail nest pas aussi norm quavec des langages tels que PASCAL.
1.2
LOrdinateur
Dfinition 1.2.1 (Ordinateur : Dfinition "juridique"). Le terme ordinateur dsigne un appareil

lectronique qui accepte les donnes sous un format numrique et les traite en vue dun rsultat.
Ainsi, un ordinateur traite (ou manipule) de linformation. Celle-ci peut tre sous forme de
Multimdia (musique, film, image)
Donnes (Description dun client dune entreprise)
Textes
des pages Web.
Chiffres (Comptes dune entreprise, rsultats dexpriences, rsultat de calculs par exemple
des calculs numriques sur des structures mcaniques).
Exemple 1.2.2 (Un fichier de musique). Si on prend lexemple dun fichier MP3. Ce fichier se
prsente sous une forme numrique : une suite de 0 et de 1 qui saffichent sous la forme suivante
dans un diteur de texte1
1
car les bits sont transforms suivant le code ASCII.
Semestre 1 : Chapitre 1
r= h<X<^E^OTS6~NDa
Le traitement de linformation consiste donc faire jouer cette suite de 0 ou de 1 sous forme de
sons. Ceci par lintermdiaire du priphrique carte son.
Exemple 1.2.3 (Un texte). Un exemple similaire. On prend lexemple dun fichier de .doc. Ouvert
sous le bloc note cela donne
;!"#$%&E n t r y Microsoft Word-Dokument
MSWordDoc
Word.Document.8
Le but ici consiste alors manipuler cette suite de 0 et 1 et de le considrer comme un texte par
lintermdiaire dun Traitement de Texte afin de le modifier, de le mettre en forme.
Structuration de linformation
La suite des oprations possibles pour un ordinateur est limite. Il sagit des 4 oprations de
bases (addition, soustraction, multiplication, division de nombre) le plus gnralement sur des
nombres entiers, ainsi que la manipulations de ces nombres vis--vis de la mmoire.
Aussi la vue des exemples prcdents on peut se demander comment se passa la transformation dun flux compos de 0 et 1 en de la musique ou en un fichier texte. Comment indiquer
lordinateur ce quil doit traiter comment lui notifier le type dinformation ? Comment la structurer ?
Cette structuration est obtenue grce au Codage de linformation :
Codage des Nombres
Codage des caractres
Dfinition 1.2.4 (Codage des nombres). Le codage est la transformation (inversible) dune suite
de 0 et de 1 en un type ou une structure plus complexe donne.
1.3
Programme
Ici arrive la question

Quest ce quun programme ?
lie avec cette autre question
Quest ce quun logiciel ?
Dfinition 1.3.1. Un logiciel est un programme ou un ensemble de programmes qui visent offrir
un utilisateur (ou lordinateur) une fonctionnalit ou un service donn.
Par exemple :
Traitement de texte
MMIA, Langage C
Un utilitaire de configuration
Dfinition 1.3.2 (Programme). Cest la description dune suite doprations lmentaires en vue
de la ralisation au cours de son excution dune action donne.
Ces oprations peuvent tre
- une suite doprations lmentaires diffrentes
- ou la rptition un grand nombre de fois dun ensemble doprations. On parle dans ce cas l
dalgorithme.
Ces oprations manipulent des donnes structures des : structures de donnes.
On voit donc apparatre les notions dexcution, dinstructions et de donnes.
Exemple 1.3.3 (Recherche dun fichier par son nom dans un disque dur). On veut dcrire la suite
doprations qui permet lexplorateur Windows de trouver un fichier de nom donn dans un
disque dur. Ces oprations sont
1. Saisie du nom
2. Parcours de larborescence (rcursivement)
3. ...
Exemple 1.3.4 (Affichage dune liste de participants un we). On veut dcrire la suite doprations qui permettent dafficher ces donnes qui sont stockes dans un tableur.
Chargement du fichier
Selection du WE choisi
Parcours du fichier et slection des participants
Entres dun programme et manipulation de la mmoire vive
A la lumire des exemples prcdents on observe que les donnes lentre du programme
jouent un grand rle.
Tout dabord, retenons que la manipulation de donnes a lieu uniquement dans la mmoire
vive. Dans le langage courant charger un fichier consiste le transfrer du disque dur vers la
mmoire vive.
Au cours de leurs excutions les programmes manipulent
des donns simples,
des structures de donnes,
des adresses mmoires sur ces donnes.
Dfinition 1.3.5 (Structure de donnes). Une structure de donnes peut tre vue comme une manire dorganiser des donnes simples (nombre, caractres,...) dans un ensemble plus complexe en
vue de faciliter le maniement de cet ensemble par le programme.
Les fichiers Sont une manire de stocker les donnes sur un priphrique mmoire. Il existe
plusieurs type de fichiers. Citons, entre autre, .doc, .htm, .xls, .dat, .txt chaque extension qualifiant
la manire dont le fichier est structur .... Ces fichiers sont des fichiers de donnes.
Le .exe se distingue ce nest pas un fichier de donnes mais un binaire ou programme executable qui dcrit ce que doit faire la machine (le processeur) interprter les ordres, manipuler les
donnes,
Dfinition 1.3.6 (Fichier excutable). Programme directement comprhensible par le processeur,
contenant une suite des "commandes" qui entranent des actions ou des oprations de la part du
systme.
En tant quadjectif, caractrise un fichier que lon peut excuter.
Exemple 1.3.7 (Maniement dun fichier texte par lintermdiaire de WORD). En quoi consiste un
traitement de texte. Le traitement de texte word consiste simplement en fait en un excutable appel
word.exe. Il manipule des donnes structures qui sont des textes. Ces donnes sont sauvegardes
sous formes de fichiers (les .doc). Ouvrir un fichier .doc consiste alors :
Excuter le programme word.exe.
Lui donner des donnes en entre : Le fichier .doc.
Exercice 1.3.8 (Suite doprations pour faire cuire un bifteck). On voudrait ici retranscrire sous la
forme dune suite dinstructions le fait tout simple en apparence de cuisiner de la viande la pole.
Quelles peuvent tre les donnes dentre du programme ? Quelles sont les diffrentes oprations
mettre en oeuvre ?
1.4
Le Langage de Programmation
Nous abordons maintenant la manire dont un humain peut crire un programme2 . Le fait
dcrire des programmes sappelle la Programmation.
Le principe est simple : il sagit de dire lordinateur ce que vous voulez quil fasse. Pour ce
faire il faut dcrire lordinateur, lui dire dans un langage quil comprend, la suite dinstructions
et les donnes quil va manipuler. Dans ce but, on utilise un langage de programmation.
1.4.1 Gnralits
Dfinition 1.4.1 (Langage de programmation). Un langage de programmation est un ensemble
de symboles et de rgles destin dcrire lensemble des actions quun ordinateur doit excuter.
Cest une manire de donner des instructions un ordinateur qui est, le plus souvent, lisible par un
humain mais pas directement par lordinateur.
Le fait dutiliser un langage de programmation se justifie par la difficult dexprimer la suite
dinstructions dans le langage de lordinateur.
2
sans se tirer une balle dans la tte.
MMIA, Langage C
Dfinition 1.4.2 (Langage Machine). Cest le "langage" de base comprhensible par un ordinateur
(utilis par le processeur), soit une suite de zros et de uns.
Attention, le langage machine nest pas comprhensible facilement par lhumain moyen. Aussi,
il est plus pratique de trouver un langage intermdiaire, comprhensible par lhomme, qui sera
ensuite transform en langage machine pour tre exploitable par le processeur.
Langage de haut niveau de bas niveau Plus le langage est comprhensible par lhomme, en
dautres termes plus il est volu, plus on dira quil est de haut niveau. Ainsi si la programme est
crit dans un langage proche de lordinateur on dira quil est crit dans un langage de bas niveau.
Remarque 1.4.3 (Portabilit). Un programme crit dans un langage machine dpend troitement
du type de processeur utilis car chaque type de processeur peut avoir son propre langage machine.
Pour pouvoir lutiliser sur une autre machine il faudrait alors le rcrire entirement.
Ainsi, un langage informatique a donc plusieurs avantages :
il est plus facilement comprhensible que le langage machine
il permet une plus grande portabilit, cest--dire une plus grande facilit dadaptation sur
des machines de types diffrents
La compilation
On sintresse maintenant la transformation du programme crit sous la forme dune suite
dinstructions comprhensibles par lhomme en une suite dinstructions comprhensibles par la
machine.
Dfinition 1.4.4 (Code source). Cest lensemble des instructions dun programme crites dans un
langage de programmation informatique de haut niveau.
La traduction du code source peut se faire de deux manire soit par linterprtation, soit par
la compilation.
Linterprtation Un programme crit dans un langage interprt a besoin dun programme auxiliaire appel interprteur qui analyse, traduit et excute les instructions du programme. Le cycle
dun interprteur est le suivant :
lire et analyser une instruction ;
si linstruction est syntaxiquement correcte, lexcuter ;
passer linstruction suivante.
Ainsi, contrairement au compilateur, linterprteur se charge aussi de lexcution du programme,
au fur et mesure de son interprtation. Du fait de cette phase dinterprtation, lexcution dun
programme interprt est gnralement plus lente que le mme programme compil. Mais un programme interprt est beaucoup plus portable.
La compilation Le code source dun programme crit dans un langage dit "compil" va tre
traduit une fois pour toutes par un programme annexe (le compilateur) afin de gnrer un fichier
excutable.
Remarque 1.4.5. La compilateur dpend du langage. Un compilateur C ne va pas pouvoir compiler
un programme crit en PASCAL. En effet, le compilateur sappuie sur la syntaxe du langage pour
lequel il a t crit.
Le langage C est un langage compil.
1.4.2 Smantique et syntaxe dun langage

On veut ici distinguer la faon dcrire un programme dans un langage et le but poursuivit
qui va dterminer la suite des actions faire faire. Autrement dit, on veut distinguer le sens des
oprations de la manire dont on lcrit.
La syntaxe est la branche de la linguistique qui tudie la faon dont les mots se combinent pour
former des propositions, tandis que la smantique sattache le plus souvent la signification des
proposition.
Ces deux concepts sappliquent aussi en informatique
Dfinition 1.4.6 (Syntaxe). La syntaxe est la dfinition de lensemble de rgles qui rgissent
lagencement des groupes de mots (entits lexicales).
Cette dfinition des rgles est appele grammaire formelle dun langage.
Un petit rappel, chacun dentre nous a fait au cours de ces tudes une tude de grammaire
de langues diffrentes, le franais, langlais, lespagnol, lallemand.... Au cours de ces cours que
faisiez vous ?
Lors de la compilation, le compilateur va vrifier si le respect de ces rgles est effectif ou non.
Dfinition 1.4.7. La smantique est ltude de la signification (le but poursuivi) des programmes.
Ainsi la syntaxe est spcifique un langage de programmation et consiste lorganisation
dune instruction tandis que la smantique nest pas spcifique un langage (mais plus un type
de programmation) et consiste dans lorganisation des instructions du programme.
Il existe plusieurs manires de structurer la faon dont on organise la suite des instructions
et leur traitement pour raliser une mme finalit. Ainsi on a diffrente manire de programmer
appeles :
Programmation fonctionnelle,
Programmation dclarative,
Programmation imprative,
Programmation objet
Celle que nous allons utiliser est la programmation imprative
Dfinition 1.4.8 (Programmation imprative). Les instructions qui modifient les donnes sont excutes simplement les unes aprs les autres.
MMIA, Langage C
Ltat du programme est dfini par le contenu de la mmoire centrale un instant et ne peut
tre modifi que par une instruction,
La plupart des langages impratifs offrent de plus des moyens de structurer les suites dinstructions.
Dfinition 1.4.9 (Programmation structure). Un langage de programmation structur offre des
structures de contrle standardises qui permettent dorganiser la suite des instructions (rptitions,
branchements conditionnels)
1.5
Exercices
Chapitre 2
Structure gnrale dun programme C
2.1
Introduction
On sintresse ici la structure syntaxique dun programme. En dautres termes la faon dont
on doit organiser nos groupes de mots (dinstructions) dans un programme en C.
2.1.1 Identificateurs
Lors de nos programmes il va falloir identifier certaines parties spcifique, ou certaines entits
bien particulires. Pour cela on va devoir les nommer (cest encore une des manires les plus
facile), ce laide didentificateurs.
Dfinition 2.1.1 (Identificateur). Un identificateur est un nom compos dune suite de caractres
alphanumriques, cest dire les chiffres, les lettres, auxquels sajoutent le caractre soulign : _ .
Un chiffre ne peut tre la premire lettre dun identificateur. Un identificateur peut tre tronqu 32 caractres. Les majuscules et les minuscules sont diffrencies (on dit que cest Case
sensitive).
Un identificateur sert dsigner :
Une variable,
Une fonction,
Un type.
2.1.2 Mots rservs du langage

Attention certains mots sont utiliss par le langage C. Ils ont un rle et une fonction bien dfinis
et ne peuvent tre utiliss nimporte comment. Ces mots sont appels parfois mots-Clefs ou mots
rservs Il sagit entre autre des mots :
Les types
char, float, int, void,
Des instructions
do, while, else, if,
14
MMIA, Langage C
divers
static, return.
Caractres rservs Caractres qui ont un rle particulier en C et qui ne peuvent tre utilis seul
comme identificateur.
=, +, *, &
2.2
Structure dun programme
Comme nous lavons vu un programme est la description dun suite dinstructions. Celles-ci
doivent tre agences dans un certain ordre pour tre comprise par le compilateur.
2.2.1 Instructions
Une instructions est un ordre de traitement que lon donne lordinateur. La syntaxe des composants lmentaires doit donc correspondre une syntaxe comprhensible et traitable par lordinateur. La liste des ordres et leur sens sera vu au fur et mesure du cours.
Une instruction est dlimite la fin par un point virgule. Une instructions scrit donc
instruction ;
Le point virgule indique lordinateur quil doit effectuer compltement les oprations dcrites dans linstruction avant de pouvoir passer linstruction suivante. Cela sappelle la Programmation squentielle.
Remarque 2.2.1. Attention certaines instructions attendent un signal (ou un geste) de la part de
lutilisateur avant de pouvoir sachever. Tant que lutilisateur naura pas donn ce signal linstruction complte nest pas termine. Cest par exemple le cas des instructions de lecture au clavier
scanf ou getchar.
Bloc dinstructions Il est aussi parfois important de grouper un ensemble dinstructions. Ceci
se fait en dfinissant un bloc dinstructions qui regroupe les instructions grce des accolades. On
aura donc
{
instruction1 ;
instruction2 ;
instruction3 ;
}
Ce groupe dinstructions est vu par lordinateur comme une seule instruction mme si lensemble des instructions qui le composent sont excutes. Ou encore, on pourrait considrer le bloc
dinstructions comme une seule et mme instruction qui doit excuter plusieurs instructions.
2.2.2 Organisation gnrale

Un programme crit en C scrit toujours de la mme manire. La structure gnrale dun
programme C est la suivante,
[Directives du prprocesseur]
// Cest lajout de potentialits supplmentaires
[fonctions secondaires]
main(){
[Dclaration des variables]
[instructions]
}
Reprsentons ceci sur un exemple simple.
Exemple 2.2.2 (Affichage lcran). Le programme qui affiche mon nom lcran est :
#include <stdio.h>
void main(){
printf("Mon nom est : Jean-Jacques");
}
Commentaires du programme prcdent Ici il ny a pas de dclarations de variables.
La seule chose qui est faite est laffichage lcran de la phrase :
Mon nom est : Jean-Jacques.
Le terme #include <stdio.h> indique lordinateur quil faut quil aille chercher un
certains nombre de fonctions prdfinies qui sont dcrites dans le fichier stdio.h. Ainsi la description de printf est contenue dans stdio.h.
Le terme main est le programme principal en terminologie PASCAL, la fonction principale
en C. Cest l que lordinateur va, tout dabord, chercher les instructions quil doit effectuer. Une
suite dinstructions sans un main quelque part ne marchera pas.
La seule instruction ici est printf("Mon nom est : Emmanuel Hyon") ; On utilise la fonction printf qui affiche ce quon lui donne entre parenthses. Ici la donne est la
phrase Mon nom est : Jean-Jacques, qui est matrialise comme une phrase pour lordinateur par
les guillemets.
2.2.3 Les variables

On rappelle que les donnes que nous manipulons lors dun programme sont des espaces de la
mmoire vive (RAM). Ces donnes peuvent tre constantes (et sont appeles constantes) ou varier
au cours de lexcution du programme, auquel cas on les appelle des variables.
MMIA, Langage C
Les types
Une variable est une donne en mmoire caractrise par deux choses :
Son adresse,
Sa valeur.
Cest pourquoi, il faut dfinir cette donne par une taille et par une "classe de valeur" quil faut
prciser au programme. Cette dernire dfinit ce que cette variable reprsente comme type dinformation et qualifie le type de valeur de la variable.
Cette qualification sappelle le typage et la classe de valeur le type.
Nous verrons au dbut trois types mme sil en existe beaucoup plus.
Le type char
Le type int
Le type float.
Le type char Ce type dsigne un ensemble de caractres. Un char contient, au moins, les
caractres alphanumriques ainsi que quelques caractres supplmentaires. La faon dont loctet
ou les 2 octets sont relis aux caractres sappelle le codage. Il y a diffrent type de codage des
caractres : le code ASCII, le code ISO-Latin (ASCII 8 bits), le code UTF.
Le type int Le type int reprsente les objets appartenant aux entiers relatif (Z). Ils sont
cods sur 32 bits et le premier bit reprsente le signe. 1 . La valeur dun entier peut varier entre
[231 , 231 1], cest dire :
[2 147 483 648, 2 147 483 647]
(2.2.1)
Le type float On croit souvent reprsenter les rels avec le type float, Cela nest pas vrai,
En effet linfini nest pas reprsentable avec un ordinateur. En fait le type float float code un
ensemble fini de nombre dcimaux (fini mais de grande taille). Cest dire, un sous-ensemble
des rationnels. Ils sont appels nombre virgule flottante. A virgule puisquon parle de nombre
dcimaux. Trs grossirement, Flottante parce que on peut coder le nombre 16 se code dune
manire similaire 1.6101 avec un exposant et une mantisse.
Dclaration de variables
Comme on veut manipuler des variables il va falloir expliquer au programme quil doit crer
une zone mmoire associe cette variable. De plus, il vaut que et le programmeur et le programme
puissent savoir quoi correspond cette zone mmoire dans le programme. A cette fin on utilise un
identificateur de la variable. Enfin il faut spcifier son type.
Dfinition 2.2.3 (Dclaration de variable). La dclaration fournit les informations pour lutilisation
dune variable. Cest la rservation de lespace mmoire ncessaire la manipulation de cette
variable dans un programme.
1
Sur les compilateurs GNU
En C la dclaration se fait de la manire suivante : type identificateur ;
Exemple 2.2.4 (Exemple de dclaration).
char a; /* Declaration dune variable a de type caractre */
int b; /* Declaration dune variable b de type entier */
float c; /* Declaration dune variable c de type flottant */
Affectation
Mais ce nest pas tout de possder des zones de mmoire encore faut-il les remplir. En effet,
une variable uniquement dclare na pas de valeur. En dautres termes on a rserv un espace
mmoire par la dclaration mais on ne la pas rempli.
Remplir ou donner (voire redonner) une valeur une variable sappelle laffectation. La premire affectation dune variable sappelle linitialisation.
Remarque 2.2.5. Attention Une variable non-initialise est considre comme nayant aucune
valeur. Sa manipulation est parfois possible mais les donnes retournes vont tre fausses.
Rgle de programmation 2.2.6. Gardons alors la rgle de base suivant en tte :
Toute variable dclare doit tre initialise avant utilisation.
Remarque 2.2.7. Attention Une variable non initialise peut tre, selon les compilateurs et les
architectures, affiche comme valant 0. Cela peut tre trompeur et ne pas reflter la ralit.
Les constantes
Une constante est une valeur qui apparat littralement dans le code source. Le type est dtermin par lordinateur en fonction de la manire dont elle est crite. Ainsi const A = 1 ; dfinit
une constante entire et const A=1.0 dfinit une constante de type float.
Un exemple
Exemple 2.2.8 (Affichage lcran). Le programme qui affiche la premire lettre de mon nom
lcran est :
#include <stdio.h>
void main(){
char c;
int a,b;
a=8;
b=6;
c=E;
MMIA, Langage C
printf("La premiere lettre de mon prenom est : ");

printf("%c",c);
printf("Son nombre de lettre est : ");
printf("%d",a);
printf("La premiere lettre de Pierre est :")

c=p;
printf("%c",c);
a=b;
printf("Son nombre de lettre est : ");
printf("%d",a);
}
Commentaires du programme prcdent
Les valeurs de a, b et c.
Le formattage avec %.
a prend la valeur de b.
2.3
Les expressions
Une expression en informatique cest la gnralisation de la formule mathmatique.

Dfinition 2.3.1 (Expression). Suite doprateurs et doprandes (variables et constantes) dcrivant un calcul effectuer. Ce calcul pouvant porter sur nimporte quel type de donnes (nombres,
caractres...).
Une expression peut tre vue comme une opration qui renvoie une valeur ET un type. Mais
une expression nest pas une instruction ds lors quil manque laffectation 2 , cependant lexpression fait partie de linstruction.
Lexpression la plus simple est de la forme :
variable oprateur variable ou oprateur variable.
Ou sous une forme plus gnrale
expression1 op expression2.
Donnons tout dabord une liste (non exhaustive) des oprateurs.
2
Qui fait elle mme partie de lexpression en C
2.3.1 Oprateurs arithmtiques

les oprateurs arithmtiques sont :
- (oprateur unaire)
+
*
/
% reste de la division entire.
Ces oprateurs agissent comme classiquement en mathmatique. Sur les entiers et les nombres
virgule flottante.
Remarque 2.3.2. Attention au type des variables sur laquelle sapplique la division /.
float x;
x = 3/2;
ici x vaut 1.
float x;
x = 3.0/2.0;
ici x vaut 1.5.
2.3.2 Oprateurs de comparaisons

Ces oprateurs sont aussi parfois appels oprateurs conditionnels. Ils sont
(< )> strictement (infrieur) suprieur,
(<=) >= (infrieur ou gal)
== != gal ou diffrent.
Ces oprateurs renvoient une valeur de vrit dont le rsultat dpend de la vrification ou non
de la condition. Le type et la valeur renvoys sont diffrents des autres langages de programmation
et on ne sappesantira pas dessus. Ainsi,
Valeur de vrit Condition est vrifie
Valeur de vrit Condition non vrifie
Remarque 2.3.3.
1. Ne pas confondre laffectation = la comparaison ==.
2. La comparaison == nest pas efficace sur les flottants. Car il peut y avoir des problmes
dimprcision numrique.
Exemple 2.3.4. Donnons un exemple.
int a,b;
a=2;
b=3;
(a==b)
MMIA, Langage C
Correspond une valeur de vrit : la condition nest pas vrifie.
int a,b;
a=2;
b=3;
(a!=b)
Correspond une valeur de vrit : la condition est vrifie.
int a,b;
a=2;
b=3;
(a <= b)
Correspond une valeur de vrit de ? ? ?
Oprateurs logiques boolens
Ces oprateurs permettent de composer des expressions comportant des conditions. (relies
un oprateur de comparaison).
&& le et,
|| le ou,
! la ngation,
Syntaxe : expression1 op expression2.
Exemple 2.3.5. Teste si le nombre est infrieur 9 et suprieur 0 :
(a<=9) && (a >= 0)
ou teste que le nombre a est compris entre 0 et 9 :
! ((a>9) || (a < 0))
Ou encore teste si a est nul.
(a<=0) && (a >= 0)
2.3.3 Oprateurs affectation compose et dincrmentation dcrmentation

Vu en TD.
2.3.4 Oprateur dadresse

Dclaration variable a rserve une zone mmoire a. Cette zone mmoire fait partie de lensemble des zone mmoires de la mmoire vive rserve la programmation.
Schema 2.3.6 (Zone Mmoire). To do.
Sur le schma la zone mmoire de a est la ieme case du tableau.
Loprateur & renvoie ladresse de loprande. Ainsi &a renvoie ladresse de a (sous une forme
cabalistique).
Exemple 2.3.7 (Scanf). Pour la saisie au clavier on a
char c;
scanf("%c",&c);
2.3.5 Sens de lvaluation dune expression

On voudrait savoir dans quel ordre et comment lordinateur value (cest dire associe une
valeur lexpression algbrique) une expression. Pour cela il faut savoir que les oprateurs nont
pas tous la mme priorit.
Rgle de priorit des oprateurs
Les priorits sont lues de haut en bas
Oprateur
( )
&adresse
(type)
!
/
%
*
+
< <= > >=
==
!=
&&
||
Remarque 2.3.8.
1. On remarque que lordre peut tre forc par le parenthsage. Les parenthses ne donnent quun ordre partiel dvaluation entre les oprateurs.
2. Remarquons encore que lordre dvaluation des arguments nest pas prcis pour la plupart
des oprateurs en C. Cest dire quon peut dabord valuer loprande de gauche ou loprande de droite indiffremment.
3. Les seuls oprateurs qui sont toujours valus squentiellement de la gauche vers la droite
sont && et ||.
MMIA, Langage C
Exemple 2.3.9 (Evaluation dune expression).
(x + y) z + b / 5 x
| {z } |{z} |{z} |{z} |{z}
|{z} |{z}
|
{z
} |{z}
|{z} |{z}
{z
}
|
{z
} |{z}
|
Exemple 2.3.10. Quelle va tre lexpression de la valeur suivante ?

int a,b,c;
float d;
a=2;
b=3;
c=10;
d=1.24;
((a+b)*z+d)/5-a
2.3.6 Transtypage ou conversion de type

A une expression correspond un type. Ce type correspond au type qui prend le plus de place
en mmoire (type le plus prcis). On parle de promotion. Cest pourquoi il faut parfois modifier le
type dune expression. Il y a deux manires de conversion de type.
Conversion implicite
Cest, grosso modo, des conversions faites par lordinateur.
float c;
int a,b;
a=3;
b=5;
c=a+b;
c est de type float. a+b de type int. Il y a un conversion de type implicite qui transforme le
type du rsultat de a+b en flottant.
Conversion implicite non dsire Il se peut cependant en C que lordinateur fasse des conversions implicites malvenues. Ces transtypages (conversions) sont maintenant affichs par des avertissements sur certains compilateurs rcents.
float c;
int a,b;
a=1;
c=1.5;
b=a+c;
Ici b vaudra 2 et non 2.5 car le transtypage induit une perte de prcision
Exemple 2.3.11. Analogie des petites et des grosses boites
Conversion explicite
Quelque fois cest lutilisateur qui dcide de faire cette conversion. Mais il le fait en toute
connaissance de cause.
float tranches;
int duree,nombre;
nombre=(int) duree * tranche;
oprateur de transtypage
2.4
Cest loprateur ( type ) avec type le type de sortie dsir.
Exercices Thoriques
Exercice 2.4.1 (Questionnaire). crire un programme qui demande lutilisateur son ge, sa taille
(exprime en m) et son poids (exprim en kg) puis qui affiche lcran les informations saisies.
Exercice 2.4.2 (Droulement dun programme). Drouler le programme suivant et donner les
valeurs finales de toutes les variables dclares.
#include <stdio.h>
main()
{
int a,b,c,d;
a=2;
b=a+3;
c=b/a;
d=c+b%a;
a=(a+b+c+d)/2;
printf("a=%d,b=%d,c=%d,d=%d\n",a,b,c,d);
getchar();
}
Exercice 2.4.3 (convertisseur 3). crire un programme qui convertit un horaire exprim en secondes en heures minutes secondes.
Chapitre 3
Les instructions structures ou Structures
de contrles
3.1
Introduction
Commenons par
"pour choisir, il faut penser ce quon pourra faire et se remmorer les consquences de ce quon
a dj fait."
Bergson
eh ben linformatique pareil.
Exemple 3.1.1 (Rappel exemple 1.3.3). Dans la recherche dun fichier de nom x dans lordinateur
on tait amen
Rpter un certain nombre de fois la mme recherche dun nouveau fichier.
Tester si ctait celui l le bon.
Ainsi, lcriture dun programme procde de plusieurs possibilits dordonner un ensemble
dactions.
Suite dactions squentielles.
Choix entre plusieurs possibilits qui vont dterminer la suite du programme.
Rptitions de la mme action un certain nombre de fois.
On dit que ces agencements sont des structures car ils dcident lordre des instructions. Ces
structures sont ncessaires car elles permettent de contrler le comportement du programme en
fonction de son droulement.
3.2
Les conditionnelles
On introduit les structures relatives au choix.

25
Dfinition 3.2.1 (But dune structure conditionnelle). Le but dune telle structure est de pouvoir
faire un aiguillage entre diffrentes possibilits de droulement de programme.
Ces possibilits daiguillage traduisent des choix effectuer similairement ceux que lon fait
dans la vie courante.
Exemple 3.2.2 (Sans alternatives). Heure fin des cours : Si lheure de fin des cours est passe je
rentre chez moi.
Exemple 3.2.3 (Avec Alternative). Jai 16 ans jai le droit en toute modration de prendre de la
bire dans un bar, sinon (si je suis plus jeune) je nai pas le droit.
3.2.1 Smantique : Traduction en suite dactions

Traduisons cette suite dactions sous la forme dun schma.
Schema 3.2.4 (Continuation 3.2.2). Reprsentation algorithmique de lexemple 3.2.2.
Schema 3.2.5 (Continuation 3.2.3). Reprsentation algorithmique de lexemple 3.2.3.
3.2.2 Syntaxe
Le mot-cl if permet deffectuer une instruction (simple ou compose) de manire conditionnelle. Il peut tre suivi du mot-cl else pour spcifier linstruction effectuer lorsque la condition
est fausse (lalternative).
if (condition)
/* si la condition est vraie */
instruction
ou
if (condition) {
instruction 1
...
instruction n
}
ou encore si il existe une suite dinstructions lorsque la condition est fausse.
if (condition) {
instruction 1
...
instruction n
} else {
MMIA, Langage C
/* si la condition est fausse */
instruction 1
...
instruction n
}
Le code des deux exemples
Exemple 3.2.2.
# include<stdio.h>
main(){
int heure;
printf(Saisissez l heure);
scanf(%d,&heure);
if (heure >= 18) printf(Je rentre a la maison);
}
Exemple 3.2.3.
#include<stdio.h>
main(){
int age;
printf(Saisissez votre age);
scanf(%d,&age);
if (age >= 16){
printf(Cest bon tu es autorise);
printf(Un demi ?);
}
else {
printf(Tu es trop petit);
printf(Un cacolac ?);
}
}
Le droulement du programme prcdent est
quand age=10
quand age=20.
Remarque 3.2.6 (Attention au bloc dinstructions). Le positionnement des accolades permet de
dfinir correctement les instructions effectuer aprs aiguillage. Que donne le code suivant ?
# include<stdio.h>
main(){
int heure;
printf(Saisissez l heure);
scanf(%d,&heure);
if (heure >= 18)
printf(il est 6 heure passee");
printf(Je rentre a la maison);
}
Comment le corriger pour ne pas passer pour un mauvais lve ?
Remarque 3.2.7 (Convention dcriture). Voici quelques conventions dcriture qui permettent de
rendre son code plus lisible :
Ouverture aprs la condition ou aprs le else.
Code effectuer indent (dcal).
Fermeture de laccolade au mme niveau que le if et le else.
Exemple 3.2.8 (Valeur absolue). Donner le code correspondant au calcul de la valeur absolue de
a-b.
Etape 1 : En franais
Etape 2 : Schma Algorithmique
Etape 3 : Programme
#include <stdio.h>
main(){
int a,b;
int valeur_absolue;
scanf("%d",& a);
scanf("%d",& b);
if (a-b < 0){
valeur_absolue=b-a;
}
else {
valeur_absolue=a-b;
}
printf("La valeur absolue est %d,valeur_absolue);
}
MMIA, Langage C
Conditionnelles imbriques
Il est possible dinclure une structure conditionnelle lintrieur dune autre structure conditionnelle.
Expression du problme en franais . On reprend l exemple 3.2.3, mais on voudrait que lge
soit valide. Cest dire que ce soit un entier positif et infrieur 130. Ensuite si lge est valide
alors je regarde si on est en ge dtre dans un bar.
Expression de lalgorithme
Etape 1 -> Si lage est compris entre 0 et 130
->alors
->->si lge est suprieur 16
-> ->alors droit de rentrer dans le bar
-> ->sinon pas le droit
->sinon afficher que lge nest pas valide
Le Code
#include<stdio.h>
main(){
int age;
printf(Saisissez votre age);
scanf(%d,&age);
if (age > 0) && (age <=130){
if (age >= 16){
printf(Cest bon tu es autorise);
printf(Un perrier ?);
}
else {
printf(Tu es trop petit);
printf(Un cacolac ?);
}
else {
//alternative du premier if
printf("Age non valide");
}
// fin des conditionnelles
printf(Fin);
}
3.2.3 Les boucles : Introduction

Dfinition 3.2.9. On appelle boucle le fait de rpter un nombre de fois (dtermin ou non) la
mme action ou la mme srie dactions.
Reprenons des exemples de la vie courante
Exemple 3.2.10 (Effacer 5 fichiers dans lordinateur). Cela consiste rpter 5 fois lopration
deffacement.
Exemple 3.2.11 (Effacer tous les fichiers dun dossier). Ceci consiste effacer des fichiers tant
quil en reste dans le rpertoire.
On se rend compte quil y a deux types de boucle
for : pour
while : tant que
3.2.4 la boucle for

Introduction
Utilisation prconise La boucle for est utilise de prfrence
lorsque lon a un nombre prdtermin doprations faire.
lorsque ce nombre ne dpend pas de variables dont la valeur est modifie dans la boucle.
Syntaxe
int i; // indice courant.
int deb;
inf fin;
for(i=deb;i<fin;i++){
instruction 1
...
instruction n
}
Smantique ou expression de lalgorithme
On reprsente la boucle par le schma suivant.
Entre-> Test valeur indice $i<Fin$ ? -> non sortie de boucle

^
|
|
oui |
|
|
-----Traitement des instructions
On remarque que la boucle apparat directement sur ce schma.
MMIA, Langage C
Deux exemples
Exemple 3.2.12 (Saisie de 10 nombres au clavier et affichage.).
En franais :
La suite des oprations : Je pars dun indice gal 0 (cest une convention) et je le fait varier
jusqu 9 inclus ou 10 exclu. Pour chaque valeur dindice je demande de lire et dafficher.
En algo cela donne le schma suivant Pour i variant de debut = 0 f in = 9 rpter : demander
une valeur, lire la valeur, afficher la valeur.
En code
#include <stdio.h>
main(){
int entier;
int deb;
inf fin;
deb=0;
fin=9;
for(i=deb;i<=fin;i++){
printf(Saisir nombre);
scanf("%d",&entier);
printf("Vous avez saisi le nombre %d",entier);
}
}
Excution du programme Commenter le droulement Au dbut affectations : deb = 0 et f in = 9.

Ensuite,
Autres exemples : des expressions qui dpendent de la valeur dindice de la boucle
Exemple 3.2.13 (Affichage de 5 entiers partir de 100).
En franais :
pour lentier valant 100, jaffiche lentier,
En algo : pour i de 100 104 rpter : afficher lentier

En code
#include <stdio.h>
main(){
int entier;
inf fin;
deb=0;
fin=5;
for(i=0;i<fin;i++){
entier=100+i;
printf("Le nombre %d",entier);
}
}
Droulement Commentaire du droulement de lexcution.
Deux boucles imbriques
On veut afficher la table de multiplication de 2, 3 et 4 chacune entre 1 jusqu 5.
En franais Faire varier la table
Pour 2 afficher la table des 2 de 1 5....
Affichage de la table de x de 1 5
Pour 1 afficher x 1
Pour 2 afficher x 2
Pour 3 afficher x 2
Pour 4 afficher x 2
Pour 5 afficher x 2
En Algo
Code
#include <stdio.h>
MMIA, Langage C
main(){
int i; // indice courant boucle 1
int j; // indice courant boucle 2
int fin1;
int fin2;
int deb1;
int table;
deb1=2;
fin1=5;
fin2=5;
for(i=deb1;i<fin1;i++){
// Affichage de la table de i
for(j=1;j<6;j++){
printf("%d multiplie par %d vaut %d",i,j,i*j);
}
}
}
3.2.5 La boucle while

Utilisation prconise La boucle while est utilise de prfrence
lorsque le nombre doprations faire dpend directement de la satisfaction dune condition
lintrieur de la boucle.
lorsque cette condition est modifie au moins une fois dans la boucle.
Rgle de programmation 3.2.14. Il est extrmement important de modifier dans la boucle les
valeurs qui sont impliques dans la condition qui dtermine la sortie de la boucle. Autrement
lordinateur ne "sarrte" pas.
Syntaxe
/* On note expr(a) une expresson booleenne qui depend de a */
int a; /* type indiffrent */
a=10;
while (expr(a) ){
instruction 1
...
instruction modifiant la valeur de a
de sorte que la satisfaction ou non de expr(a) est modifiee
...
instruction n
}
Smantique ou expression de lalgorithme
-> entree ---> Verification de la
--- Non -> sortie de boucle
^
satisfaction de
|
|
lexpression
|
|
|
|
| oui
---------------------------traitement des
instructions
Quelques exemples
Exemple 3.2.15 (Saisie de caractres aux claviers). On veut saisir des caractres au clavier et les
afficher mais ds que le caractre saisi est n alors la saisie sarrte.
En franais
La condition de satisfaction est : le caractre est diffrent de n. En effet, tant que le caractre est
diffrent alors la boucle continue.
Les instructions dans la boucle sont :
Demande de saisie du caractre et affichage.
Le caractre lu doit tre le caractre impliqu dans la condition de satisfaction.
En pseudo Langage
Donner une valeur au caractre que lon saisira plus tard dans la boucle de telle sorte que lexpression boolenne puisse tre value.
Tant que lexpression nest pas vrifie faire :
1. Lire le caractre.
2. Afficher le caractre.
3. Affectation de la valeur du caractre lu la valeur du caractre qui est impliqu dans lexpression boolenne (Peut tre fait en 1).
Le programme
#include <stdio.h>
main(){
char a;
MMIA, Langage C
a=o;
while (a <> n){
printf("saisissez un caractre au clavier");
scanf("%c",&a);
printf("Vous avez saisi la caractre %c",a);
}
printf("Vous avez arrete la boucle");
printf("c est la fin");
}
Droulement de lexcution du programme. On sintresse au droulement dans deux cas,
Quand ligne2 a=n.
Quand ligne 2 a=o.
Exemple 3.2.16 (Reprendre lexemple avec un ge valide). On veut maintenant reprendre lexercice de discrimination des clients du bar. On cherche ce que le test de lge ne puisse se produire
que quand lge est valide. Cela implique que tant que lge nest pas valide lutilisateur ressaisi
son ge.
En pseudo langage
En code
3.3
Quelques erreurs classiques
On prsente ici un certain nombre derreurs classiques qui se produisent lors des premiers
maniement de boucle. Ceci sera fait en illustrant la rdaction dun programme simple.
dont le but est de trouver la valeur dun indice n tel que son inverse soit plus petite que un
nombre donn que lon nomme prcision.
Ci-dessous une suite de programmes faux. Par soucis de concision on se restreint au main.
bf Premier programme
main(){
int n;
float precision, inverse;
n=0;
precision=0.00023;
while(inverse > precision) {
printf("Pour %d cela nest pas bon",n);
printf("Encore un effort");
}
printf("valeur correcte : %d",n);
}
Quelles sont donc les erreurs ?
n na pas t initialis correctement ;
1/n division de deux entiers donc cela devrait toujours donner 0.
Second Programme
main(){
int n;
n=1;
precision=0.00023;
inverse= ( (float) 1)/n;
}
}
Quelles sont les erreurs ?
n ne varie pas et lexpression boolenne qui dpend de n ne varie pas non plus ;
La programme ne va jamais sortir de la boucle 1 .
Troisime Programme
main(){
int n;
n=1;
precision=0.00023;
n=n+1;
}
}
1
On a bien le temps daller prendre un caf
MMIA, Langage C
Il reste une dernire erreur (subtile). En effet le test est fait avec une valeur dcale par rapport
lindice.
Cas 4 Exemple correct
main(){
int n;
n=1;
precision=0.00023;
n=n+1;
}
}
3.4
Exercices Thoriques
Structures Conditionnelles
Exercice 3.4.1 (Pair ou impair ?). crire un programme qui demande lutilisateur un entier
positif et qui affiche lcran sil est pair ou impair.
Exercice 3.4.2 (Equation du second degr). crire un programme qui rsoud une quation du
second degr dont les coefficients sont entrs par lutilisateur (on supposera que le coefficient de
x2 nest pas nul).
Exercice 3.4.3 (Maximum de trois entiers saisis au clavier). crire un programme qui demande
trois entiers lutilisateur et qui affiche la plus grande valeur saisie.
3.4.1 Boucles
Boucles simples
Exercice 3.4.4. crire un programme qui affiche lcran les carrs de tous les nombres de 1
n o n est un entier donn par lutilisateur. Modifier le programme pour quil naffiche que 10
nombres au plus par ligne.
Exercice 3.4.5. crire un programme qui affiche tous les multiples de k compris entre a et b o k,
a et b sont trois entiers entrs par lutilisateur.
Boucles et conditionnelles imbriques
Exercice 3.4.6. crire un programme qui demande lutilisateur deux entiers n et p puis qui
affiche lcran tous les cubes des entiers de n n + 10 p en revenant la ligne tous les p
nombres.
Boucles imbriques
Exercice 3.4.7. crire un programme qui affiche un triangle rempli dtoiles, stendant sur un
nombre de lignes entr au clavier, comme dans lexemple suivant :
Nombre de lignes = 5
*
**
***
****
*****
Chapitre 4
Les tableaux
Premire partie
4.1
Introduction
Un bref rappel : On nomme structure de donnes une structure logique destine contenir des
donnes en leur donnant une organisation permettant de simplifier leur traitement.
Pour prendre un exemple de la vie quotidienne, on peut prsenter un annuaire tlphonique
sous diffrentes formes
par nom,
par type dactivit (pages jaunes),
par numro tlphonique (annuaires inverss),
par adresse
Dans ce cas, chaque usage correspondra une structure dannuaire approprie. Ici, les donnes
sont toutes les mmes mais cest la manire daller les chercher qui diffre.
De toutes les structures de donnes possibles nous nous intressons lune des plus simple : le
tableau une seule dimension.
Dfinition 4.1.1. Un tableau est une suite adjacente de variables (lments du tableau) dun type
donn.
Les lments sont accessibles uniquement par un mcanisme dindexage (ou accs index).
On voit apparatre (encore) deux notions
1. celle de donne.
2. celle daccs la donne.
Remarque 4.1.2 (Allgorie dun tableau). Un tableau peut tre vu comme une suite contigu de
cases mmoire, toutes de la mme taille. Cette taille tant dtermine par la taille du type de donne
stocke. On accde ces cases par un mcanisme dindexation qui est le mcanisme qui permet
dassocier sans ambiguit un contenu et une rfrence.
39
Proprits nonons quelques proprit de base dun tableau.
1. Un tableau ne contient que des lments du mme type (entier, caractre, flottant).
2. Un tableau a une taille qui est le nombre de cases quil contient.
3. Les cases du tableau ont toute un indice. Cet indice dcrit la place de la case parmi lensemble
des cases.
4. Les numros des indices sont en ordre croissant. La premire case du tableau est indice par
0 (en C) et la dernire case par taille 1.
Schma dun tableau de taille 5
4.2
Manipulation du tableau en C
On prsente ici les manipulations dun tableau , on choisit au dbut les concepts les plus simples
qui concernent la manipulation de tableau.
4.2.1 Dclaration dun tableau

La dclaration dun tableau est de la forme :
type nom[nombre dentier] ;
En ralit, pour tre plus propre (ce qui veut dire pour viter des causes supplmentaires derreur), on peut dfinir la taille du tableau comme une constante dans le main :
const taille = valeur.
Ensuite on ne traite plus que la constante taille et non un nombre donn lors des manipulations de tableaux de la mme taille. Cela permet de ne changer la taille qu un seul endroit du
programme.
Les deux dclarations suivantes sont quivalentes :
int tableau[4] ;
et
const taille=4 ;
int tableau[taille] ;
4.2.2 Initialisation dun tableau

Linitialisation dun tableau consiste affecter une valeur pour chaque case.
Remarque 4.2.1. Attention un tableau non initialis va (selon les compilateurs) afficher des valeurs qui vous sembleront aberrantes ou parfois des zros. Considrer, pour tre le plus gnrique
possible, que un tableau non initialis ne contient rien.
MMIA, Langage C
Il existe deux manires dinitialiser un tableau la dclaration ou lors du programme.
Initialisation la dclaration Cette manire convient pour des tableaux de petite taille. On met
les valeurs que lon doit affecter aux cases du tableau entre accolades. Ce qui donne :
int tab[5] = {4, 6, 8, 12, 20} ;
Initialisation au cours du programme Cette voie est privilgie pour des tableaux de grandes
tailles. Il faut accder chaque case et lui affecter une valeur.
4.2.3 Accs une entre du tableau

Laccs la ime case du tableau appel "tab" (en considrant quelle existe) se fait par linstruction tab[i].
Ainsi pour donner une valeur la i + 1me case, linstruction utiliser est :
tab[i]=3 ;
De la mme manire, pour : utiliser la valeur de la i+1me case du tableau, soit pour laffichage
soit pour laffectation dune autre variable, les instructions sont respectivement
printf("%d",tab[1]) ; (avec tab tableau dentiers)
et
a=tab[i] ; (a et tab de mme type).
Ainsi a=tab[i] ; signifie que la variable a prend comme valeur le contenu de la i + 1me case
du tableau
Ainsi printf("%d",tab[1]) ; signifie que lon affiche la premire case du tableau.
Linitialisation du tableau de tout lheure devient alors .
int tab[5];
tab[0]=4;
tab[1]=6;
tab[2]=8;
tab[3]=12;
tab[4]=20;
Prcautions dusage 1 : Indice et case traite
Prcautions dusage 2 : Copie de tableau Soit A et B deux tableaux dentiers de mme taille.
Laffectation de la valeur dun tableau A un autre tableau B nest pas possible. Autrement dit,
lensemble des valeurs dun tableau ne peut tre pass un autre tableau en une seule instruction.
Il faut affecter les valeurs du tableau, valeur par valeur. Dun point de vue langage C la suite
dinstructions :
const taille=2;
int A[taille] ={4, 6};
int B[taille];
B= A;
nest pas valide.
Celle qui est correcte est
const taille=2;
int A[taille] ={4, 6};
int B[taille];
B[0]=A[0];
B[1]=A[1];
Prcautions dusage 3 : Plage des indices Une valeur dindice qui nappartiendrait pas lintervalle [0, taille 1] renvoie une erreur et le programme sarrte. En effet une telle valeur na
pas de signification pour lordinateur. Elle nest corrle aucune adresse mmoire ce qui fait que
une instruction comportant une rfrence au tableau avec une telle valeur dindice ne peut pas tre
traite correctement.
4.3
Manipulations de tableau : Quelques Exemples
4.3.1 Affectation, copie et affichage de tableaux de taille donne

#include<stdio.h>
main(){
const taille=10;
int i;
int A[taille];
int B[taille];
/* initialisation de A */
for(i=0;i<taille;i++){
printf("Entrer la valeur de la %d eme case du tableau,%d);
scanf("%d",&A[i]);
}
/* Recopie de A en B */
B[i]=A[i];
}
MMIA, Langage C
/* Affichage de A */
printf("Le tableau A est");
printf("A[%d]= %d",i,A[i]);
}
}
Exercice Thoriques
Exercice 4.3.1. Dcrire le rsultat produit par le programme suivant :
#include <stdio.h>
main()
{
int i, b = 0;
int c[lO] = {1, 2, 3, 4, 5 , 6, 7, 8 , 9, 10};
for (i = 0; i < 10; i++)
{
if ((c[i] % 2) == 0)
{
b = b+ c[i];
}
}
printf("dans boucle %d %d",i,b);
}
Exercice 4.3.2. On suppose un tableau dentier de taille 5. On veut changer le contenue de la
case dindice i et le contenu de la case j (les indices sont demands lutilisateur).
Exercice 4.3.3. On suppose un tableau dentier de taille 5. On veut supprimer la case dindice j
et le remplacer par le contenu de la case dindice j + 1.
Chapitre 5
Quelques principes de bases de
lalgorithmique
5.1
Introduction
On ne va pas rentrer dans une dfinition formelle de lalgorithme en informatique mais uniquement donner un certains nombre de concepts qui visent mieux faire comprendre ce quest un
algorithme.
Un algorithme est une suite d oprations effectuer en vue de raliser (ou excuter) une
opration donne qui peut snoncer en langage clair.
Les algorithmes ne sont pas restreints linformatique. Ils existent dans la vie quotidienne, ainsi
une recette de cuisine peut tre considre comme un algorithme. Une suite dindications dcrivant
le chemin pour aller chez quelquun aussi. Mais ils restent, quand mme, principalement utiliss en
mathmatique et en informatique. Ils sont notamment essentiels dans la recherche dune solution
avec un ordinateur, parce que pour obtenir une solution on doit dcrire une srie dinstructions
claires.
Lautre aspect qui conduit leur utilisation en informatique tient au fait que le plus souvent un
algorithme se trouvent tre une rptition donne dun jeu dinstructions. Dans ce cas on parle des
tapes dun algorithme. Enfin, un algorithme termine cest dire trouve la solution en un nombre
fini (pas forcment petit) doprations (ou dtapes).
Un algorithme est indpendant du langage de programmation. Cest sa mise en oeuvre (ou
implmentation) au moyen dun langage de programmation qui va le rendre dpendant. Lalgorithme mis en oeuvre constitue alors une brique de base dun programme informatique.
Ces algorithmes utilisent de manires plus ou moins cachs un certain nombre de concepts dont
certains ont t codifis
5.2
Accumulateur
Introduction Question : Comment calculez-vous une somme de 4 nombres ? Par exemple comment calcule-t-on de tte la somme de 2 + 4 + 5 + 7 ? La plupart du temps on fait 2 + 4 = 6, puis
44
MMIA, Langage C
6 + 5 = 11 et enfin 11 + 7 = 18. Cela marche parce que laddition est associative. Que sont donc
le 6, le 11 et le 18. Ces nombres sont le stockage du rsultat temporaire de votre addition.
Ces nombres sont appels accumulateurs.
Proprits Enumrons quelques proprits la vue de cet exemple.
1. La valeur finale de laccumulateur est le rsultat que lon cherche.
2. La valeur prise par laccumulateur a chaque tape est le rsultat du calcul une tape qui
sajoute ce quon a dj calcul.
3. Linitialisation peut apparatre sous deux formes soit on fixe comme valeur initiale llment
neutre de lopration, soit on prend la premire valeur qui appairait lors des calculs.
4. La valeur de llment ajout peut dpendre directement de ltape laquelle on se trouve
ou de la valeur dun nombre qui dpend de ltape.
5. Lopration utilise est associative.
Dans quels cas utilise-t-on a un accumulateur ? Cette question est un peu difficile et viens avec
la pratique. Pour quun accumulateur doive tre utilis il suffit souvent quun certain nombre des
conditions ci-dessus soient vrifies. En fait cela met en ouvre le concept dinvariant de boucle que
lon verra plus tard dans le chapitre1 .
Attention lopration dajout nest pas forcment laddition cela peut tre le maximum ou la
multiplication. Toute la difficult est de deviner quel est lopration utilise.
5.2.1 Un exemple daccumulateur simple

On veut calculer la somme des n premiers nombres entiers. En mathmatiques cela veut dire
calculer 1 + 2 + .... + n.
Ceci est quivalent (((1 + 2) + 3) + . . . + n).
Cest aussi quivalent la premire tape laddition de 0 + 1 puis, la seconde tape au
rsultat temporaire on ajoute 2, la troisime tape on ajoute au rsultat temporaire 3. Ainsi la
ime tape on ajoute i laccumulateur.
Description de lalgorithme
Initialisation de laccumulateur 0 (lment neutre de laddition).
Faire de 1 jusqu n : accumulateur+i (o i est le compteur dtapes)
Le rsultat est-il bien celui attendu ?
Le code est donc
#include<stdio.h>
main(){
int accumulateur;
1
Si vous tes en train de rviser cela se dit plus tard dans la soire
int i;
int n;
n=21;
accumulateur=0;
for(i=1;i<22;i++){
accumulateur=accumulateur+i;
}
printf("valeur finale %d",accumulateur);
}
5.2.2 Le maximum des lments dun tableau

But : On veut calculer le maximum dun tableau tab de taille taille dont les valeurs ont dj
t rentres.
Il faut tout dabord remarquer que le max est associatif :
max (max(a, b), c) = max(a, b, c).
Donc il nous suffit en fait pour connatre le maximum ltape i, de connatre le maximum
ltape i 1 et de le comparer au terme contenu dans la ime case.
Il y a deux cas possibles
Soit le maximum de ltape i1 est plus grand que le ime terme auquel cas le max ltape
i est le maximum des i 1 premiers termes.
Soit le ime terme est plus grand que le maximum de ltape i1 auquel cas le max ltape
i est le ime terme.
Description de lalgorithme accumulateur est le premier terme du tableau
de i de 2 taille faire
si tableau[i] > max alors max<-tableau[i] sinon ne rien faire
Code
#include<stdio.h>
main(){
const taille = X;
int accumulateur;
int i;
int tab[taille];
// initialisation du tableau
MMIA, Langage C
accumulateur=tab[0];
for(i=0;i<taille-1;i++){
if (tab[i+1]>accumulateur) {
acumulateur=tab[i];
}
}
printf("valeur finale le max est %d",accumulateur);
}
5.3
Suites rcurrentes
5.3.1 Exemple introductif

On sintresse des suites de valeurs dfinies dune manire rcurrente. Cela signifie que le
nme terme dpend du terme prcdent. Sous la forme la plus simple on a :
U (n) = f (U (n 1)).
Ces suites ont beaucoup dapplications dans la vie courante et selon lexpression de la fonction
il nest pas forcment facile de les calculer par une formule mathmatique.
Un exemple On veut calculer la 3me valeur de la suite gomtrique :
U (n) = q U (n 1)
avec U (0) diffrent de 0.
Comment effectuer le calcul ? On a
U (0) = a, U (1) = qU (0) = aq, U (2) = qU (1) = aq 2 et U (3) = qU (2) = aq 3 .
La question est comment peut-on crire cette suite de calculs pour connatre la valeur pour
nimporte quel valeur de n ? Si n vaut 1000 il ne sera pas possible de dclarer 1000 variables ! !
Comment alors, gnraliser ce calcul afin deffectuer toujours la mme suite doprations chaque
tape en utilisant une seule valeur ?
On utilise une valeur temporaire qui chaque tape stocke la valeur de U (n). Linclusion dans
une boucle se fait alors "facilement". Cest un accumulateur en un peu plus compliqu et on verra
plus tard le lien.
Si on utilise une variable temporaire. Cette variable temporaire vaut la fin de la boucle la
valeur du terme de la suite quon calcule. Le calcul prcdent se fait de la manire suivante :
temporaire= U (0) = a,
temporaire=U (1) = f (U (0)) cest dire temporaire= f (temporaire).
A lordre 2 on a
temporaire= U (2) = f (U (1)), cest dire temporaire= f (temporaire). Et donc on obtient le
calcul pour nimporte quelle valeur de n :
temporaire = U (n) = f (U (n 1)) = f (temporaire).
Illustration Illustrons ce mode de calcul sur lexemple prcdent et observons le comportement
de temporaire.
...
5.3.2 Modlisation et exemple de calcul

Une suite rcurrente dordre 1 est une suite dfinie par
U (n) = f (U (n 1)).
Lorsquon cherche connatre la nme valeur dune suite rcurrente dordre 1 on fonctionne de la
manire suivante.
On utilise une valeur temporaire qui va prendre pour valeur chaque itration la valeur de la
suite.
Cette valeur temporaire est initialise avec la constante initiale de la suite (U (0)).
Cette valeur est utilise chaque tape pour calculer la nouvelle valeur de la suite.
A chaque tape, la valeur de la variable temporaire lentre de la ime itration est U (i1)
et la sortie U (i).
Pour connatre le nme terme de la suite on fait n fois la boucle.
Exemple 5.3.1 (Conjecture de Syracuse). La suite de Syracuse est dfinie de la manire suivante :
(
un
si un est pair
un+1 = 2
3un + 1 sinon.
On a une suite rcurrente dont le calcul dpend de litration (selon quelle est paire ou non).
Mais cela reste le mme modle.
Exprimons donc lalgorithme en fonction de la mthode vue plus haut.
Initialisation de la variable tempo avec une valeur quelconque rentre par lutilisateur
Boucle pour i variant de 1 n faire
Calcul de U (i) la fin tempo devra valoir U (i)
Au dbut de cette boucle tempo vaut U (i 1)
Si U (i 1) est pair alors U (i) = U (i 1)/2, on a donc tempo = tempo/2
Si U (i 1) est impair alors U (i) = 3U (i 1) + 2, on a donc tempo = 3tempo + 1
Ce qui donne en code
#include <stdio.h>
main(){
int tempo;
int val_init;
int nb_iter=20;
int i;
MMIA, Langage C
scanf("%d",&val_init);
// Initialisation methode
tempo=val_init;
for(i=0;i<nb_iter;i++){
if (tempo%2==0) {
tempo=tempo/2;
}
else{
tempo=3*tempo+1;
}
}
printf("Le resultat final est %d",tempo);
}
5.3.3 Suite rcurrente dordre suprieur 1

Ces suites se dfinissent de la manire suivante
U (n) = f (U (n 1), U (n 2), . . . , U (nk )).
avec k fini.
Cela fonctionne strictement de la mme manire il suffit juste maintenant de stocker les k
1 termes prcdents et de les mettre jour chaque tape. Ainsi, il faut crer k 1 variables
temporaires pour stocker les termes et la fin de chaque calcul de U (i), leur donner la bonne
valeur.
Exemple 5.3.2 (Suite de Fibonacci). Une suite de Fibonacci est dfinie de la manire suivante
U (n) = U (n 1) + U (n 2), avec U (0) = x et U (1) = y.
On doit donc crer deux variables temporaires tempo qui stockera la valeur courante et tempo_2
qui stockera lavant dernier terme. A litration i :
On calcule U (i) avec U (i 1) et U (i 2). On aurait donc tempo qui vaut U (i 1) et tempo_2
qui vaut U (i 1).
Soit res=tempo + tempo_2. Alors res est gal U (i). Maintenant il faut que tempo prenne la
valeur U (i) et tempo_2 prenne U (i 1). Comme cela la prochaine itration on aura tempo qui
vaut U (i 1) et tempo_2 qui vaut U (i 1). Pour cela on fait : tempo_2 = tempo et tempo = res.
Attention lordre est important.
Une petite question Pourquoi si la ime itration tempo prend la valeur U (i) alors litration
i + 1 il vaudra U (i 1) ?
Le code associ
#include <stdio.h>
main(){
int tempo, tempo_2;
int i;
int nb_iter;
int res;
nb_iter=15;
scanf(%d",&tempo);
scanf(%d",&tempo_2);
for(i=3;i<(n+1);i++={
res=tempo+tempo_2;
tempo_2=tempo;
tempo=res;
}
}
5.4
Equivalence entre accumulateur et suite rcurrente
Le principe de laccumulateur vu au dbut de ce chapitre est en fait souvent trs similaire aux
principes des suite rcurrentes. Nous allons montrer, ici, que lexemple du maximum des termes
dun tableau peut se modliser sous la forme dune suite rcurrente (parfois appele suite itrative).
Rappel On veut calculer le maximum des lments dun tableau dont la taille est taille.
Description de lalgorithme :
Accumulateur prend comme valeur la valeur du premier terme du tableau.
de i de 2 taille faire
si tableau[i] > max alors max<-tableau[i] sinon ne rien faire.
Code :
#include<stdio.h>
main(){
const taille = X;
int accumulateur;
int i;
MMIA, Langage C
int tab[taille];
// initialisation du tableau
accumulateur=tab[0];
for(i=0;i<taille-1;i++){
if (tab[i+1]>accumulateur) {
acumulateur=tab[i];
}
}
printf("valeur finale le max est %d",accumulateur);
}
Modlisation sous forme dune suite rcurrente On a, ltape i :
max(accumulateur,ime terme du tableau).
On suppose que les valeurs de laccumulateur, chaque tape, sont les valeurs des termes dune
suite rcurrente. On peut dfinir alors une suite V telle que V (i) soit la valeur de laccumulateur
ltape i. On aurait :
Valeur de laccumulateur en 0 = V (0),
Valeur de laccumulateur en 1 = V (1),
...
Valeur de laccumulateur en k = V (k)
...
La formule de calcul de V (i) est alors
V (i) = max(V (i 1), tab[i]).
(5.4.1)
5.4.1 Gnralisation
La transformation de lexemple ci-dessus peut se gnraliser trs facilement ds lors que le calcul de laccumulateur dpend uniquement du terme prcdent et dune suite de calculs. A contrario,
le calcul dune suite rcurrente (ou itrative) est en fait un accumulateur. La valeur du terme de la
suite tant la valeur de laccumulateur.
A titre dexercice, il vous est laiss faire la transformation de lexemple 1 de ce chapitre.
5.5
Invariant de boucle
La question quon se pose maintenant tient sous deux formes :

1. Etant donn un problme P comment vrifier que la suite de calculs effectus est correcte et
donne le bon rsultat.
2. Comment ce problme peut-il se modliser sous la forme dun accumulateur (pris ici au sens
accumulateur et suite itrative) ?
5.5.1 Raisonnement par rcurrence

Tout dabord un petit rappel sur les raisonnements par rcurrence. Un raisonnement par rcurrence pour montrer une proprit A(i) est de la forme
1. Montrer que A(1) est vraie (directement).
2. Montrer, si ncessaire, que les proprits A(2),...,A(k) sont vraies (avec k IN ).
3. En supposant que la proprit est vraie jusqu lordre n, Montrer quon a alors A(n+1).
Exemple 5.5.1 (Somme des n premiers nombres). On veut montrer que la somme des n premiers
entiers naturels est n(n+1)
.
2
Preuve :
1. On a somme du premier entier qui vaut 1 et (1 2)/2 = 1. Donc lassertion est vraie
lordre 1.
2. Supposons que lassertion
vraie jusqu lordre n. Montrons que lassertion est vraie
P soit P
n
lordre n + 1. On a n+1
=
vaut donc en utilisant lhypothse de
n=1
n=1 +(n + 1). Ceci
Pn+1 n(n+1)+2(n+1)
Pn+1 n(n+1)
= (n+1)(n+2)
rcurrence n=1 = 2 + (n + 1), il sensuit n=1 =
2
2
Le rsultat, est prouv.
5.5.2 Invariant de boucle et accumulateur

De la mme manire, pour montrer la correction du calcul dune suite itrative on va dfinir un
mcanisme trs proche du raisonnement par rcurrence : linvariant de boucle. Ce concept a t
utilis tout au long des deux chapitres prcdents sans tre formellement identifi.
Dfinition 5.5.2 (Invariant de boucle). On appelle invariant de boucle une proprit qui reste vraie
chaque passage dans la boucle. Plus prcisment chaque passage dans un point donn de la
boucle qui le plus souvent est la fin ou le dbut.
Cet invariant a pour but dassurer la correction du programme. En assurant que, la fin du
programme, la proprit voulue est satisfaite.
La dmarche est la suivante :
1. Vrifier que la proprit est vraie au dbut de lalgorithme.
2. Vrifier par rcurrence que linvariant de boucle (la proprit) reste vrai aprs chaque boucle
Le plus compliqu restant la plupart du temps la recherche de cette proprit invariante. En effet,
dfinir un invariant qui assure qu la fin du programme la proprit que lon cherche sera bien
vrifie nest pas immdiat.
MMIA, Langage C
Exemple
Appliquons cela au calcul du maximum des termes dun tableau. On veut calculer le maximum des termes dun tableau. Ce quon veut cest trouver la proprit qui assure que, la fin de
lalgorithme, le rsultat renvoy sera bien le plus grand terme du tableau.
Recherche de linvariant de boucle Je dfinis tout dabord le terme U calcul chaque boucle
par : U = max(U, tab[]). On essaye (mais ici cela va marcher) comme invariant de boucle et
comme point de vrification le prdicat : "A la fin de la nme tape de la boucle le terme U est le
maximum des n premiers termes du tableau". Cest cette affirmation que je vais prendre comme
proprit de linvariant de boucle.
Vrifions quelle satisfait les conditions requises pour assurer le bon rsultat.
A ltape 1 on a U = tab[1]. (Equivalent max(tab[1], U ) avec U = ). Le terme U est bien le
maximum du premier terme du tableau.
Supposons que nous soyons ltape n et que U est le maximum des n 1 premiers termes du
tableau. Comme U = max(U, tab[n]) alors la fin de la boucle U est le maximum des n premiers
termes du tableau.
Par rcurrence on saura que la fin du calcul le rsultat trouv sera le maximum des termes du
tableau.
Remarque 5.5.3. Ceci permet de vrifier que le calcul effectu avec un accumulateur est correct.
Cela permet aussi en sachant cela dobtenir une ligne directrice (grosso modo : "trouver quelque
chose qui bouge pas") lorsquon cherche trouver un algorithme en vu de rsoudre un problme.
Application au suites itratives Dans ce cas la proprit vrifier est beaucoup plus naturelle
il sagit de calculer un terme et de vrifier quil est bien au dbut de chaque boucle le terme de la
suite correspondant.
Gnralisation Cette mthode ne se restreint pas au calcul avec accumulateur ou des suite rcurrentes mais bien plus largement lalgorithmique en gnral.
Deuxime partie
Semestre 2
54
Chapitre 6
Les fonctions
6.1
Introduction
En langage C comme dans beaucoup dautres Langages informatique on peut dcouper un

programme en plusieurs parties, ces parties sont appeles fonctions. Une seule fonction en C existe
obligatoirement le main. Cette fonction va pouvoir utiliser (on dit appeler) les autres fonctions (les
autres parties de code) pour raliser son but.
6.1.1 But dune fonction

On peut se demander pourquoi morceler comme cela un programme.
Bien que cela ne semble pas tre apparent. Cela est fait pour diffrentes raisons.
Division du programme en sous parties excutant une action simple (Programme plus structur).
Le code est (avec de lhabitude) plus lisible.
Cela facilite le dboguage.
On vite de changer tout en programme quand on fait des changements : on ne modifie que
la partie incrimine.
Volont de dvelopper certaines parties spcifiquement pour tre utilise au court du programme. On regroupe la suite dinstructions pour former une action globale.
viter de rcrire 15 fois la mme chose pour refaire la mme action.
La sous partie qui excute une action logique unique (laction logique) va tre appele par son
identificateur et manipule soit par une autre fonction soit par le main.
Fonctions dj connues Il y a un certains nombre de fonctions que vous manipulez dj.
printf, scanf, cos
Exemple de fonction Citons quelques dexemples dapplications qui peuvent tre ralises par
une fonction (pas forcment en C).
Fonction de lecture dun morceau MP3 (mme action sur diffrents contenus).
55
MMIA, Langage C
Fonction daffichage dun menu.

Fonction de test de cohrence dune donne entre
Fonction de calcul dun cart type, sur des ensembles de donnes
Fonction de calcul des valeurs dune suite
etc...
En rsum
Dfinition 6.1.1. Une fonction est une partie dun code source qui permet de :
- raliser la mme action logique plusieurs fois
ou
- raliser la mme action logique sur des objets diffrents.
Les instructions dune fonction sont dfinies (en langage C) laide de blocs dinstructions.
6.2
Fonctions non paramtres
On sintresse dans un premier temps des fonctions dites non paramtres 1 .
6.2.1 Dfinition dune fonction

Comment est dfinie une fonction ? Une dfinition de fonction, contient : une interface (ou
en-tte ou encore prototype nous verrons la diffrence plus tard) et un corps de fonction.
Cette dfinition est sous deux formes
len-tte permet de dire comment la fonction va tre utilise. Les paramtres, au cas chant,
dont elle a besoin et de donner une indication sur le type de son rsultat.
Le corps de la fonction, lui, contient la description de la suite dinstructions que lon veut
faire effectuer lordinateur.
Les en-ttes de fonctions non paramtres
Cest la premire ligne de la dfinition de la fonction. Elle se prsente sous la forme :
type nom_fonction() .
Dans cet en-tte, il y a deux lments :
- Le nom de la fonction : son identificateur qui va permettre de lidentifier vis--vis des autres
parties du programme. Lappel de la fonction va utiliser ce nom.
- Le type dsigne le type de la fonction cest dire le type de la valeur quelle retourne (car
une fonction retourne ou renvoie une valeur).
1
Attention en C contrairement dautres langages il nexiste que des fonctions pas de procdures
MMIA, Langage C
Les types de valeurs retournes Le type de la fonction est le type de la valeur quelle retourne
(car une fonction retourne ou renvoie une valeur). Une fonction qui ne renvoie pas de valeur (cela
existe aussi) est une fonction dont le type de retour est spcifi par le mot clef void.
Une fonction comme par exemple cos(x) retourne ou renvoie une valeur (pour celle de la
bibliothque math.h cette valeur est de type double). Cest dire quelle transmet cette valeur
la fin de son droulement au sous-programme appelant. Dans le cas o une valeur est retourne le
sous programme appelant devra grer (et savoir comment grer) cette valeur rcupre.
Le corps dune fonction
Le corps de la fonction est lensemble des instructions que lont veut faire faire lordinateur.
On a parfois besoin dutiliser des variables propres la fonction, en ce cas le corps de la fonction
dbute par la dclaration de ces variables. Il est suivi par une srie dinstructions.
Enfin, le corps dune fonction se termine par linstruction de retour linstruction "return" de
syntaxe "return(expression) ;". Avec
- valeur de expression valant la valeur que retourne la fonction.
- type de expression devant tre identique celui spcifi dans len-tte de la fonction.
Lorsque la fonction ne retourne pas de valeur (type void), le corps de la fonction se termine par
return ;.
Lors de lexcution dune fonction linstruction return provoque le retour au programme appelant. Cela signifie quaucune autre instruction de la fonction sera excute.
Remarque 6.2.1. Il peut y avoir plusieurs instructions return dans la dclaration dune fonction.
Mais cest la premire instructions return rencontre qui provoquera larrt de la fonction et le
retour au programme appelant. Ainsi, si on a
int fonction(){
int i;
i=0;
return i;
i=i+1;
return i+1;
la valeur retourne sera 0 et non 1.
Exemple
On veut une fonction qui retourne un nombre saisi au clavier par lutilisateur. Ce nombre devant
tre compris entre 0 et 10 et on veut afficher lcart entre le nombre saisi et le milieu de lintervalle.
Le code de la fonction doit tre.
int saisie_nombre(){
int ecart, nombre;
printf("Saisissez un nombre entre 1 et 10");
scanf("%d",&nombre);
MMIA, Langage C
while ( (nombre >10) || (nombre <0) ){

ecart=abs(nombre-5); // utilisation de la fonction abs
printf("tu tcartes de %d",ecart);
}
return nombre;
} // fin de la fonction
Dclaration dune fonction
En C, il faut dclarer toute fonction avant de pouvoir lutiliser. La dclaration informe le
compilateur du type des paramtres et du rsultat de la fonction et lui permet de vrifier que le
nombre et le type des paramtres utiliss dans la dfinition ou lors dun appel concordent bien avec
le prototype donn. Grce cela, le compilateur peut contrler si lutilisation dune fonction est
correcte et mme possible. La fonction principale main na pas besoin dtre dclare.
La dclaration dune fonction se fait par lcriture du prototype de la fonction. Ainsi
type nom_fonction ()
Rgle de programmation 6.2.2. Le compilateur doit avoir connaissance de la fonction au moment
o celle-ci est utilise. Comme cette connaissance est faite laide dune dclaration alors la
dclaration doit figurer avant tout autre utilisation de la fonction.
Une dfinition comprend une dclaration. Cest dire quil nest pas ncessaire de dclarer
une fonction dj dfinie.
Lappel dune fonction
Lappel de la fonction correspond la demande dutilisation de la fonction par le programme.
Lappel se fait par le nom de la fonction. Ainsi, linstruction saisie_nombre() ; correspond
un appel de la fonction saisie_nombre et son utilisation. par le composant appelant.
Il est parfaitement possible dappeler une fonction lintrieur dune autre fonction.
Exemple 6.2.3. #include <stdio.h>
//declaration
int saisie_nombre();
// definition
int saisie_nombre(){
int ecart, nombre;
MMIA, Langage C
while ( (nombre >10) || (nombre <0) ){

}
return nombre;
} // fin de la fonction
main() {
int recepteur_resultat_saisie;
// appel de la fonction
recepteur_resultat_saisie=saisie_nombre();
// fin du droulement de la fonction
printf("Le nombre saisi est %d",recepteur_resultat_saisie);
}
Attention, lappel dune fonction est considr comme une seule instruction. Ainsi, dans le
programme appelant, tant que les instructions de la fonction ne sont pas acheves lordinateur ne
passe pas linstruction suivante du programme appelant.
Exemple 6.2.4. Par exemple le programme suivant
#include <stdio.h>
void affiche()
void affiche(){
int a;
a=0;
printf(" Je commence \n");
for(i=0;i<1000000;i++){
a=a+1;
}
printf(" Je finis");
}
main(){
printf("C est la fin des haricots\n");
affiche();
printf("la fonction est finie \n")
}
Donnera lexcution
C est la fin des haricots
MMIA, Langage C
Je commence
Je finis
la fonction est finie
6.2.2 Le cas spcifique du main

Comme nous lavons dj dit, le main est une fonction particulire. Cest cette fonction qui est
appele lorsquon excute un programme. Le main peut renvoyer une variable qui sera un entier.
Cet entier sera transmis au programme appelant et indique le bon droulement du programme ou
non (cela doit tre gr au moment de la conception du code). Enfin le main peut prendre des
arguments qui seront transmis par la ligne de commande au programme quand on lappelle.
6.3
Fonctions paramtres
Les paramtres dune fonction (ou arguments) peuvent tre vus comme un ensemble de donnes que lon doit traiter. La dfinition dune fonction permet de dcrire le traitement et le droulement de la fonction en fonction des valeurs prises par les paramtres. Les valeurs des paramtres
sont donnes lors de lappel.
On peut imaginer le droulement dune fonction comme le travail faire par un manutentionnaire dans un entrept de pices dtaches pour voiture. Les paquets de rtroviseurs sont livrs
par un camion. Cela peut tre des rtroviseurs extrieurs ou des rtroviseurs intrieurs. Son travail
consiste prendre un paquet dans le camion (sans le faire tomber), regarder le type de rtroviseur.
- Si cest un rtroviseur intrieur alors il doit enlever la gaine de protection et le ranger
si cest un rtroviseur extrieur il doit juste lentreposer.
Le travail et la description du travail du manutentionnaire est le corps de la fonction. Le paramtre est le carton (de type carton de rtroviseurs xx). En fonction des diffrents contenus du carton
de rtroviseurs le travail du manutentionnaire ne sera pas le mme mais tous les travaux pour tous
les contenus de cartons doivent tre dfinis. Lappel dune fonction correspond larrive dun
carton, la valeur du carton correspondant la classe de rtroviseur quil contient.
Lors de la dfinition les paramtres utiliss sont donc appels paramtres formels ou paramtres muets. Puisquils formalisent et dfinissent le droulement de la fonction sans pour autant
avoir une valeur relle. Tandis que lors de lappel, les paramtres rellement utiliss qui vont avoir
une valeur sont les paramtres effectifs ou valeurs relles.
Illustrons ceci, lorsquen mathmatiques vous dfinissez
f (x) = x2 + 2x + 1.
x est un paramtre formel et quand vous utilisez f (5) 5 est la paramtre effectif.
Attention Un paramtre effectif peut tre une variable en informatique. Dans ce cas cest la
valeur de la variable qui est utilise comme valeur pour le paramtre rel.
MMIA, Langage C
Prototype dune fonction
Le prototype est de la forme
type nom_fonction (typeparam1, typeparam2, ... )

ou bien
type nom_fonction (typeparam1 nomparam1, typeparam1 nomparam2, ... )
et indique uniquement le type des donnes renvoyes et reues par la fonction.
Exemple 6.3.1. Reprenons lexemple du manutentionnaire de tout lheure. Illustrons son travail
par une fonction.
# include <stdio.h>
# include <stdlib.h>
# include <time.h>
// premiere fonction traitement par le manutentionnaire
void manutentionnaire(char carton){
if (carton==e){
printf("Cest un retro exterieur je vais le ranger");
}
else {
printf("Cest un retro interieur");
printf(" je le nettoie et je vais le ranger");
}
return;
}
// Creation des cartons
char camion(){
int u
srand(0);
// je tire une variable alatoire entre 0 et 1
u= (int) ((1.0*rand())/RAND_MAX);
if (u < 0.5) return e; else return i;
}
main(){
char c;
srand(time(NULL));
c=camion();
printf("c vaut %c\n",c);
manutentionnaire(c);
MMIA, Langage C
manutentionnaire(e);
manutentionnaire(i);
}
Commentaires
6.4
Visibilit des variables
On peut se demander quelle est la porte dune variable : une variable dclare dans une fonction peut-elle tre utilise dans une autre partie du programme ? On peut se demander quelle est sa
dure de vie. Si jappelle plusieurs fois la mme fonction et que la variable change de valeur ou
si la variable est utilise dans une autre fonction.
6.4.1 Variables globales

Dfinition 6.4.1. Une variable globale est une variable dclare en dehors de toute fonction (mme
le main).
Exemple 6.4.2. Dans lexemple suivant la variable note est une variable globale.
#include <stdio.h>
char note;
note=l;
void fonction();
void fonction()
{
note=s;
printf("la note est %c\n",note);
return;
}
main()
{
printf("la note est en dehors %c\n",note);
fonction();
}
porte Une variable globale est reconnue par le compilateur dans toute le code aprs sa dclaration.
MMIA, Langage C
6.4.2 Variables locales

Dfinition 6.4.3. Une variable locale est une variable dclare lintrieur dune fonction. Par
dfaut, les variables locales sont visibles uniquement lintrieur de la fonction2 dans laquelle
elles sont dclares. Elles ne gardent pas, par dfaut, leurs valeurs dun appel lautre.
Exemple 6.4.4. Dans lexemple suivant la variable note est une variable locale.
#include <stdio.h>
void fonction()
{
char note;
note=l;
printf("Week End Rome la note est la note est %c\n",note);
note=s;
return;
}
main()
{
fonction();
fonction();
}
Donne laffichage
Week End Rome la note est la note est l
Week End Rome la note est la note est l
Dure de vie
A la sortie de la fonction, les variables locales sont dtruites et leur valeur perdues.
Exemple de multiple dclaration dune variable du mme nom
Les variables locales nont aucun lien avec des variables globales de mme nom ni mme avec
des variables locales dune autre fonction.
Par exemple,
Exemple 6.4.5. #include <stdio.h>
char note1;
char note2;
2
et des fonctions dfinies lintrieur de cette fonction
MMIA, Langage C
note2=s;
note1=s;
void fonction()
{
char note3;
char note2;
note1=l;
note2=l;
note3=l;
printf("Ds f note 1 est %c\n",note1);
return;
}
main()
{
char note3;
note3=r;
printf("note
printf("note
printf("note
fonction();
printf("note
printf("note
printf("note
}
Donne laffichage
note
note
note
Ds f
Ds f
Ds f
note
note
note
1 est %c\n",note1);
2 est %c\n",note2);
3 est %c\n",note3);
1 est %c\n",note1);
2 est %c\n",note2);
3 est %c\n",note3);
1 est s
2 est s
3 est r
note 1 est l
note 2 est l
note 3 est l
1 est l
2 est s
3 est r
Explication
MMIA, Langage C
6.5
Passage des paramtres
On sintresse au passage des valeurs des paramtres. Cest dire la transmission de la valeur
dun des paramtres la fonction.
6.5.1 Passage par valeur

Un paramtre de fonction est assimil une variable locale. Cest la valeur du paramtre effectif
(ou rel) qui est copie dans cette "variable locale", cette variable locale tant utilise dans le corps
de la fonction. Lorsque le paramtre effectif est une variable, cest son contenu (sa valeur) qui est
copi dans la variable locale et non la variable elle mme. On remarque que la fonction ne travaille
que sur une copie qui va tre supprime la fin de la fonction. Cest pourquoi une modification
de la variable locale dans la fonction ne modifie quune copie et non la variable passe comme
paramtre effectif qui elle reste inchange.
Dfinition 6.5.1 (Passage des paramtres par valeur). On appelle passage par valeur, quand seule
la valeur dun paramtre effectif est connue de la fonction puisque cest la valeur qui est transmise
et copie.
Le C ne permet de faire que des passages par valeur.
Non modification des valeurs
Soit la fonction
void echange (int a, int b)
{
int temporaire;
printf("Au debut a = %d \t et b = %d\n",a,b);
temporaire = a;
a = b;
b = temporaire;
printf("A la fin a = %d \t et b = %d\n",a,b);
return;
}
main()
{
int a = 6, b = 1;
printf("debut programme a = %d \t b = %d\n",a,b);
echange(a,b);
printf("fin programme a = %d \t b = %d\n",a,b);
}
Ceci donnera lexcution
MMIA, Langage C
debut programme a = 6
b = 1
Au debut a = 6
et b = 1
A la fin a = 1
et b = 6
fin programme a = 6
b = 1
Cela vous semble surprenant ? Mais que pensez vous de leffet de echange(6,1) ?
Observons alors le droulement de cette fonction et le comportement (illustratif) de la mmoire
du programme prcdent.
Droulement de la fonction et effet sur la mmoire
6.5.2 Passage des paramtres par adresse

Une autre manire de transmettre les arguments effectifs est de transmettre non plus leur valeur
mais leur adresse (leur adresse mmoire). La fonction ne travaille plus sur une copie de lobjet
transmis, mais sur lobjet lui-mme (puisque elle en connat ladresse). Le paramtre effectif est
alors ladresse de la variable.
Dfinition 6.5.2 (Passage par adresse). On appelle passage par adresse, quand le paramtre effectif
qui est transmis la fonction lors de lappel est ladresse dune variable.
La fonction appele, range alors ladresse transmise dans un paramtre formel appropri (de
type adresse) qui est une variable locale la fonction appele. Cette fonction a maintenant accs,
via ce paramtre, la variable de la fonction appelante Le passage par adresse permet donc une
fonction de modifier les valeurs des variables du programme appelant.
Remarque 6.5.3. Attention cette dfinition du passage par adresse est gnrique mais ne sapplique
pas stricto sensu au Langage C. En effet, il ny as pas de passage par valeur en C (comme en Pascal
par exemple). Pour pouvoir avoir un quivalent au passage par adresse en C on utilise les pointeurs.
On va utiliser une astuce qui consiste passer par valeur un paramtre qui est en fait une adresse.
Plus de prcision dans un prochain cours mais il savre quon passe un pointeur vers une adresse
mais le pointeur en paramtres est pass lui par valeur (vous suivez ?)
void echange2 (int *adr_a, int *adr_b)
{
int t;
t = *adr_a;
*adr_a = *adr_b;
*adr_b = t;
return;
}
main()
{
MMIA, Langage C
int a = 2, b = 5;
printf("debut : a = %d et b = %d\n",a,b);
echange(&a,&b);
printf("fin : a = %d et b = %d\n",a,b);
}
Commentaires
Rgle de programmation 6.5.4 (Quand utiliser le passage par valeur ou le passage par adresse).
Le passage par valeur sutilise quand on a pas besoin de faire de modifications sur des variables,
tandis que un passage par adresse est utilis de prfrence lorsque lon doit effectuer des modifications qui doivent tre rpercutes ensuite dans tout le droulement du programme.
Dautre part, mais cela sera vu ultrieurement, on peut (on doit ? ?) parfois utiliser le passage
par adresse mme si il ny a pas de modifications. Cest le cas notamment du passage de tableaux
en paramtres.
Passage de paramtres pour les tableaux
Attention, les tableaux ne peuvent tre pass QUE par adresse. Plus spcifiquement, on donne
la rfrence (cest dire un pointeur) dune case du tableau (leplus gnralement la premire case).
Ainsi si on a dclar un tableau de nom tab, alors tab, &tab[0] et &tab ont la mme valeur.
Cest dire quils donne la mme adresse qui est la premire case du tableau.
Il y a deux manires equivalentes dans le rsultat pour dclarer un tableau en paramtres.
Premier type de dclaration
#include <stdlib.h>
void lire_tableau(int tableau[], int taille)
{
int i;
for (i = 0; i < taille; i++){
printf("La %d entree est %d,tableau[i]);
}
return;
}
main()
{
const N= 10;
int tab[N];
tableau(tab[],N);
}
MMIA, Langage C
De mme une fonction ne peut pas renvoyer un tableau directement mais une adresse sur une
zone mmoire.
Second type de dclaration
#include <stdlib.h>
void initialise_tableau(int *tableau, int taille)
{
int i;
for (i = 0; i < taille; i++){
printf("Entrer la %d eme coordonnes",i);
scanf("%d",&tableau[i]);
}
return;
}
main()
{
const N= 10;
int tab[N];
initialise_tableau(tab,N);
}
Chapitre 7
Les Pointeurs
7.1
Introduction
On rappelle quune variable que lon manipule dans un programme doit tre stocke dans
la mmoire vive de lordinateur. La dclaration dune variable est le fait de rserver un espace
mmoire pour cette variable. Ainsi, il y aura correspondance entre une variable que lon manipule
dans le programme (que lon dcrit le plus souvent par son nom ou identificateur) et lespace
rserv dans la mmoire que le systme dexploitation manipule.
Il peut tre cependant plus intressant de dcrire une variable non plus par son identificateur
(cest dire telle quelle) mais plutt en se donnant la possibilit de manipuler son espace mmoire
comme on la vu au chapitre prcdent.
7.2
Adresse Mmoire
Trs approximativement, la mmoire de lordinateur peut tre vue comme une suite de cases
mmoires conscutives (un tableau). Ces cases mmoire ont une adresse (qui est lquivalent des
indices du tableau) qui permet de les identifier de manire unique. Ces cases peuvent tre manipules soit individuellement soit par groupe. Ce, selon la taille du type que lon manipule car lespace
rserv pourra tre alors de une ou plusieurs cases mmoires. Cest ladresse de la case mmoire
qui assure la correspondance entre la variable que lon manipule dans le programme et la mmoire.
Le contenu de ces cases mmoires va tre le contenu de la variable et vice versa.
Ainsi une variable va tre dfinie par deux caractristiques
Son adresse (ou ladresse de sa premire case mmoire).
Son contenu qui donne sa valeur.
A quoi correspond alors une affectation ? Une affectation cest la recopie du contenu dune
variable dans le contenu dune autre variable. Il ny a pas de copie dadresses.
69
MMIA, Langage C
7.2.1 Oprateur adresse

Pour connatre la valeur de ladresse dune variable on utilise loprateur (unaire) &. Par
exemple &i renvoie la valeur de ladresse de la variable i. Loprateur & ne permet que de rcuprer ladresse dun objet en mmoire : variable, case de tableau et ne peut sappliquer des
expressions ou des constantes.
Cet oprateur a dj t aperu auparavant, par exemple dans scanf("%d",&a).
7.2.2 (Non) Manipulations des adresses mmoire

Si les adresses mmoires sont des entiers (de format interne un peu particulier dpendant de
larchitecture 8, 16, 32, ou 64 bits on parle alors dadressage x bits), on ne peut cependant pas manipuler les adresse mmoires comme des variables. On ne peut donc tenter daffecter une adresse
ainsi, &a=123569 na aucun sens. En effet, il faut voir ladresse comme une constante associe
la variable.
Par contre on peut utiliser & pour indiquer ladresse dune variable. Cest ce que fait lappel
la fonction scanf("%d",&a) qui va utiliser la valeur indique par la "constante" &a pour placer le
contenu codant lentier lu au clavier dans lespace mmoire indiqu par &a.
7.3
Les pointeurs
Comme on ne peut manipuler des adresses directement par lutilisation de lop rateur (unaire)
&, pour pouvoir manipuler des variables via leur adresse on utilise un autre moyen les pointeurs.
Les pointeurs sont ddis la manipulation des variables par le biais de leur adresse.
Un pointeur est un lment de valeur gale ladresse dun lment du programme. Cet lment
peut tre un type classique int, float, double, char ou encore une case dun tableau ou encore un
pointeur.
Attention, comme nous lavons dj dit, si une adresse est un entier la manipulation dune
adresse nest pas similaire la manipulation dun entier. Cest pourquoi le pointeur dpend du
type de lobjet vers lequel il pointe. Cette diffrence provient du fait que selon le type de donne la
valeur de ladresse renvoye est soit ladresse de loctet o cette donne est stocke soit ladresse
du premier des x octets o cette donne est stocke.
7.3.1 Manipulation de pointeurs

Regardons comment on peut manipuler des pointeurs.
Dclaration
Comme pour toute variable un pointeur doit tre dclar. On dclare un pointeur laide de
linstruction :
type *nom_pointeur ;
MMIA, Langage C
o type est le type de lobjet point.

Ceci dclare une donne pointeur dont lidentificateur est nom_pointeur, dont la valeur est
ladresse dune variable de type type. On dit dans ce cas l que nom_pointeur pointe sur la
variable.
Le nom nom_pointeur est donc une sorte de variable dadresse. Qui a donc elle-mme une
adresse et un contenu. La valeur (le contenu) de nom_pointeur est modifiable. Ceci signifie que
ladresse est modifiable et quune fois modifie on pointe sur un autre lment.
Attention il faut bien voir aussi que le contenu de la variable pointe par nom_pointeur peut
lui aussi tre modifi.
Affectation
On sintresse ici laffectation et la modification du contenu du pointeur (le changement
dadresse).
Affectation Laffectation dun pointeur consiste lui donner une adresse. cette adresse est obtenue par loprateur &. Ainsi dans le code suivant on dclare une variable entier laquelle on
affecte la valeur 1 et une variable pointeur (pointeur sur un entier) laquelle on affecte ladresse
de entier.
int entier;
int *pointeur;
entier=1;
pointeur = &entier;
A la fin de ces instructions les adresses et contenu des variables sont :
entier a pour valeur 1 et pour adresse X (o X est un entier dcrivant ladresse).
pointeur a pour valeur X et pour adresse Y (o Y est un entier qui donne ladresse de
pointeur.
La modification peut se faire (entre autre) en utilisant nouveau loprateur & ou encore en
copiant le contenu dune autre variable de type pointeur.
Exemple 7.3.1. Soit le programme suivant
main()
{
int entier1;
int entier2;
int *pointeur1;
int *pointeur2;
entier1= 1;
entier2= 2;
MMIA, Langage C
pointeur1 = &entier1;
pointeur1 = pointeur2;
}
A titre dexercice vous pouvez listez les diffrents contenus des variables du programme au cours
de son droulement.
Modification de la valeur pointe
On sintresse ici la modification du contenu de la variable pointe cest dire au changement
du contenu de la valeur de la variable dont ladresse est le contenu de la variable pointeur.
Observons le schma relatif.
Tout dabord il faut connatre linstruction qui va permettre daccder au contenu de la variable
pointe. Cest loprateur (unaire ici) qui permet daccder directement la valeur de lobjet
point.
Soit pointeur un pointeur vers un caractre c, *pointeur dsigne la valeur de c. Si on reprend
la suite dinstructions ci-dessus adapte aux caractres.
char c = e;
char *pointeur;
pointeur = &c;
*pointeur=d;
Donnera la fin du programme
c a pour valeur d et pour adresse X (o X est un entier dcrivant ladresse).
pointeur a pour valeur X et pour adresse Y (o Y est un entier qui donne ladresse de
pointeur.
Quelles diffrences y a-t-il entre le programme suivant et le programme de lexemple 7.3.1 ?
main()
{
int entier1;
int entier2;
int *pointeur1;
int *pointeur2;
entier1= 1;
entier2= 2;
MMIA, Langage C
*pointeur1 = *pointeur2;
}
Lien avec le passage par adresse
On peut remarquer en reprenant le passage consacr au passage de paramtres par adresse du
chapitre prcdent sur les fonctions que le passage par adresse utilise en fait des pointeurs.
Ainsi, la fonction echange2
void echange2 (int *adr_a, int *adr_b)
{
int t;
t = *adr_a;
*adr_a = *adr_b;
*adr_b = t;
return;
}
prend comme paramtres deux pointeurs (les pointeurs tant passs par valeur) et la manipulation
effectue consiste en lchange des valeurs pointes.
Chapitre 8
Structure de donnes 2
Ce chapitre est la suite du chapitre sur le mme sujet donn au premier semestre.
8.1
Les tableaux deux dimensions
On peut tendre les tableaux une dimension et utiliser des tableaux plusieurs dimensions.
Ainsi on peut voir un tableau deux dimensions comme :
Un ensemble de cases mmoires ordonnes la fois sur des lignes et des colonnes.
Un ensemble de cases mmoires indices par deux indices lun dsignant la ligne, lautre
dsignant la colonne.
Un tableaux une dimension (les lignes) dont chaque case mmoire est en fait un tableau
(les colonnes) une dimension.
Schema 8.1.1.
Un tableau deux dimensions se dclare par type nomtableau[nblig][nbcol]. Ainsi,
const L=5;
const C=10;
int tableau[L][C];
dclare un tableau dentiers de 5 lignes 10 colonnes.
Laccs la case dindice de ligne i et dindice de colonne j se fait par tab[i][j].
Exemple 8.1.2 (Fonction dinitialisation dun tableau deux dimensions). Le code de la fonction
dinitialisation dun tableau deux dimensions est
#include <stdio.h>
void initialisation2d(int tab[2][2]);
void initialisation2d(int tab[2][2]){
74
MMIA, Langage C
int i,j;
for(i=0;i<2;i++){
for(j=0;j<2;j++){
printf("Entrez la valeur de tab %d %d",i,j);
scanf("%d",&tab[i][j]);
}
}
return;
}
main(){
int tableau[2][2];
initialisation2d(tableau);
}
Commentaires Explication de la diffrence entre les dclaration du tableau ici et dclaration des
fonctions manipulant des tableaux une dimension du chapitre prcdent.
Exercice 8.1.3 (Matrice transpose). On veut la fonction qui permette de calculer la transpose
dune matrice. On suppose que la matrice donne sera la matrice transforme. On suppose que
linitialisation est faite au pralable.
t
Mathmatiquement cela veut dire que le terme de coordonnes (i, j) de la matrice Mi,j = Mj,i
.
Cela veut dire quil faut changer les termes 2 deux. Mais attention on ne doit pas changer
les termes deux fois. Cela veut dire, que lon doit faire tourner notre algorithme sur la moiti
triangulaire suprieure ou la moiti triangulaire infrieure.
Le code de cette fonction est :
void transposee(int tab[5][5]){
int i,j;
int temp;
for(i=0;i<5;i++){
for(j=i+1;j<5;j++){
/* i+1 car on ne veut quune partie */
temp=tab[i][j];
tab[i][j]=tab[j][i];
tab[j][i]=temp;
}
}
return;
MMIA, Langage C
8.2
Les structures
Les tableaux quils soient une dimension ou non ne peuvent stocker quun seul type de variable (des entiers, des caractres, etc...) mais ils ne peuvent stocker la fois des caractres et des
entiers (par exemple). Plus gnralement ils ne peuvent stocker des varaiables de type diffrents.
Cest un peu gnant ds lors que lon veut structurer des donnes plus complexes. Ainsi, si on veut
stocker par exemple une base de donnes de clients dune banque avec leur nom et leur solde de
compte. On veut donc organiser une donne qui comporte diffrent type de valeurs (le nom, le
solde).
Dfinition 8.2.1. Une structure est un lment qui regroupe et comporte un ensemble fini de plusieurs variables qui peuvent tre de type diffrents. Chaque lment de la structure est appel
champ. Chaque champ est identifi par un identificateur.
Pour bien fonctionner il faut indiquer lordinateur lorsquon dfinit une structure quels sont
les champs impliqus, leurs identificateurs et leurs type. Il faut donc dfinir un caneva (ou modle)
de la structure. On dclare le modle formel de la structure et non la "variable" correspondant
une "ralisation" de la structure.
Une dclaration de caneva se fait par
struct caneva_de_la_structure {
type champ1;
type champn;
};
Ici le terme caneva_de_la_structure est appel tiquette de la structure. Ltiquette permet
didentifier un modle de structure.
Ainsi les instructions suivantes permettent de dclarer un modle de structure appele (dtiquette) compte. De plus, le second jeu dclare lui des variables compte1, compte2 et compte3
de type structure struct compte.
struct compte {
char nom;
int solde;
};
struct compte compte1, compte2, compte3;
On saperoit donc quune structure dfinit un type.
Accs la valeur des membres Pour pouvoir accder la valeur dun des membres dune structure on utilise le . qui associe le nom dune structure (une variable de type struct) au nom du
membre. Ainsi,
printf("Monsieur Madame %c a %d sur son compte",compte1.nom,compte1.solde
MMIA, Langage C
8.2.1 Manipulation de structures

La structure tant dun genre un peu particulier on peut se demander comment les manipuler.
Oprations permises
Les seules oprations permises sur une structure sont
1. La copie ou laffectation. Ce, en considrant la structure dans son ensemble.
2. La rcupration de son adresse au moyen de loprateur &.
3. Laccs ses membres.
Initialisation Voyons comment initialiser une structure compte dfinie comme ci-dessus.
En accdant ses membres (petit 3).
it - Par une numration des valeur : struct compte compte1=c,10 ;.
- En affectant les membres 1 1 :
struct compte compte1;
compte1.nom=c;
compte1.solde=10;
Dans ce dernier cas il est plus facile et plus courant de programmer une fonction dinitialisation
qui va renvoyer une structure. Remarque il est possible de renvoyer une structure car une structure
dfinit un type. Il est alors important de voir que ce type doit tre connu de la fonction au moment
de sa dclaration pour la compilation. Cette fonction prendra en paramtres les diffrentes valeurs
des champs.
struct compte creationcompte(char c,int solde){
struct compte temp;
temp.nom=c;
temp.solde=solde;
return temp;
qui sera appele par compte1=creationcompte(c,10) ;.
Une petite question Pourquoi est-ce faisable et que alors que temp va disparaitre ?
Par recopie dune structure dj initialise : compte2=compte1.
Structure et pointeurs
MMIA, Langage C
Quelques exemples
Voici, nous prsentons ici quelques structures et les manipulations affrentes ce pour illustrer
le maniement de tels objets.
On sintresse une structure big_brother qui a pour champs : matricule, numero_maison,
et present. on veut dfinir des fonctions est_present, arrivee et depart qui indiquent respectivement si la personne est prsente ou non dans lappartement et qui modifient la valeur selon la
prsence ou non de la personne dans son appartement.
le code gnral du programme est
#include <stdio.h>
struct
int
int
int
}
big_brother{
matricule;
numero_maison;
present;
struct big_brother initialise(int, int)

int est_present(struct big_brother)
struct big_brother arrivee(struct big_brother)
struct big_brother depart(struct big_brother)
struct big_brother initialise(int mat, int num){
struct big_brother temp;
temp.matricule=mat;
temp.numero_maison=num;
temp.present=0; // non present au depart
}
int est_present(struct big_brother p){
return p.present;
}
struct big_brother arrivee(struct big_brother p){
temp.matricule=p.matricule;
temp.numero_maison=p.numero;
temp.present=1;
return temp;
}
struct big_brother depart(struct big_brother p){
MMIA, Langage C
temp.matricule=p.matricule;
temp.numero_maison=p.numero;
temp.present=1;
return temp;
}
main(){
struct big_brother b;
b=initialise(0,0);
// note on pourrait faire un menu
if (est_present(b)==1)
printf("La personne est prsente dans son appartement");
b=depart(b);
}
Et si je faisais une copie des structures dans depart et arrivee plutt que celle des champs que se
passerait-il ?
Structure et pointeurs Tout comme les types int, float ... vus auparavant on peut manipuler
des pointeurs sur des structures. Cela peut tre trs utile ds lors quon utilise des structures de
tailles importantes. Soit une structure nomme blabla avec des champs x et y. La dclaration
dun pointeur sur cette structure se fait alors par linstruction struct blabla *pointeur. Laccs
ces membres (ou champs) se fait laide de linstruction (*pointeur).x. Le parenthsage est d
uniquement des histoires de priorits des oprateurs.
Cependant comme il tait (est ?) fastidieux de tout taper chaque fois il existe un raccourcis bien pratique pour accder la valeur dun des membre. Si pointeur est un pointeur sur une
structure blabla alors p->x permet daccder la valeur du membre x de blabla.
Tableaux de structures
Comme le mot clef struct dfinit un type alors il est parfaitement possible de crer des tableau
stockant des structures du mme type.
Cela se fait de la manire suivante
struct eleve {
int module1;
int module2;
}
struct eleve promotion[35];
Rcuprer la valeur dun membre dun lment du tableau devient promotion[25].module1=20.
MMIA, Langage C
8.2.2 Structure plus complexes

Les structures que nous avons vu jusqu maintenant taient des structures dont les champs sont
plutt simples. Nous allons voir que les champs des membres peuvent tre de type plus complexes.
8.2.3 Structures comportant des tableaux

Une structure peut avoir des champs qui sont des tableaux. Ilest donc parfaitement possible de
mlanger ces deux types de structures de donnes.
Une telle structure pourrait tre de la forme :
struct eleve {
char nom[100];
double moyennes[15];
}
qui stockerait un lve par son nom (le tableau de caractre) et qui stockerait lensemble de ses
quinze notes dans un tableau.
Laccs la 8 eme note dun lve dont la variable associe est note par a serait donc effectu
par a.moyenne[7].
8.2.4 Structure comportant des structures

De la mme manire on peut avoir un des membre qui est lui-mme une structure. Par exemple,
on peut dfinir une structure client qui dfinit deux champs identifiant et dure de consommation
totale duree et qui comporte une structure dtaillant le nombre dheures gratuites (dans le forfait)
et le cot des minutes supplmentaires.
Ceci donnerait,
struct forfait{
int heures_gratuites;
float cout_minutes;
}
struct client {
int identifiant;
float duree;
struct forfait abonnement;
}
Chapitre 9
Maniement des fichiers
9.1
Introduction
Jusqu maintenant nous navions vu que des entres sorties (on peut rsumer par entres sorties lchange de donnes entre le programme et lutilisateur dans le cadre de ce cours) sous la
forme dentre standard (usuellement le clavier) et de sortie standard (usuellement lcran). Ce
type dentre sortie peut facilement atteindre ses limites ds lors que lon souhaite entrer de nombreux paramtres (par exemple des fichiers de configuration) ou garder une trace des rsultats de
lexcution dun programme. Une faon de grer cela est dutiliser des fichiers par lintermdiaire
dun certain nombre de fonctions du langage C.
La transmission des informations du programme vers le disque dur ou vice versa est en fait
le traitement dun flux de donnes. Les oprations sur les flux que nous allons voir ici passent
par un "buffer" (un espace mmoire qui va servir de rservoir mais nous ne prciserons pas o)
gr par le systme. Ceci signifie quune instruction dcriture dans le programme ne se traduira
pas immdiatement par une criture sur le disque mais par une criture dans le buffer, avec
criture sur disque quand le buffer est plein. Autrement dit, lors du maniement dun fichier il y a
cration dun espace mmoire dans la mmoire vive et il faut quil y ait galement une association
entre le fichier sur le disque et cet espace mmoire et une association entre lespace mmoire et le
programme. Le programme se chargeant dcrire (ou de lire) dans le buffer tandis que le systme
dexploitation se chargera dcrire directement sur le disque dur (ou la disquette voire tout autre
lment de sauvegarde non temporaire).
Les informations ncessaires la maintenance des associations : programme espace mmoire
et espace mmoire disque dur sont dcrites dans une structure FILE (dans stdio.h) et, lors du
programme, on gre un pointeur sur cette structure. Un fichier sera identifi alors par ce pointeur.
9.2
Diffrents types de fichier
On considre deux types de fichiers : les fichiers binaires et les fichiers textes.
81
MMIA, Langage C
9.2.1 Fichiers textes

Par convention, cette extension correspond aux fichiers formats au format de texte ASCII.
Ainsi, par exemple, (un int binaire sera transform en dcimal puis on crira le caractre correspondant chaque chiffre).
Du fait de lexistence de variantes (accentuation, ...) ce format ne permet pas une portabilit
totale (sur tous les ordinateurs) ASCII mais autorise nanmoins une trs large palette de possibilits
de portabilit.
9.2.2 Fichiers binaires

Ce sont des fichiers qui contiennent caractres, int, double crits en binaire mais qui ne
contiennent pas de chanes de caractres. Lorsquon dit crit en binaire cela signifie que un double
sera stock comme il est cod en mmoire, do gain de place mais surtout incompatibilit entre
diffrents codage des nombres.
9.3
Oprations
Nous dcrivons maintenant les diffrentes oprations que nous pouvons effectuer sur les fichiers ainsi que leur rle.
9.3.1 Ouverture
Tout dabord il faut indiquer au programme de faire le lien entre le fichier crit sur le disque et
la variable que lon manipule dans le programme. Plus prcisment, il faut crer une association
entre un flux de donnes et le fichier sur le disque. Ceci est fait au moyen de la fonction fopen (file
open). Son prototype est
FILE *fopen(char *nom,char *name)
La fonction, renvoie un lment de type FILE* (pointeur sur une structure *FILE) qui est le
flux de donnes et ouvre (lui associe) un fichier dont le nom est dcrit en paramtre.
Dcrivons ses arguments :
1. Le premier argument est le nom du fichier donn sous la forme dune chane de caractres
(*char est un pointeur sur le premier caractre de la chane).
2. Le second argument est une chane de caractres qui spcifie le mode daccs au fichier, cest
dire la manire dont on accde au fichier.
MMIA, Langage C
Les modes daccs Les diffrents modes daccs dcrivent la faon daccder aux fichier. On ne
sintresse quaux fichiers textes.
Mode Action
r
lecture (read )
"w" criture (write)
"a"
"r+"
"w+"
"a+"
Conditions
Le fichier doit exister
Le fichier va tre cr.
Sil existe lancien fichier sera effac par le nouveau fichier
criture la fin (append ) Les donnes vont tre places la fin du fichier.
Sil nexiste pas sera cr.
lecture/criture
lecture/criture
lecture/criture la fin
Rgle de programmation 9.3.1. Si lexcution de cette fonction ne se droule pas normalement, la

valeur retourne est le pointeur NULL. Il est donc recommand (comme avec un certain nombre
de fonctions renvoyant NULL) de toujours tester si la valeur renvoye par la fonction fopen est
gale NULL afin de dtecter les erreurs (lecture dun fichier inexistant...).
Exemple 9.3.2. Un exemple douverture dun fichier examen.txt lire sur la clef USB (lecteur D
sous windows).
#include <stdio.h>
main(){
FILE *fichier;
fichier=fopen(E:\\examen.txt,r);
if (fichier == NULL){
printf(jarrive pas lire);
}
}
9.3.2 Fermeture
La fermeture du flot associ un fopen est fclose (fclose(flot)). Cette fonction casse la relation
qui existe entre le flot et le fichier sur disque. Elle vide (flush) galement les tampons. De manire
gnrale ne pas fermer les fichiers peut parfois provoquer des erreurs car selon le systme il se peut
que le fichier reste ouvert.
9.3.3 Lecture criture

Les lectures et les critures dans les fichiers textes se font avec les fonctions fprintf, fscanf qui
sont similaires printf, scanf lexception de ladjonction dun flot.
MMIA, Langage C
fprintf(flot,formatage, expr_1,...,expr_n)
fscanf(flot,formatage,expr1,...,exprn)
9.3.4 Exemple
On veut lire un fichier de dix entiers (chacun deux sur une ligne) et leur rajouter chacun la
moyenne temporaire des valeurs qui sera inscrite dans un deuxime fichier. Ceci dans le fichier
utilisateur1.data et utilisateur1.data dont le chemin est (sous linux) /home/user/moi/.
#include <stdio.h>
main(){
FILE *lire;
FILE *ecrire;
int somme;
int entier;
int i;
lire=fopen(/home/user/moi/utilisateur1.data,r);
if (lire != NULL){
somme=0;
ecrire=fopen(/home/user/moi/utilisateur2.data,w);
if (ecrire != NULL){
for(i=0;i<10;i++){
fscanf(lire,%d,&entier);
somme=somme+entier;
fprintf(ecrire,%f,somme/(i+1));
}
}
else{
printf(Le programme sarrete);
}
}
else{
printf(Le programme sarrete);
}
fclose(lire);
fclose(ecrire);
}
Remarquons que les lus sont lus les uns la suite des autres de manire squentielle.

Programmation L C

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Programmation L C

Transféré par

Droits d'auteur :

Formats disponibles

Universite Paris Ouest Nanterre La dfense

Table des matires

Structure gnrale dun programme C

Les instructions structures ou Structures de contrles

3.2.3 Les boucles : Introduction

Quelques principes de bases de lalgorithmique

6.4.1 Variables globales . . . . . . . . .

Maniement des fichiers

Apprentissage de linformatique et buts poursuivis par ce

1.1.1 But du cours et prrequis

Dfinition 1.2.1 (Ordinateur : Dfinition "juridique"). Le terme ordinateur dsigne un appareil

car les bits sont transforms suivant le code ASCII.

Ici arrive la question

sans se tirer une balle dans la tte.

1.4.2 Smantique et syntaxe dun langage

2.1.2 Mots rservs du langage

Structure dun programme

2.2.2 Organisation gnrale

2.2.3 Les variables

Sur les compilateurs GNU

printf("La premiere lettre de mon prenom est : ");

printf("La premiere lettre de Pierre est :")

Une expression en informatique cest la gnralisation de la formule mathmatique.

Qui fait elle mme partie de lexpression en C

2.3.1 Oprateurs arithmtiques

2.3.2 Oprateurs de comparaisons

2.3.3 Oprateurs affectation compose et dincrmentation dcrmentation

2.3.4 Oprateur dadresse

2.3.5 Sens de lvaluation dune expression

Exemple 2.3.10. Quelle va tre lexpression de la valeur suivante ?

2.3.6 Transtypage ou conversion de type

Cest loprateur ( type ) avec type le type de sortie dsir.

On introduit les structures relatives au choix.

3.2.1 Smantique : Traduction en suite dactions

3.2.3 Les boucles : Introduction

3.2.4 la boucle for

On reprsente la boucle par le schma suivant.

Entre-> Test valeur indice $i<Fin$ ? -> non sortie de boucle

Excution du programme Commenter le droulement Au dbut affectations : deb = 0 et f in = 9.

En algo : pour i de 100 104 rpter : afficher lentier

3.2.5 La boucle while

Quelques erreurs classiques

On a bien le temps daller prendre un caf

4.2.1 Dclaration dun tableau

4.2.2 Initialisation dun tableau

4.2.3 Accs une entre du tableau

Manipulations de tableau : Quelques Exemples

4.3.1 Affectation, copie et affichage de tableaux de taille donne

5.2.1 Un exemple daccumulateur simple

5.2.2 Le maximum des lments dun tableau

5.3.1 Exemple introductif

5.3.2 Modlisation et exemple de calcul

5.3.3 Suite rcurrente dordre suprieur 1

Equivalence entre accumulateur et suite rcurrente

La question quon se pose maintenant tient sous deux formes :

5.5.1 Raisonnement par rcurrence

5.5.2 Invariant de boucle et accumulateur

En langage C comme dans beaucoup dautres Langages informatique on peut dcouper un

6.1.1 But dune fonction

Fonction daffichage dun menu.

Fonctions non paramtres

On sintresse dans un premier temps des fonctions dites non paramtres 1 .

6.2.1 Dfinition dune fonction