Vous êtes sur la page 1sur 142

ALGORITHME - PROGRAMMATION – LANGAGE C

Dr KAMAGATE Beman Hamidja


E-mail : beman2017@gmail.com
Tel : +225 49 13 76 83
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 1
STRUCTURE D’UN ORDINATEUR

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 2


CONSTITUANT D’UN ORDINATEUR

❑ Les ordinateurs sont des machines programmables capables d’effectuer un


nombre important d’opérations avec précision en un temps très court.

❑La structure de base d’un ordinateur comprend les éléments fondamentaux


suivants :
▪ Une unité centrale de traitement (unité centrale).
▪ Une unité de mémoire, appelée mémoire centrale.
▪ Des unités de stockage.
▪ Des unités d’entrée/sortie.
▪ Un système de bus permettant de véhiculer l’information entre l’unité
centrale et les autres unités.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 3


CONSTITUANT D’UN ORDINATEUR

Figure 1 : Architecture d’un ordinateur


Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 4
UNITE CENTRALE DE TRAITEMENT

❑ L’unité centrale de traitement ou CPU (Central Processing Unit) est le centre de


calcul et de contrôle d’un ordinateur, elle constitue le « cerveau » de
l’ordinateur. L’unité centrale réalise toutes les opérations demandées, elle est
matérialisée physiquement par un circuit électronique appelé « microprocesseur ».
❑ Un microprocesseur est caractérisé principalement par :
▪ Sa marque (Intel , cyrix, amd,….).
▪ Sa fréquence d’horloge : le nombre d’opération que le microprocesseur peut
effectuer en seconde (la fréquence atteint actuellement quelques Gigahertz).
1 KHz = 210 Hz
1 MHz = 220 Hz
1 GHz = 230 Hz

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 5


UNITE CENTRALE DE TRAITEMENT

❑ L’unité centrale comporte les éléments suivants :


▪ Unité arithmétique et logique :
L’UAL est l’organe qui permet d’effectuer des opérations arithmétiques (addition,
soustraction, multiplication, division), des opérations logiques (par exemple des
comparaisons).
▪ Unité de commande :
L’unité de commande gère le déroulement des instructions. Elle décode et
exécute les instructions demandées.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 6


MÉMOIRE CENTRALE

❑ La mémoire centrale est un organe de l’ordinateur permettant d’enregistrer, de


stocker et de restituer les informations.
▪ La mémoire centrale se présente sous la forme de petites barrettes que l’on
peut enficher dans des supports, appelés Slots.
▪ La mémoire centrale d’un ordinateur est séparée en deux sections :
la mémoire vive et la mémoire morte.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 7


MÉMOIRE CENTRALE
❑ La mémoire vive (RAM Random Access Memory) : est une mémoire où on peut lire
et écrire à volonté. Cette mémoire est dite « volatile » c'est-à-dire qu’elle perd son
contenu dés qu’elle est hors tension.
La mémoire vive contient en plus des programmes servant à la gestion de l’ordinateur,
le programme relatif à un traitement spécifique ainsi que les données qu’il requiert et
les résultats qu’il génère.

❑ La mémoire morte (ROM Read Only Memory) : Est destinée uniquement à être lue ;
en revanche, son contenu n’est pas altéré par une coupure de courant, c'est une
mémoire « permanente »
La mémoire morte, programmée par le constructeur, est essentiellement utilisée pour
contenir les logiciels de base servant au démarrage de l’ordinateur.
Toutefois, il est possible d’écrire sur certains types de mémoire morte, désignés par :
les sigles PROM(Programmable Read Only Memory), EPROM (Erase Programmable
Read Only Memory) et EEPROM (Electrically Erasable Programmable Read Only
Memory) :
.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 8


LES PERIPHERIQUES

❑ Les périphériques sont les organes de l’ordinateur qui permettent de communiquer


avec l’unité centrale et de stocker les informations d’une façon permanente.

▪ Les périphériques d’entrée : clavier , souris ,Scanner, Microphone….

▪ Les périphériques de sortie : écran , imprimante , enceintes…

▪ Les périphériques de stockage : disque dur, CD-ROM, DVD, Clé…

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 9


SYSTÈME DE BUS

❑ Un bus est un système de transfert de données entre plusieurs unités


fonctionnelles de traitement de données par l'intermédiaire d'une voie de
transmission commune

Carte de bus
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 10
SYSTÈME DE BUS
❑ On distingue trois bus :

▪ Les bus de données transmettent le message proprement dit,


▪ Les bus d’adresses permettent d'identifier les composants qui partagent les
données,
▪ Le bus de contrôle, un ensemble de signaux identifiant le type d'action : lecture ou
écriture, taille du message.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 11


STRUCTURE D’UNE UNITE DE CALCUL EMBARQUE

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 12


QU’EST-CE QU’UN SYSTÈME EMBARQUE ?

❑ Un système embarqué est un système complexe qui intègre du logiciel et du matériel


conçus ensemble afin de fournir des fonctionnalités données. Il contient généralement
un ou plusieurs microprocesseurs destinés à exécuter un ensemble de programmes
définis lors de la conception et stockés dans des mémoires. Le système matériel et
l'application (logiciel) sont intimement liés et immergés dans le matériel et ne sont pas
aussi facilement discernables comme dans un environnement de travail classique de
type ordinateur de bureau PC( Personal Computer),
❑ Un système embarqué est autonome et ne possède pas des entrées/sorties
standards tels qu'un clavier ou un écran d'ordinateur. Contrairement à un PC,
l'interface IHM (Interface Homme machine) d'un système embarqué peut être aussi
simple qu'une diode électroluminescente LED( Light Emitter Diode) qui clignote ou
aussi complexe qu'un système de vision de nuit en temps réel ; les afficheurs à
cristaux liquides LCD (Liquid Crystal Display) de structure généralement simple sont
couramment utilisés.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 13


EXEMPLE DE SYSTÈMES EMBARQUES

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 14


DECOMPOSITION D’UN SYSTÈME EMBARQUE
❑ Quelle que soit la nature et la complexité du système, on décompose un système
embarqués en :
▪ Le système contrôlé = environnement (procédé) équipé d'une instrumentation qui réalise
l'interface avec le système de contrôle
▪ Le système de contrôle = éléments matériels (microprocesseurs… ) et logiciels dont la mission
est d'agir sur le procédé via les actionneurs en fonction de l'état de ce procédé indiqué par les
capteurs de manière maintenir ou conduire le procédé dans un état donné

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 15


STRUCTURE TYPIQUE D’UN SYSTÈME EMBARQUE

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 16


ARCHITECTURE EN COUCHE D’UN SYSTÈME EMBARQUE

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 17


ARCHITECTURE EN COUCHE D’UN SYSTÈME EMBARQUE
❑ Couche matérielle :
▪ Unité centrale de calcul(Central Processor Unit - CPU) constituée d’un microprocesseur,
qui permet au système informatique d’exécuter les programmes, lire les données et
restituer des résultats ;
▪ Mémoire - unité physique où les données et/ou programmes sont stockées ;
▪ Interface Entrées/Sorties permettent de communiquer avec l’extérieur/périphériques.
▪ Bus - interconnexion des différents composants

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 18


ARCHITECTURE EN COUCHE D’UN SYSTÈME EMBARQUE
❑ Couche système
▪ La couche système est une couche optionnelle. Cependant , sa présence peut être
nécessaire dans les cas suivants :
• Affranchir le développeur de bien connaître le matériel : gain de
temps de développement ;
• Bénéficier des mêmes avancées technologiques que les applications
classiques ;
• Environnement de développement plus performant.

▪ Quelques exemples de système d’exploitation


• Windows (depuis 1985) c’est aujourd’hui l’OS le plus répandu
• Mac OS (depuis 1984)
• Unix crée en 1969 par Kenneth Thompson
• Linux crée en 1991 par Linux Torvalds (plusieurs distributions sont disponibles open-source)

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 19


ARCHITECTURE EN COUCHE D’UN SYSTÈME EMBARQUE
❑ Couche logiciel application ( langages de programmation)
▪ Ce sont un ensemble de logiciels qui permettent de créer un programme qui seront traduit dans
un langage machine du micro-processeur. A ce niveau , nous avons les langages de bas
niveau et les langages de hauts niveau.

• Un langage de programmation de bas niveau ne fournit que peu d'abstraction par rapport au jeu
d'instructions du processeur de la machine. Le langage machine et le langage
d'assemblage sont les archétypes de langages de bas niveau, puisqu'ils permettent de
manipuler explicitement des registres, des adresses mémoires, des instructions machines.

• Un langage de haut niveau permet de créer un programme sans tenir compte des
caractéristiques particulières (registres, etc) de l'ordinateur censé exécuter le programme.
Exemple de langage de haut niveau : C,C++, Java, Python….

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 20


LANGAGE DE PROGRAMMATION

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 21


QU’EST-CE QUE LA PROGRAMMATION ?
❑ Programmer c’est demandé à l’ordinateur d’exécuter des actions élémentaires
appelées : instructions.
❑ Ces actions élémentaires résultent d’un algorithme qui constitue un schéma de
résolution d’un problème.
❑ L’ordinateur ne comprend que le langage machine qui est difficilement
compréhensible par l’être humain.

Exemple : si on demandait à l’ordinateur d’effectuer l’opération « 3+5 » , cela pourrait


se traduire par : 0010110110010011010011110

Langage binaire ( suite de 0 et 1) parfaitement compréhensible par l’ordinateur


mais pas par l’homme. D’où la nécessité d’un langage de programmation très
proche du langage humain et traductible dans le langage machine de
l’ordinateur.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 22


LANGAGE C

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 28


PRESENTATION DU LANGAGE C

❑ Le langage C est un langage de programmation impératif et généraliste. C’est un des


langages les plus utilisés.

❑ La programmation impérative est un paradigme de programmation (


https://fr.wikipedia.org/wiki/Paradigme_(programmation) ) qui décrit les opérations en séquences
d'instructions exécutées par l'ordinateur pour modifier l'état du programme.

❑ Le C est également un langage compilé par opposition au langage interprété. Cela signifie
qu'un programme C est décrit par un fichier texte, appelé fichier source. Ce fichier n'étant
évidemment pas exécutable par le microprocesseur, il faut le traduire en langage machine par
un compilateur.

❑ compilateur: C’est un programme qui traduit un code source écrit dans un langage de haut
niveau compréhensible par l’être humain en un langage de bas niveau (langage machine)
compréhensible par l’ordinateur.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 29


PRESENTATION DU LANGAGE C

❑ Les normes du langage C:


▪ ANSI X3.159-1989 (ANSI C, C89);
▪ ISO/CEI 9899:1990 (C90);
▪ ISO/CEI 9899:1999 (C99);
▪ ISO/CEI 9899:2011 (C11).
❑ Influencé par : BCPL, B, Algol 68, Fortran.
❑ A influencé : awk, csh, C++, C#, Objective-C, D, Concurrent C, Java, JavaScript, PHP, Perl,…
❑ Implémentation : GCC, MSVC, Borland C, Clang, TCC
❑ Extension de fichier : .c et .h

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 30


HISTORIQUE DU LANGAGE C
❑ 1972: Conception du C par Dennis Richie et Ken Thompson, chercheurs aux Bell Labs, afin
de développer le système d'exploitation UNIX.
❑ 1978, Brian Kernighan et Dennis Richie publient la définition classique du C dans le livre The
C Programming language

Ken Thompson ( à gauche)


Dennis Ritchie( à droite)

❑ de 1983 à 1989 : Travail de normalisation du par l’ANSI ((American National Standards


Institute)

❑Celle-ci fut reprise telle par l'ISO (International Standards Organization) en 1990.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 31


DEVELOPPEMENT D’UN PROGRAMME C

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 32


LES ETAPES DU DEVELOPPEMENT

❑ Etape 1 : Edition du fichier source


▪ Le fichier source ou code source represente la traduction de l’algorithme dans le
langage C. C’est un fichier qui a pour extension .c
▪ Plusieurs éditeurs de textes permettent de créer ce fichier source , on peut citer comme
exemple :
• bloc note , notepad++ sous windows
• vim, vi sous UNIX/Linux
❑ Etape 2 : la compilation
▪ Cette étape permet de créer un fichier objet (fichier binaire ) à partir d’un fichier source.
▪ Le fichier objet a pour extension .o

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 33


LES ETAPES DU DEVELOPPEMENT

❑ Etape 3 : Edition de liens


▪ L’édition de lien consiste à créer un fichier exécutable à partir des fichiers objets du projets
en les mettant bout en bout.
▪ La résolution des appels qui ont été laissés durant la compilation, cela consiste à
remplacer l’appel à la fonction par un lien (un saut) vers la fonction elle-même (qui se
trouve à un endroit différent dans le binaire).
▪ L’édition de lien positionne le point de départ du programme (la première ligne de la
fonction main).
❑ Etape 4 : le débogage
▪ Le débogage permet de traquer les erreurs et le corrigés

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 34


LES OUTILS
❑ Pour créer un programme C , on a besoin de trois outils
▪ un éditeur de texte;
▪ Un compilateur;
▪ Un éditeur de lien;
▪ Un débogueur;
❑ Ce qui se fait dans la pratique ?
▪ Soit on récupère chacun de ces quatre programmes séparément. C'est la méthode la plus
compliquée, mais elle fonctionne. Sous Linux en particulier, bon nombre de programmeurs
préfèrent utiliser ces quatre programmes séparément.
▪ Soit on utilise un programme qui combine éditeur de texte, compilateur et débogueur. Ces
programmes» sont appelés IDE, ou encore « Environnements de développement ».

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 35


LES OUTILS
❑ Quelques IDE
▪ Visual C++.( windows)
▪ Code::Blocks.( windows, Linux, Mac Os)
▪ Xcode ( Mac Os seulement )
Et bien d’autres .
Dans ce cours nous allons utiliser Code::Blocks

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 36


CODE::BLOCKS

❑ INSTALLATION
❖ Code::Blocks est un IDE libre et gratuit, disponible pour Windows, Mac et Linux.
❖ Pour télécharger , aller sur la page : http://www.codeblocks.org/downloads/binaries
▪ Si vous êtes sous Windows, repérez la section « windows ». Télécharger le logiciel
en prenant le programme qui contient mingw dans le nom (ex : codeblocks-17.12mingw-
setup.exe). L’autre version est sans compilateur.

▪ Si vous êtes sous Linux, choisissez le package qui correspond à votre distribution,
▪ Enfin, sous Mac, choisissez le fichier le plus récent de la liste.
❖ L'installation est très simple et rapide. Laissez toutes les options par défaut et lancez le
programme.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 37


CODE::BLOCKS

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 38


Code::Blocks

▪ (1) la barre d'outils : elle comprend de nombreux boutons, mais seuls quelques-uns nous
seront régulièrement utiles. J'y reviendrai plus loin;
▪ (2) la liste des fichiers du projet : c'est à gauche que s'affiche la liste de tous les fichiers
source de votre programme. Notez que sur cette capture aucun projet n'a été créé, on ne voit
donc pas encore de fichiers à l'intérieur de la liste;
▪ (3) la zone principale : c'est là que vous pourrez écrire votre code en langage C;
▪ (4) la zone de notification : aussi appelée la « zone de la mort », c'est ici que vous verrez
les erreurs de compilation s'afficher si votre code comporte des erreurs. Cela arrive très
régulièrement !

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 39


CODE::BLOCKS
❑ Créer un nouveau projet
▪ Pour créer un nouveau projet, c'est très simple : allez dans le menu
File / New / Project
▪ Dans la fenêtre qui s'ouvre (fig. suivante), choisissez Console application

▪ Cliquez sur Go pour créer le projet. Un assistant s'ouvre. Faites Next, cette
première page ne servant à rien.
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 40
CODE::BLOCKS
❑ Créer un nouveau projet( suite)
▪ On vous demande ensuite si vous allez faire du C ou du C++ (fig. suivante) : répondez « C ».

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 41


CODE::BLOCKS
❑ Créer un nouveau projet( suite)
▪ On vous demande le nom de votre projet (fig. suivante) et dans quel dossier les fichiers
source seront enregistrés.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 42


CODE::BLOCKS
❑ Créer un nouveau projet( suite)
▪ Enfin, la dernière page (fig. suivante) vous permet de choisir de quelle façon le programme doit être
compilé. Vous pouvez laisser les options par défaut, ça n'aura pas d'incidence sur ce que nous
allons faire dans l'immédiat (veillez à ce que la case Debug ou Release au moins soit cochée).

Cliquez sur Finish, c'est bon !


Code::Blocks vous créera un premier projet avec déjà un tout petit peu de code source dedans.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 43


LES COMPOSANTS ÉLÉMENTAIRES DU C

❑ Un programme en langage C est constitué des six groupes de composants élémentaires


suivants :
▪ les identificateurs;

▪ les mots-clefs;

▪ les constantes;

▪ les chaînes de caractères;

▪ les opérateurs;

▪ les signes de ponctuation.

Remarque : On peut ajouter à ces six groupes les commentaires, qui sont enlevés par le
préprocesseur.
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 44
LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les identificateurs
▪ Le rôle d'un identificateur est de donner un nom à une entité du programme. Plus précisément,
un identificateur peut désigner :
• un nom de variable ou de fonction,
• un type défini par typedef, struct, union ou enum,
• une étiquette.
▪ Un identificateur est une suite de caractères parmi :
▪ les lettres (minuscules ou majuscules, mais non accentuées),
▪ les chiffres,
▪ le ``blanc souligné'' (_).
▪ Le premier caractère d'un identificateur ne peut pas être un chiffre. Par
exemple, var1, tab_23 ou _deb sont des identificateurs valides ; par contre, 1i et i:j ne le
sont pas. Il est cependant déconseillé d'utiliser _ comme premier caractère d'un identificateur
car il est souvent employé pour définir les variables globales de l'environnement C.

▪ Sensible à la casse : les majuscules et minuscules sont différenciées.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 45


LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les mots-clefs
▪ Un certain nombre de mots, appelés mots-clefs, sont réservés pour le langage lui-même et
ne peuvent pas être utilisés comme identificateurs. L'ANSI C compte 32 mots clefs :
auto const double float int short struct unsigned

break continue else for long signed switch void

case default enum goto register sizeof typedef volatile

char do extern if return static union while

▪ Plusieurs catégories de mots-clefs :


▪ Les spécificateurs de stockage
auto register static extern typedef
• Les spécificateurs de type
char double enum float int long short signed struct union unsigned void

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 46


LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les mots-clefs

• Les qualificateurs de type


const volatile

• Les instructions de contrôle


break case continue default do else for goto if switch while

• Divers
return sizeof

❑ Les commentaires

▪ Un commentaire débute par /* et se termine par */. Par exemple,


/* Ceci est un commentaire */
On ne peut pas imbriquer des commentaires. Quand on met en commentaire un morceau de
programme, il faut donc veiller à ce que celui-ci ne contienne pas de commentaire.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 47


LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ L'affectation

En C, l'affectation est un opérateur à part entière. Elle est symbolisée par le signe = Sa
syntaxe est la suivante :
variable = expression

• Le terme de gauche de l'affectation peut être une variable simple, un élément de tableau
mais pas une constante.

• Cette expression a pour effet d'évaluer expression et d'affecter la valeur obtenue


à variable. De plus, cette expression possède une valeur, qui est celle expression.
Ainsi, l'expression i = 5 vaut 5.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 48


LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ L'affectation
• L'affectation effectue une conversion de type implicite : la valeur de l'expression
(terme de droite) est convertie dans le type du terme de gauche. Par exemple, le
programme suivant
main()
{
int i, j = 2;
float x = 2.5;
i = j + x;
x = x + i;
printf("\n %f \n",x);
}

imprime pour x la valeur 6.5 (et non 7), car dans l'instruction i = j + x;, l'expression j
+ x a été convertie en entier.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 49


LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ Les opérateurs arithmétiques
• Les opérateurs arithmétiques classiques sont l'opérateur unaire - (changement de signe)
ainsi que les opérateurs binaires
+ addition
- soustraction
* multiplication
/ division
% reste de la division (modulo)

• Contrairement à d'autres langages, le C ne dispose que de la notation / pour désigner à la fois


la division entière et la division entre flottants. Si les deux opérandes sont de type entier,
l'opérateur /produira une division entière (quotient de la division). Par contre, il délivrera une
valeur flottante dès que l'un des opérandes est un flottant. Par exemple,
float x;
x = 3 / 2;
affecte à x la valeur 1. Par contre x = 3 / 2.; affecte à x la valeur 1.5.
• L'opérateur % ne s'applique qu'à des opérandes de type entier. Si l'un des deux opérandes est
négatif, le signe du reste dépend de l'implémentation, mais il est en général le même que celui
du dividende.
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 50
LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ Les opérateurs relationnels
> strictement supérieur
>= supérieur ou égal
< strictement inférieur
<= inférieur ou égal
== égal
!= différent

▪ Leur syntaxe est


expression-1 op expression-2
Les deux expressions sont évaluées puis comparées. La valeur rendue est de type int. Elle
vaut 1 si la condition est vraie, et 0 sinon.
▪ Attention à ne pas confondre l'opérateur de test d'égalité == avec l'opérateur d'affection =.
Ainsi, le programme
Ainsi, le programme
main()
{
int a = 0;
int b = 1;
if (a = b)
printf("\n a et b sont egaux \n");
else
printf("\n a et b sont differents \n");
}
imprime à l'écran a et b sont egaux !
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 51
LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ Les opérateurs logiques booléens
• Comme pour les opérateurs de comparaison, la valeur retournée par ces opérateurs est
un int qui vaut 1 si la condition est vraie et 0 sinon.
• Dans une expression de type

expression-1 op-1 expression-2 op-2 ...expression-n

l'évaluation se fait de gauche à droite et s'arrête dès que le résultat final est déterminé. Par
exemple dans
int i;
int p[10];
if ((i >= 0) && (i <= 9) && !(p[i] == 0))
...
La dernière clause ne sera pas évaluée si i n'est pas entre 0 et 9.
&& et logique
|| ou logique
! négation logique

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 52


LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ Les opérateurs logiques bit à bit
• Les six opérateurs suivants permettent de manipuler des entiers au niveau du bit. Ils
s'appliquent aux entiers de toute longueur (short, int ou long), signés ou non.

& et | ou inclusif
^ ou exclusif ~ complément à 1
décalage à
<< >> décalage à droite
gauche

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 53


LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs

▪ Les opérateurs d'affectation composée

• Les opérateurs d'affectation composée sont : += -= *= /= %= &= ^= |= <<= >>=


Pour tout opérateur op, l'expression
expression-1 op= expression-2
est équivalente à
expression-1 = expression-1 op expression-2

Toutefois, avec l'affection composée, expression-1 n'est évaluée qu'une seule fois.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 54


LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ Les opérateurs d’incrémentation et de décrémentation

• Les opérateurs d'incrémentation ++ et de décrémentation -- s'utilisent aussi bien en suffixe


(i++) qu'en préfixe (++i). Dans les deux cas la variable i sera incrémentée, toutefois dans la
notation suffixe la valeur retournée sera l'ancienne valeur de i alors que dans la notation
préfixe se sera la nouvelle. Par exemple,

int a = 3, b, c;
b = ++a; /* a et b valent 4 */
c = b++; /* c vaut 4 et b vaut 5 */

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 55


LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ L'opérateur virgule
• Une expression peut être constituée d'une suite d'expressions séparées par des virgules :
expression-1, expression-2, ... , expression-n
• Cette expression est alors évaluée de gauche à droite. Sa valeur sera la valeur de l'expression
de droite. Par exemple, le programme
main()
{
int a, b;
b = ((a = 3), (a + 2));
printf("\n b = %d \n",b);
}
• imprime b = 5.
La virgule séparant les arguments d'une fonction ou les déclarations de variables n'est pas
l'opérateur virgule. Par exemple l'instruction composée
{
int a=1;
printf("\%d \%d",++a,a);
}
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 56
LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ L'opérateur virgule
• Une expression peut être constituée d'une suite d'expressions séparées par des virgules :
expression-1, expression-2, ... , expression-n
• Cette expression est alors évaluée de gauche à droite. Sa valeur sera la valeur de l'expression
de droite. Par exemple, le programme
main()
{
int a, b;
b = ((a = 3), (a + 2));
printf("\n b = %d \n",b);
}
• imprime b = 5.
La virgule séparant les arguments d'une fonction ou les déclarations de variables n'est pas
l'opérateur virgule. Par exemple l'instruction composée
{
int a=1;
printf("\%d \%d",++a,a);
}
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 57
LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ L'opérateur conditionnel ternaire
• L'opérateur conditionnel ? est un opérateur ternaire. Sa syntaxe est la suivante :
condition ? expression-1 : expression-2

• Cette expression est égale à expression-1 si condition est satisfaite, et à expression-


2 sinon.
• Par exemple, l'expression
x >= 0 ? x : -x

correspond à la valeur absolue d'un nombre.

De même l'instruction
m = ((a > b) ? a : b);

affecte à m le maximum de a et de b.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 58


LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ L'opérateur de conversion de type
L'opérateur de conversion de type, appelé cast, permet de modifier explicitement le type d'un
objet. On écrit
(type) objet
Par exemple,
main()
{
int i = 3, j = 2;
printf("%f \n",(float)i/j);
}
retourne la valeur 1.5.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 59


LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ L'opérateur adresse
L'opérateur d'adresse & appliqué à une variable retourne l'adresse-mémoire de cette variable. La
syntaxe est : &objet

▪ Règles de priorité des opérateurs

Le tableau suivant classe les opérateurs par ordres de priorité décroissants. Les
opérateurs placés sur une même ligne ont même priorité. Si dans une expression figurent
plusieurs opérateurs de même priorité, l'ordre d'évaluation est définie par la flèche de la
seconde colonne du tableau. On préfèrera toutefois mettre des parenthèses en cas de
doute...

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 60


LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ ordre de priorité décroissant

opérateurs
() [] -> .
! ~ ++ -- -
(unaire) (type) *(indirection) &(adresse) sizeof
* / %
+ -(binaire)
<< >>
< <= > >=
== !=
&(et bit-à-bit)
^
|
&&
||
?:
= += -= *= /= %= &= ^= |= <<= >>=
,

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 61


LES COMPOSANTS ÉLÉMENTAIRES DU C
❑ Les opérateurs
▪ ordre de priorité décroissant

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 62


STRUCTURE D’UN PROGRAMME C
❑ Quelques définitions
▪ Une expression est une suite de composants élémentaires syntaxiquement correcte. Par exemple
x = 0

ou bien
(i >= 0) && (i < 10) && (p[i] != 0)

▪ Une instruction est une expression suivie d'un point-virgule. Le point-virgule signifie en quelque
sorte ``évaluer cette expression‘’. Par exemple

x = 0;
▪ Instruction composée ou bloc : Plusieurs instructions peuvent être rassemblées par des
accolades { et }.
if (x != 0)
{
z = y / x;
t = y % x;
}
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 63
STRUCTURE D’UN PROGRAMME C
❑ Quelques définitions
▪ Déclaration : Une instruction composée d'un spécificateur de type et d'une liste d'identificateurs
séparés par une virgule est une déclaration. Par exemple,
int a;
int b = 1, c;
double x = 2.38e4;
char message[80];
Remarque : En C, toute variable doit faire l'objet d'une déclaration avant d'être utilisée

❑ Un programme C se présente de la façon suivante :

[directives au préprocesseur]
[déclarations de variables externes]
[fonctions secondaires]

main()
{déclarations de variables internes
instructions
}
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 64
STRUCTURE D’UN PROGRAMME C
❑ La fonction principale main peut avoir des paramètres formels. On supposera dans un
premier temps que la fonction main n'a pas de valeur de retour. Ceci est toléré par le
compilateur mais produit un message d'avertissement quand on utilise l'option -Wall de gcc

❑ Les fonctions secondaires peuvent être placées indifféremment avant ou après la fonction
principale. Une fonction secondaire peut se décrire de la manière suivante :

type ma_fonction ( arguments )


{déclarations de variables internes
instructions
}

▪ Cette fonction retournera un objet dont le type sera type (à l'aide d'une instruction
comme return objet;).

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 65


REPRESENTATION DES NOMBRES EN MACHINE

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 66


LES TYPES PREDEFINIS DU C

❑ Le C est un langage typé. Cela signifie en particulier que toute variable, constante ou
fonction est d'un type précis. Le type d'un objet définit la façon dont il est représenté en
mémoire.

❑ La mémoire de l'ordinateur se décompose en une suite continue d'octets. Chaque octet de


la mémoire est caractérisé par son adresse, qui est un entier. Deux octets contigus en
mémoire ont des adresses qui diffèrent d'une unité. Quand une variable est définie, il lui est
attribué une adresse. Cette variable correspondra à une zone mémoire dont la longueur (le
nombre d'octets) est fixée par le type.

❑ La taille mémoire correspondant aux différents types dépend des compilateurs ; toutefois,
la norme ANSI spécifie un certain nombre de contraintes.

❑ Les types de base en C concernent les caractères, les entiers et les flottants (nombres
réels). Ils sont désignés par les mots-clefs suivants :

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 67


LES TYPES PREDEFINIS DU C

❑ Produire une figure

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 68


LES TYPES PREDEFINIS DU C
❑ Le type caractère
▪ Le mot-clef char désigne un objet de type caractère. Un char peut contenir n'importe quel
élément du jeu de caractères de la machine utilisée. La plupart du temps, un objet de
type char est codé sur un octet ; c'est l'objet le plus élémentaire en C. Le jeu de caractères
utilisé correspond généralement au codage ASCII

▪ Une des particularités du type char en C est qu'il peut être assimilé à un entier : tout objet de
type char peut être utilisé dans une expression qui utilise des objets de type entier. Par
exemple, si c est de type char, l'expression c + 1 est valide. Elle désigne le caractère
suivant dans le code ASCII.

Ainsi, le programme suivant imprime le caractère 'B’.


main()
{
char c = 'A';
printf("%c", c + 1);
}
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 69
LES TYPES PREDEFINIS DU C
❑ Le type entier
▪ Le mot-clef désignant le type entier est int. Un objet de type int est représenté par un mot
``naturel'' de la machine utilisée, 32 bits pour un DEC alpha ou un PC Intel.
▪ Le type int peut être précédé d'un attribut de précision (short ou long) et/ou d'un attribut de
représentation (unsigned).
▪ Un objet de type short int a au moins la taille d'un char et au plus la taille d'un int. En
général, un short int est codé sur 16 bits.
▪ Un objet de type long int a au moins la taille d'un int (64 bits sur un DEC alpha, 32 bits sur
un PC Intel).
DEC Alpha PC Intel (Linux)
char 8 bits 8 bits caractère
short 16 bits 16 bits entier court
int 32 bits 32 bits entier
long 64 bits 32 bits entier long
long entier long
n.i. 64 bits
long (non ANSI)

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 70


LES TYPES PREDEFINIS DU C
❑ Le type entier

▪ Le bit de poids fort d'un entier est son signe.


▪ Un entier positif est donc représenté en mémoire par la suite de 32 bits dont le bit de poids
fort vaut 0 et les 31 autres bits correspondent à la décomposition de l'entier en base 2

Par exemple, pour des objets de type char (8 bits), l'entier positif 12 sera représenté en
mémoire par 00001100

▪ Un entier négatif est, lui, représenté par une suite de 32 bits dont le bit de poids fort vaut 1
et les 31 autres bits correspondent à la valeur absolue de l'entier représentée suivant la
technique dite du ``complément à 2‘’. Cela signifie que l'on exprime la valeur absolue de
l'entier sous forme binaire, que l'on prend le complémentaire bit-à-bit de cette valeur et que
l'on ajoute 1 au résultat.

Ainsi, pour des objets de type signed char (8 bits), -1 sera représenté par 11111111, -2 par
11111110, -12 par 11110100

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 71


LES TYPES PREDEFINIS DU C
❑ Le type entier
▪ Un int peut donc représenter un entier entre -231 et (231-1).
▪ L'attribut unsigned spécifie que l'entier n'a pas de signe.
▪ Plus généralement, les valeurs maximales et minimales des différents types entiers sont
définies dans la librairie standard limits.h
▪ Le mot-clef sizeof a pour syntaxe
sizeof(expression)
où expression est un type ou un objet. Le résultat est un entier égal au nombre d'octets
nécessaires pour stocker le type ou l'objet. Par exemple unsigned short x;

taille = sizeof(unsigned short);


taille = sizeof(x);
Dans les deux cas, taille vaudra 4.

REMARQUE : Pour obtenir des programmes portables, on s'efforcera de ne jamais présumer de


la taille d'un objet de type entier. On utilisera toujours une des constantes de limits.h ou le
résultat obtenu en appliquant l'opérateur sizeof.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 72


LES TYPES PREDEFINIS DU C
❑ Les types flottants
▪ Les types float, double et long double servent à représenter des nombres en virgule
flottante. Ils correspondent aux différentes précisions possibles.

DEC Alpha PC Intel


float 32 bits 32 bits flottant
double 64 bits 64 bits flottant double précision
long double 64 bits 128 bits flottant quadruple précision
Les types flottants
▪ Les flottants sont généralement stockés en mémoire sous la représentation de la virgule
flottante normalisée. On écrit le nombre sous la forme ``signe 0,mantisse Bexposant''.
En général, B=2. Le digit de poids fort de la mantisse n'est jamais nul.

▪ Un flottant est donc représenté par une suite de bits dont le bit de poids fort correspond au
signe du nombre. Le champ du milieu correspond à la représentation binaire de l'exposant
alors que les bits de poids faible servent à représenter la mantisse.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 73


LES TYPES PREDEFINIS DU C
❑ Les constantes

▪ Une constante est une valeur qui apparaît littéralement dans le code source d'un programme, le
type de la constante étant déterminé par la façon dont la constante est écrite. Les constantes
peuvent être de 4 types : entier, flottant (nombre réel), caractère, énumération. Ces constantes vont
être utilisées, par exemple, pour initialiser une variable.

• Les constantes entières

constante type

1234 int
02322 int /* octal */
0x4D2 int /* hexadécimal */
123456789L long
1234U unsigned int
123456789UL unsigned long int

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 74


LES TYPES PREDEFINIS DU C
❑ Les constantes
• Les constantes réelles
constante type

12.34 double
12.3e-4 double
12.34F float
12.34L long double
• Les constantes caractères
\n nouvelle ligne \r retour chariot
tabulation
\t \f saut de page
horizontale
\v tabulation verticale\a signal d'alerte
\b retour arrière

Les constantes chaînes de caractères

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 75


LES TYPES PREDEFINIS DU C
❑ Les constantes
▪ Les constantes chaînes de caractères

• Une chaîne de caractères est une suite de caractères entourés par des guillemets. Par
exemple,
"Ceci est une chaîne de caractères"
• Une chaîne de caractères peut contenir des caractères non imprimables, désignés par les
représentations vues précédemment. Par exemple,
"ligne 1 \n ligne 2"

• A l'intérieur d'une chaîne de caractères, le caractère " doit être désigné par \".

• Enfin, le caractère \ suivi d'un passage à la ligne est ignoré. Cela permet de faire tenir de longues
chaînes de caractères sur plusieurs lignes. Par exemple,
"ceci est une longue longue longue longue longue longue longue longue \
chaîne de caractères"

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 76


Les instructions de contrôle en C

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 77


Les instructions de contrôle
❑ On appelle instruction de contrôle toute instruction qui permet de contrôler le
fonctionnement d'un programme.
❑ Le langage C dispose d’instructions de contrôle permettant de réaliser :

▪ des choix : L’instruction conditionnelle if…else…

L’instruction d’aiguillage ou de choix switch…case…default…

▪ des boucles les instruction répétitives :


+ while…do…
+ do…while…
+ for…

▪ des branchements Les instructions de branchement inconditionnel


+ goto
+ break ( associé aux boucles)
+ continue ( associé aux boucles)
+ return

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 78


Les instructions de contrôle de choix
❑ L’instruction conditionnelle if…else
▪ L’instruction conditionnelle permet de tester une condition puis d'exécuter une action parmi deux
actions possibles.
Syntaxe:
if ( expression) instructions1;
[ else instructions2 ; ]

▪ Instructions1 et instructions2 sont des instructions quelconques qui peuvent être soit une
instruction soit un bloc d’instructions placées entre { et }.
▪ Si l’expression a une valeur vraie alors instructions1 est exécutée sinon instructions2 est
exécutée.

Exemple1 Exemple 2

Int a,b ; Int a,b ;


… …
if ( a<b ) max = b ; if (( a < = b ) && ( b<= c)) printf( “ordonne”);
else max = a ;

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 79


Les instructions de contrôle de choix
❑ Cas imbrications des instructions if…else
▪ Règle à appliquer: Le premier else rencontré est associé avec le plus proche if qui le précède:

▪ 1ère forme d’imbrication :

if (a <= b) if ( b<= c) { printf( “ ordonnée” ); max = c; }


else printf( “ non ordonnée” );

dans cet exemple, dans le cas où l’expression ( a<=b ) est fausse, rien n’est affiché .

▪ 2ème forme d’imbrication :

if (heure >= 0) && ( heure < 12) printf( “ bonjour” );


else if ((heure >= 12) && ( heure < 18)) printf( “ bon pares midi” );
else if ((heure >= 18) && ( heure < 24 )) printf (“ bonsoir” );
else printf( “ erreur” );

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 80


Les instructions de contrôle de choix

❑ L’instruction switch:

▪ L’instruction switch est une instruction de choix multiple. Elle permet d’évaluer une expression
puis d'exécuter une action parmi plusieurs actions étiquetées. Si la valeur de l’expression
correspond à une des étiquettes, l’action correspondante est exécutée .

▪ Si la valeur de expression est égale à l'une des constantes, la liste


d'instructions correspondant est exécutée. Sinon la liste
d'instructions  correspondant à default est exécutée. L'instruction default est
facultative

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 81


Les instructions de contrôle de choix
❑ L’instruction switch
▪ Syntaxe
switch (expression )
{case constante-1:
liste d'instructions 1
break;
case constante-2:
liste d'instructions 2
break;
...
case constante-n:
liste d'instructions n
break;
default:
liste d'instructions 
break;
}

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 82


Les instructions de contrôle de choix
❑ L’instruction switch
▪ Exemples

Exemple1: Exemple2: cas où plusieurs “case” font référence à la


Char c; même action.

switch ( c) switch ( c = getchar() )
{ {
case ‘a’ : printf( “ lettre a” ); break; case ‘a’ :
case ‘o’ :
case ‘b’ : printf ( “ lettre b” ); break; case ‘i’ :
case ‘e’ :
default : printf ( “ lettre inconnue” case ‘u’ :
); case ‘y’ : printf ( " c’est une voyelle " ) ;
} break ;
}

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 83


Les instructions de contrôle de choix
❑ L’instruction switch
▪ Exemples
Exemple3 : cas de plusieurs “switch " imbriqués :

int err;
char code ;

switch ( err)
{
case 1 : printf( " erreur grave" ) ;
switch ( code)
{
case ‘0’ : printf ( “ à l’ open " ) ; break ;
case ‘e’ : printf ( “ à l’ écriture " ) ; break ;
default : printf ( “ inconnue " ) ; break ;
} break ;
case 2 : printf( " erreur simple" ) ; break ;
default : printf( " erreur inconnue" ) ; break ;
}.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 84


Les instructions de contrôle répétitives

❑ L’instruction do…while…
▪ Elle permet de répéter une ou plusieurs actions tant que la condition spécifiée n’est pas vérifiée.
▪ Syntaxe :

do instructions while ( expression) ;

▪ Instructions peut être soit une seule instruction suivie de ; soit un bloc d’instructions entre { et }.

▪ L’expression est évaluée après avoir exécutée au moins une fois instructions. Si la valeur de
l’expression est non nulle ( vraie), cette exécution est répétée sinon l’itération se termine.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 85


Les instructions de contrôle répétitives

❑ L’instruction do…while…
▪ Exemple
Exemple 1:
do x -- ;
while x > 0

Exemple2 :
do c = getchar() ;
while ( c != ‘\n’ )

peut être écrite : do {}


while ( c = getchar() , c != ‘n’ )

▪ Remarque :
• l’instruction à répéter peut être vide , après le “do” on peut mettre soit le point virgule soit { et }.
• L’expression du “while” peut une expression avec un opérateur séquentiel et dont la dernière sous-
expression est évaluée à vrai ou faux.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 86


Les instructions de contrôle répétitives

❑ L’instruction while
▪ Tant qu’une condition spécifiée n’est pas vérifiée, elle permet de répéter une ou plusieurs
actions.

▪ Syntaxe :
while ( expression ) instructions

▪ Instructions peut être soit une seule instruction soit un bloc d’instructions entre { et } .

▪ L’expression est évaluée avant d'exécuter instructions. Tant que la valeur de l’expression est
non nulle ( vraie), instructions est exécutée, sinon l’itération se termine.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 87


Les instructions de contrôle répétitives

❑ L’instruction while
Exemple 1:

while( x >0 ) Exemple3:


x --; while ( printf( “ donnez un nombre ”) ,
Ou bien scanf( “ %d”, &n) , somme<=100 )
somme += n;
while ( x--,x>0) ;

Est équivalente à : do x -- ;
While ( x > 0) ;

Exemple2 :

while ( c = getchar(),c != ‘\n’ ) {}

peut être écrite : do {}


while ( c = getchar() , c != ‘n’ )

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 88


Les instructions de contrôle répétitives
❑ L’instruction for :
▪ L’instruction for est une instruction de boucle faisant intervenir l’initialisation, le test de limite et
l’incrémentation en une seule action.

▪ Syntaxe:
for ( [expr1] ; [expr2] ; [expr3] )
Instructions;

▪ “ instructions” peut être une instruction composée, et sera dans ce cas délimitée par { et }.
▪ “ expr1” est une expression ( une initialisation) qui ne sera exécutée qu’une seule fois au début.
▪ “expr2” est une expression dont le résultat détermine la fin de la boucle. Tant que sa valeur est non
nulle ( vraie), la boucle continue.
▪ “ expr3” est une expression ( en général) qui sera exécutée à chaque itération.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 89


Les instructions de contrôle répétitives
❑ L’instruction for :

Exemple:
for ( I=0; I<10; I++)
{ …..
if ( table[ I ] == ‘A’)
…….
}

▪ chacune des 3 expressions est facultative.

for ( ; I<10; I++) /* pas d’initialisation

for ( I=0; k>1; ) /* pas de progression

for ( ; ; ) /* boucle infinie

▪ Lorsque l’expression 2 est absente, elle est considérée vraie.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 90


Les instructions de contrôle répétitives
❑ L’instruction for :

▪ Il est possible de regrouper plusieurs actions dans une expression.

#define EOL ‘\n’


char text[80];
int i;
for ( i=0; text[ i ] = getchac() != EOL; text[i] = toupper (text[ i ]) , i++ );

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 91


Les instructions de branchements conditionnels

❑ L’instruction break:
▪ Elle peut être utilisée dans les boucles ou dans une instruction switch. Elle permet d’interrompre le
déroulement de la structure où elle a été appelée.
▪ Dans le cas des boucles ou plusieurs ‘switch ’ imbriqués, l’instruction ‘break’ n’a d’effet que sur la
boucle où elle a été définie.
Exemple: programme qui permet de lire des caractères jusqu ‘à fin de fichier ou fin de ligne.

while ( ( c=getchar()) != EOF )


{ ….
If ( c == ‘\n’ )
break;
….
}

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 92


Les instructions de branchements conditionnels
❑ L’instruction continue:

▪ Elle peut être utilisée dans les boucles .Elle permet de sauter une séquence d’instructions sans sortir
de la boucle.. Dans le cas des boucles imbriquées, l’instruction ‘continue’ n’a d’effet que sur la boucle
où elle a été définie.

Exemple:

for( I=0,k=0; I<10; I++)


{ ….
if( I == 4) continue; /* dès que I=4 , le programme saute la séquence
for qui suit et passe à l’iteration suivante I= I+ 1
for ( j=0; j<10; j++)
{ …
if ( j == 7) break;
k += j;
}
}

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 93


Les instructions de branchements conditionnels
❑ L’instruction goto:
Elle permet le branchement inconditionnel vers une instruction spécifiée par une étiquette dans le
programme.

▪ Syntaxe:
goto etiquette;
….

etiquette: …..

▪ Exemple:

while ( ( c=getchar()) != EOF )


{ ….
If ( c == ‘\n’ )
goto fin;
….
};

fin: printf( “ fin de boucle” );

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 94


Les d'entrées-sorties standards

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 95


Les fonctions d’entrées- sorties classiques

❑ Il s'agit des fonctions de la librairie standard stdio.h utilisées avec les unités classiques
d'entrées-sorties, qui sont respectivement le clavier et l'écran.

❑ Sur certains compilateurs, l'appel à la librairie stdio.h par la directive au préprocesseur


#include <stdio.h> n'est pas nécessaire pour utiliser printf et scanf.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 96


Les fonctions d’entrées- sorties classiques
❑ La fonction d'écriture printf

▪ La fonction printf est une fonction d'impression formatée, ce qui signifie que les données sont
converties selon le format particulier choisi. Sa syntaxe est
printf("chaîne de contrôle ",expression-1, ..., expression-n);

▪ La chaîne de contrôle contient le texte à afficher et les spécifications de format


correspondant à chaque expression de la liste. Les spécifications de format ont pour but
d'annoncer le format des données à visualiser. Elles sont introduites par le caractère %, suivi
d'un caractère désignant le format d'impression. Les formats d'impression en C sont donnés à la
table de la page 102

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 97


Les fonctions d’entrées- sorties classiques
❑ La fonction d'écriture printf

En plus du caractère donnant le type des données, on peut éventuellement préciser certains
paramètres du format d'impression, qui sont spécifiés entre le % et le caractère de conversion
dans l'ordre suivant :
• largeur minimale du champ d'impression : %10d spécifie qu'au moins 10 caractères seront
réservés pour imprimer l'entier. Par défaut, la donnée sera cadrée à droite du champ. Le
signe - avant le format signifie que la donnée sera cadrée à gauche du champ (%-10d).
• précision : %.12f signifie qu'un flottant sera imprimé avec 12 chiffres après la virgule. De
même %10.2f signifie que l'on réserve 12 caractères (incluant le caractère .) pour imprimer
le flottant et que 2 d'entre eux sont destinés aux chiffres après la virgule. Lorsque la précision
n'est pas spécifiée, elle correspond par défaut à 6 chiffres après la virgule.
• Pour une chaîne de caractères, la précision correspond au nombre de caractères
imprimés : %30.4s signifie que l'on réserve un champ de 30 caractères pour imprimer la
chaîne mais que seulement les 4 premiers caractères seront imprimés (suivis de 26 blancs).

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 98


Les fonctions d’entrées- sorties classiques
❑ La fonction d'écriture printf
format conversion en écriture
%d int décimale signée
%ld long int décimale signée
%u unsigned int décimale non signée
%lu unsigned long int décimale non signée
%o unsigned int octale non signée
%lo unsigned long int octale non signée
%x unsigned int hexadécimale non signée
%lx unsigned long int hexadécimale non signée
%f double décimale virgule fixe
%lf long double décimale virgule fixe
%e double décimale notation exponentielle
%le long double décimale notation exponentielle
décimale, représentation la plus courte
%g double
parmi %f et %e
décimale, représentation la plus courte
%lg long double
parmi %lf et %le
%c unsigned char caractère
%s char* chaîne de caractères
Formats d'impression pour la fonction printf
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 99
Les fonctions d’entrées- sorties classiques
❑ La fonction d'écriture printf #include <stdio.h>
main()
{
▪ Exemple int i = 23674;
int j = -23674;
long int k = (1l << 32);
double x = 1e-8 + 1000;
char c = 'A';
char *chaine = "chaine de caracteres";

printf("impression de i: \n");
printf("%d \t %u \t %o \t %x",i,i,i,i);
printf("\nimpression de j: \n");
printf("%d \t %u \t %o \t %x",j,j,j,j);
printf("\nimpression de k: \n");
printf("%d \t %o \t %x",k,k,k);
printf("\n%ld \t %lu \t %lo \t %lx",k,k,k,k);
printf("\nimpression de x: \n");
printf("%f \t %e \t %g",x,x,x);
printf("\n%.2f \t %.2e",x,x);
printf("\n%.20f \t %.20e",x,x);
printf("\nimpression de c: \n");
printf("%c \t %d",c,c);
printf("\nimpression de chaine: \n");
printf("%s \t %.10s",chaine,chaine);
printf("\n");
}

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 100


Les fonctions d’entrées- sorties classiques
❑ La fonction d'écriture printf

Ce programme imprime à l'écran :


impression de i:
23674 23674 56172 5c7a
impression de j:
-23674 4294943622 37777721606 ffffa386
impression de k:
0 0 0
4294967296 4294967296 40000000000 100000000
impression de x:
1000.000000 1.000000e+03 1000
1000.00 1.00e+03
1000.00000001000000000000 1.00000000001000000000e+03
impression de c:
A 65
impression de chaine:
chaine de caracteres chaine de

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 101


Les fonctions d’entrées- sorties classiques
❑ La fonction de saisie scanf

▪ La fonction scanf permet de saisir des données au clavier et de les stocker aux adresses
spécifiées par les arguments de la fonctions.
scanf("chaîne de contrôle",argument-1,...,argument-n)
▪ La chaîne de contrôle indique le format dans lequel les données lues sont converties. Elle
ne contient pas d'autres caractères (notamment pas de \n). Comme pour printf, les
conversions de format sont spécifiées par un caractère précédé du signe %. Les formats
valides pour la fonction scanf diffèrent légèrement de ceux de la fonction printf.
▪ Les données à entrer au clavier doivent être séparées par des blancs ou des <RETURN> sauf
s'il s'agit de caractères. On peut toutefois fixer le nombre de caractères de la donnée à lire. Par
exemple %3s pour une chaîne de 3 caractères, %10d pour un entier qui s'étend sur 10 chiffres,
signe inclus
.
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 102
Les fonctions d’entrées- sorties classiques
❑ La fonction de saisie scanf

Exemple :
#include <stdio.h>
main()
{
int i;
printf("entrez un entier sous forme hexadecimale i = ");
scanf("%x",&i);
printf("i = %d\n",i);
}
Si on entre au clavier la valeur 1a, le programme affiche i = 26.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 103


Les fonctions d’entrées- sorties classiques
❑ La fonction de saisie scanf
format type d'objet pointé représentation de la donnée saisie
%d int décimale signée
%hd short int décimale signée
%ld long int décimale signée
%u unsigned int décimale non signée
%hu unsigned short int décimale non signée
%lu unsigned long int décimale non signée
%o int octale
%ho short int octale
%lo long int octale
%x int hexadécimale
%hx short int hexadécimale
%lx long int hexadécimale
%f float flottante virgule fixe
%lf double flottante virgule fixe
%Lf long double flottante virgule fixe
%e float flottante notation exponentielle
%le double flottante notation exponentielle
%Le long double flottante notation exponentielle
%g float flottante virgule fixe ou notation exponentielle
%lg double flottante virgule fixe ou notation exponentielle
%Lg long double flottante virgule fixe ou notation exponentielle
%c char caractère
%s char* chaîne de caractères

Formats de saisie pour la fonction scanf


Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 104
Les fonctions d’entrées- sorties classiques
❑ Impression et lecture de caractères

▪ Les fonctions getchar et putchar permettent respectivement de lire et d'imprimer des


caractères. Il s'agit de fonctions d'entrées-sorties non formatées.

▪ La fonction getchar retourne un int correspondant au caractère lu. Pour mettre le caractère
lu dans une variable caractere, on écrit
caractere = getchar();
▪ Lorsqu'elle détecte la fin de fichier, elle retourne l'entier EOF (End Of File), valeur définie dans
la librairie stdio.h. En général, la constante EOF vaut -1.

▪ La fonction putchar écrit caractere sur la sortie standard :


putchar(caractere);

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 105


Les fonctions d’entrées- sorties classiques
❑ Impression et lecture de caractères
▪ Elle retourne un int correspondant à l'entier lu ou à la constante EOF en cas d'erreur.
Par exemple, le programme suivant lit un fichier et le recopie caractère par caractère à
l'écran.

#include <stdio.h>
main()
{
char c;

while ((c = getchar()) != EOF)


putchar(c);
}

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 106


Les fonctions d’entrées- sorties classiques
❑ Impression et lecture de caractères
▪ Pour l'exécuter, il suffit d'utiliser l'opérateur de redirection d'Unix :
▪ programme-executable < nom-fichier
Notons que l'expression (c = getchar()) dans le programme précédent a pour valeur la
valeur de l'expression getchar() qui est de type int. Le test (c = getchar()) !=
EOF compare donc bien deux objets de type int (signés).
Ce n'est par contre pas le cas dans le programme suivant :
#include <stdio.h>
main()
{
char c;
do
{
c = getchar();
if (c != EOF)
putchar(c);
}
while (c != EOF);
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 107
Les fonctions d’entrées- sorties classiques
❑ Impression et lecture de caractères

▪ Ici, le test c != EOF compare un objet de type char et la constante EOF qui vaut -1. Si le
type char est non signé par défaut, cette condition est donc toujours vérifiée. Si le
type char est signé, alors le caractère de code 255, y, sera converti en l'entier -1. La
rencontre du caractère y sera donc interprétée comme une fin de fichier. Il est donc
recommandé de déclarer de type int (et non char) une variable destinée à recevoir un
caractère lu par getchar afin de permettre la détection de fin de fichier
.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 108


Fonctions et procédures

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 109


Fonctions
❑ Définition
▪ Le code suivant définit une fonction fonction renvoyant une valeur de
type type_retour et prenant N arguments, par1 de type type1, par2 de type type2,
etc.

type_retour fonction(type1 par1, type2 par2, /* ..., */ typeN parN)

{ /* Déclarations de variables ... */ /* Instructions ... */

▪ L'exécution d'une fonction se termine soit lorsque l'accolade fermante est atteinte, soit
lorsque le mot clef return est rencontré. La valeur renvoyée par une fonction est donnée
comme paramètre à return.

▪ Une procédure est une fonction renvoyant void, dans ce cas return est appelé sans
paramètre.
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 110
Fonctions

❑ Déclaration par prototype


▪ Le prototype d'une fonction correspond simplement à son en-tête (tout ce qui précède la
première accolade ouvrante). C'est-à-dire son nom, son type de retour et les types des
différents paramètres. Cela permet au compilateur de vérifier que la fonction est appelée
avec le bon nombre de paramètres et surtout avec les bons types. La ligne suivante déclare
la fonction fonction, mais sans la définir :

type_retour nom fonction(type1, type2, /* ..., */ typeN);

▪ À noter que les noms des paramètres peuvent être omis et que la déclaration doit se
terminer par un point-virgule (;), sans quoi vous pourrez vous attendre à une cascade d'erreurs.
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 111
Fonctions

❑ Évaluation des arguments


La norme du langage ne spécifie pas l'ordre d'évaluation des arguments. Il faut donc faire
particulièrement attention aux effets de bords.
▪ Exemple 1 : Ce code contient une erreur volontaire !

#include <stdio.h> ▪ Lors de l'appel de la fonction somme, si


int somme(int a, int b)
l'expression++i est évaluée avant
{
l'expression i, alors le programme affichera 2.
return a + b;
} Si, au contraire, c'est l'expression i qui est
int main(void) évaluée avant l'expression ++i, alors le
{ programme affichera 1.
int i = 0; printf("%d\n",
somme(++i, i) ); return 0;
}
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 112
Fonctions

❑ Évaluation des arguments

▪ Exemple 2 ▪ Dans cet autre exemple, les


expressions g() et h() pouvant être
#include <stdio.h> int
fonction(int, int); évaluées dans n'importe quel ordre, on ne
int g(void); peut pas savoir laquelle des
int h(void); fonctions g et h sera appelée en premier.
Si l'appel de ces fonctions provoque des
int test(void)
effets de bord (affichage de messages,
{
modification de variables globales...), alors
return fonction(g(), h());
le comportement du programme est
}
imprévisible

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 113


Fonctions

❑ Évaluation des arguments

▪ Exemple 3

#include <stdio.h>
int fonction(int, int); ▪ Pour pallier le problème de l’exemple 2,
int g(void); il faut imposer l'ordre d'appel
int h(void);
int test(void)
{
int a,b;
a = g();
b = h();
return fonction(a, b);
}

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 114


Fonctions

❑ Nombre variable d’arguments


▪ Une fonctionnalité assez utile est d'avoir une fonction avec un nombre variable d'arguments,
comme la fameuse fonction printf(). Pour cela, il suffit de déclarer le prototype de la fonction
de la manière suivante :
#include <stdarg.h>
void ma_fonction(type1 arg1, type2 arg2, ...)
{
▪ Les points
} de suspension sont une notation C pour indiquer que la fonction accepte d'autres
arguments.
▪ L'en-tête <stdarg.h> permet de traiter les arguments à l'intérieur de la fonction.
▪ Une fonction à nombre variable d'arguments contient au moins un paramètre fixe. En effet la
déclaration suivante est invalide : void ma_fonction(...);

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 115


Fonctions

❑ Accès aux arguments


▪ Pour accéder aux arguments situés après le dernier argument fixe, il faut utiliser certaines
fonctions (ou plutôt macros) de l'en-tête <stdarg.h>.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 116


Fonctions
❑ La fonction main
▪ La fonction main est le point d’entrée d’un programme en C. La norme définit deux prototype
qui sont portables :

int main(int argc, char * argv[]) { /* ... */ }


int main(void) { /* ... */ }

▪ Le premier prototype est plus "général" : il permet de récupérer des paramètres au


programme. Le deuxième existe pour des raisons de simplicité, quand on ne veut pas
traiter ces arguments.

▪ Si ces deux prototypes sont portables, une implémentation peut néanmoins définir un autre
prototype pour main, ou spécifier une autre fonction pour le démarrage du programme.
Cependant ces cas sont plus rares (et souvent spécifiques à du C embarqué).

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 117


Fonctions
❑ La fonction main
▪ Paramètres de ligne de commande

La fonction main prend deux paramètres qui permettent d'accéder aux paramètres passés au
programme lors de son appel. Le premier, généralement appelé argc (argument count), est le
nombre de paramètres qui ont été passés au programme. Le second, argv (argument vector),
est la liste de ces paramètres. Les paramètres sont stockés sous forme de chaîne de
caractères, argv est donc un tableau de chaînes de caractères, ou un pointeur sur un
pointeur sur char. argc correspond au nombre d'éléments de ce tableau.
La première chaîne de caractères, dont l'adresse est dans argv[0], contient le nom du
programme. Le premier paramètre est donc argv[1]. Le dernier élément du
tableau, argv[argc], est un pointeur nul.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 118


Fonctions
❑ La fonction main
▪ Valeur de retour
La fonction main retourne toujours une valeur de type entier. L'usage veut qu'on retourne 0
(ou EXIT_SUCCESS) si le programme s'est déroulé correctement, ou EXIT_FAILUREpour
indiquer qu'il y a eu une erreur (Les macros EXIT_SUCCESS et EXIT_FAILURE étant
définies dans l'en-tête <stdlib.h>). Il est possible par le programme appelant de
récupérer ce code de retour, et de l'interpréter comme bon lui semble.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 119


Fonctions
❑ La fonction main
▪ Exemple
Voici un petit programme très simple qui affiche la liste des paramètres passés au
programme lorsqu'il est appelé:
#include <stdio.h>
int main(int argc, char * argv[])
{ int i;
for (i = 0; i < argc; i++)
printf("paramètre %i : %s\n", i, argv[i]);
return 0;
}

On effectue une boucle sur argv à l'aide de argc. Enregistrez-le sous le nom params.c puis
compilez-le (cc params.c -o params). Vous pouvez ensuite l'appeler ainsi:
./params hello world ! # sous Unix
params.exe hello world ! # sous MS-DOS ou Windows

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 120


Fonctions
❑ La fonction main
▪ Exemple

Vous devriez voir en sortie quelque chose comme ceci (paramètre 0 varie selon le système
d'exploitation):

paramètre 0 : ./params
paramètre 1 : hello
paramètre 2 : world
paramètre 3 : !

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 121


VISIBILITE DES DONNEES
❑ Une variable est associée à un type particulier mais, on peut lui associer une
classification qui est un attribut aussi important que le type. Cette classification détermine
l'emplacement mémoire où la variable sera stockée. La classification concerne aussi les
fonctions.
❑ Selon l'emplacement de la définition d'une variable, celle-ci est soit variable globale ou
variable locale

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 122


VISIBILITE DES DONNEES
❑ Une variable globale est connue donc utilisable dans n'importe quelle partie du fichier
où elle est définie en particulier à l'intérieur de n'importe quelle fonction du module. Cette portée
peut même s'étendre à d'autres modules du programme, si le programme est constitué de
plusieurs fichiers.

❑ Une variable locale est définie à l'intérieur d'une fonction et au début d'un bloc (c'est le seul
endroit où il est permis de définir des variables locales). Une variable locale n’est connue
qu'à l'intérieur du bloc dans lequel elle est définie.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 123


VISIBILITE DES DONNEES
❑ Exemple :

int g; g est une variable globale

main() {

int i; i est une variable locale


static int k; k est une variable globale privée
..
}

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 124


VISIBILITE DES DONNEES
❑ On retiendra que :
▪ Les variables globales sont statiques c'est-à-dire qu'elles sont permanentes. Elles
existent toute la durée de l'exécution du programme. Au démarrage du programme, le
système alloue l'espace nécessaire et effectue les initialisations. Tout cet espace sera
rendu au système lors de la terminaison du programme.

▪ Les variables locales et les arguments formels des fonctions sont automatiques.
L'espace nécessaire est alloué lors de l'activation de la fonction ou du bloc
correspondant. Il est restitué au système à la fin du bloc ou de la fonction.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 125


VISIBILITE DES DONNEES

❑ Variables globales privées et publiques

▪ Dans cette section, on s'intéresse aux programmes constitués de plusieurs modules. Toutes les
variables globales sont publiques c'est-à-dire qu'elles peuvent (moyennant une déclaration
spécifique) être utilisées dans les autres modules (fichiers C).

▪ On peut interdire cette facilité en donnant à ces variables le qualificateur static. On dit alors
qu'il s'agit d'une variable globale privée.

▪ Le qualificateur extern placé devant la déclaration d'une variable ou d'une fonction


informe que celui-ci sera défini plus loin dans le même module ou dans un autre module.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 126


VISIBILITE DES DONNEES
❑ Fonctions privées et publiques
▪ Comme pour les variables globales, les fonctions peuvent être privées ou publiques. Une fonction
privée ne peut être appelée que par des fonctions qui figurent dans le même module. Par contre,
une fonction publique peut être appelée par n'importe quelle fonction d’un module du programme.

▪ Toutes les fonctions sont publiques c'est-à-dire qu'elles peuvent (moyennant une déclaration
spécifique, voir plus loin) être utilisées dans les autres modules.

▪ On peut interdire cette facilité en donnant à ces fonctions l’état static. On dit alors qu'il s'agit
d'une fonction privée.

▪ Le qualificateur extern placé devant la déclaration d'une fonction informe que celle-ci sera
définie plus loin dans le même module ou dans un autre module.

▪ A chaque fonction, il ne peut y avoir qu'une seule définition. Par contre, il peut y avoir
plusieurs déclarations dans le même module ou dans d'autres modules.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 127


POINTEURS

❑ Un pointeur est une variable qui contient l'adresse d'une autre variable. L'opérateur
unaire & donne l'adresse mémoire d'un objet.

▪ L'instruction : p = &c; affecte l'adresse de c à la variable p.


On dit que p pointe sur c.

▪ L'opérateur unaire & s'applique uniquement sur des objets en mémoire.

En particulier, il ne peut pas s'appliquer sur des constantes ou même à des


variables déclarées comme register (registres du processeur).

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 128


POINTEURS

❑ L'opérateur unaire * représente l'opérateur d'indirection ou de déréférence. Appliqué à un


pointeur, il donne accès à l'objet pointé par ce pointeur.

int x = 1, y = 2, z[10];
int *pi; pi pointeur sur un int
pi = &x; pi pointe sur x
y = *pi; y est affecté à la valeur de l'objet pointé par pi i.e. x
*pi = 0; x vaut 0
pi = &z[0]; pi pointe sur le premier élément du tableau z

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 129


POINTEURS
❑ Pointeurs et tableaux

▪ Les pointeurs et les tableaux sont conceptuellement similaires en C. Soient tab un tableau de int
de 10 éléments et pint un pointeur vers un int.

▪ L'affectation : pint = &tab[0]; ou pint = tab;

fait en sorte que tab et pint pointe tous deux sur le même élément (le premier élément du tableau).
Si pint pointe sur le ième élément du tableau, alors *(pint + 1) désigne respectivement sur le (i
+1)ème élément du tableau.

▪ La correspondance entre pint et tab est si étroite que l'on pourra écrire tab[i] ou *(pint+i).
De même, &tab[i] ou pint+i sont équivalents.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 130


POINTEURS
❑ Pointeurs et tableaux

▪ Les pointeurs et les tableaux sont conceptuellement similaires en C. Soient tab un tableau de int
de 10 éléments et pint un pointeur vers un int.

▪ L'affectation : pint = &tab[0]; ou pint = tab;

fait en sorte que tab et pint pointe tous deux sur le même élément (le premier élément du tableau).
Si pint pointe sur le ième élément du tableau, alors *(pint + 1) désigne respectivement sur le (i
+1)ème élément du tableau.

▪ La correspondance entre pint et tab est si étroite que l'on pourra écrire tab[i] ou *(pint+i).
De même, &tab[i] ou pint+i sont équivalents.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 131


POINTEURS

❑ Le type void

▪ Le type void se comporte comme un type fondamental:


- Il sert à préciser qu'une fonction ne renvoie aucune valeur (procédure).
- Il peut être utilisé comme type de base pour des pointeurs sur des objets de type inconnu (pointeur
universel ).
void f();
void * pv;

▪ Cette facilité doit être utilisée pour se servir des fonctions génériques qui rendent des
pointeurs vers n'importe quel type d'objets (exemple : fonction malloc).

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 132


POINTEURS

❑ Le type void
Exemple :

void * malloc(unsigned taille);


void free(void *);

void une_fonction() {

}
int *pi;
char *pc;
pi = (int *) malloc(10*sizeof(int)); Noter la conversion explicite
pc = (char *) malloc(10*sizeof(char));
...
free(pi);
free(pc);

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 133


GESTION DES ENTREES ET SORTIES

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 134


LES ENTREES SORTIES HAUT NIVEAU FORMATEES

❑ Les E/S formatés. Les E/S haut niveau

▪ Les E/S sont un point crucial dans le langage C. N’étant pas intégrés au langage comme
avec le Pascal (avec writeln et readln), les appels d’E/S ont longtemps dépendu du type de
compilateur C ; ce qui a conduit à des problèmes de portabilité des programmes C. L’arrivée
de l’extension C-ANSI a permis de corriger ce défaut (du moins théoriquement…).

▪ Un fichier est constitué d'une suite de données non structuré (stream) et est vu par un
programme C comme un flot/flux i.e. une suite d'octets structurés ou non qui, selon le cas,
constitue soit un fichier texte ou un fichier binaire ou encore les données provenant d’un
périphérique matériel. On peut alors comparer un fichier C à un tableau d'octets.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 135


LES ENTREES SORTIES HAUT NIVEAU FORMATEES
❑ Les E/S formatés. Les E/S haut niveau
▪ Un fichier texte est un fichier structuré en suite de lignes et exploitable par divers programmes
(éditeur de texte, logiciel d'impression ...)
▪ Un fichier binaire n'a aucune structure et est inexploitable par des programmes externes qui
ignorent la structure réelle du fichier.

▪ Remarque
Il est à noter que sous UNIX : « Tout est fichier (et tout est processus) ».
Un périphérique est repéré par un point d’entrée dans le système de fichiers (path) si
bien que : Lire et écrire sur un périphérique sous UNIX revient à lire et à écrire dans un
Fichier. Il en est aussi de même pour la programmation socket en mode TCP !

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 136


LES ENTREES SORTIES HAUT NIVEAU FORMATEES
❑ Les E/S formatés. Les E/S haut niveau
▪ Remarque
Les périphériques sont représentés traditionnellement par une entrée dans le répertoire
/dev sous UNIX :
Exemple :
Liaison série : /dev/ttya sous Solaris /dev/ttyS0 sous Linux (port COM1 du PC).

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 137


LES ENTREES SORTIES HAUT NIVEAU FORMATEES

❑ Le tampon d'entrée sortie des appels d'E/S formatés

▪ Quelle que soit l'opération que l'on veuille effectuer sur un fichier (lecture ou écriture)d’un
disque dur, les données transitent par un buffer de la bibliothèque d’E/S (libc) et ensuite par
une zone mémoire temporaire appelé tampon (buffer cache du noyau sous UNIX) avant
d'être définitivement rangées dans le fichier.

▪ Le programmeur n'a pas à se soucier de la gestion de ce tampon : c'est le système


d’exploitation qui en a la responsabilité.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 138


LES ENTREES SORTIES HAUT NIVEAU FORMATEES

❑ Le tampon d'entrée sortie des appels d'E/S formatés

▪ L'utilisation par l’intermédiaire d'un tampon permet d'optimiser le fonctionnement des E/S et
notamment sur disque puisque l'écriture ou la lecture dans un tampon de taille N octets
(qui réside en mémoire) est bien plus rapide que la même opération sur le fichier directement
sous la forme de N lectures/écritures d’un octet.
On minimise ainsi les mouvements de la tête d’écriture d’un disque dur…

▪ L’inconvénient est que l’on ne contrôle plus le moment de lecture/écriture dans le fichier qui
est à la charge du système d’exploitation, ce qui est gênant pour l’accès à des périphériques
matériels comme une liaison série.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 139


LES ENTREES /SORTIES BAS NIVEAU FORMATEES

❑ Le tampon d'entrée sortie des appels d'E/S formatés

▪ On utilisera alors les appels d’E/S bas niveau non bufferisés pour l’accès à un périphérique
matériel (pas de buffer libc et éventuellement pas de tampon noyau)…
▪ On utilisera alors les appels d’E/S de haut niveau formatées et bufferisés (buffer libc et tampon
du noyau) pour l’accès à un fichier sur disque (bien que les appels d’E/S bas niveau non
bufferisés (pas de buffer libc et tampon noyau) soient aussi utilisables…)

▪ Le passage par un tampon, s'il accélère les opérations d’E/S introduit un problème de décalage
dans la chronologie, puisque l'opération effective de lecture ou d'écriture dans le fichier n'est pas
prédictible par le programmeur. Il en découle qu'une interruption brutale d'un programme (ou du
système) peut conduire à des pertes d'informations dans les fichiers.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 140


LES ENTREES /SORTIES BAS NIVEAU FORMATEES
❑ Fonctions générales sur les flots

▪ Les flots sont désignés par des variables de type FILE * (pointeur sur une structure de type
FILE).

▪ Le type FILE est défini dans le fichier d'interface stdio.h.

▪ Pour utiliser un fichier dans un programme C, il faut donc inclure le fichier stdio.h
et définir une variable par fichier :

#include <stdio.h>
FILE *fd1, *fd2;
...

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 141


LES ENTREES/SORTIES BAS NIVEAU FORMATES

❑ fopen
▪ Avant qu'un programme puisse utiliser un fichier, il faut ouvrir ce fichier. L'ouverture
du fichier initialise tous les champs du descripteur évoqué plus haut. C'est la fonction :

FILE *fopen(char *nom, char *mode_d_accès);

qui est utilisée pour ouvrir un fichier.


Cette fonction retourne un pointeur vers une structure de type FILE qui sera utilisée
pour les opérations d’E/S par la suite.
• Le paramètre nom est une chaîne de caractères qui désigne le nom du fichier.
• Le paramètre mode_d_accès est une également une chaîne de caractères qui spécifie
le type d'opération que l'on veut effectuer sur ce fichier,
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 142
LES ENTREES/SORTIES BAS NIVEAU FORMATES

❑ fopen
▪ Le type d'opération à effectuer sur le fichier peut être :

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 143


LES ENTREES/SORTIES BAS NIVEAU FORMATES
❑ fopen
▪ Lorsqu'il y a une erreur, le programme ne s'arrête pas (pour arrêter le programme, il faut
utiliser l’appel exit(int cause) ).
▪ La fonction/appel renvoie la valeur NULL (qui vaut 0). C'est au programmeur de tester
cette valeur chaque fois qu'il appelle cette fonction.

Bien programmer, c’est toujours tester le code de retour de tous les appels système ! ! !

#include <stdio.h>
main() {
FILE *fd;
fd = fopen("toto.c", "r");
if (fd == NULL) {
printf("Erreur d'ouverture du fichier %s", "toto.c");
exit(0);
}
. . .
}
Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 144
LES ENTREES/SORTIES BAS NIVEAU FORMATES
❑ fopen
▪ Ou plus concis à la sauce UNIX :

#include <stdio.h>
main() {
FILE *fd;

if ((fd = fopen("toto.c", "r")) == NULL) {


printf("Erreur d'ouverture du fichier %s", "toto.c");
exit(0);
}
. . .

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 145


LES ENTREES/SORTIES BAS NIVEAU FORMATES

❑ Fclose
▪ Même si le système se charge de fermer tous les fichiers ouverts à la fin de l'exécution d'un
programme, il est vivement conseillé de fermer les fichiers dès qu'ils ne sont plus utilisés
notamment pour réduire le nombre de descripteurs ouverts et se prémunir contre toute
interruption brutale du programme.

C'est la fonction : int fclose(FILE *flot); qui est utilisée pour fermer un fichier.

▪ Le paramètre flot (stream) est un pointeur vers une structure de type FILE qui est la valeur
retournée par un appel à la fonction fopen.
▪ La fonction fclose retourne EOF (End Of File) si la fermeture du fichier s'est mal
passée. Sinon, c'est la valeur 0 qui est retournée.

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 146


LES ENTREES/SORTIES BAS NIVEAU FORMATES

❑ fflush

Cette fonction provoque l'écriture physique immédiate du tampon à la demande du programmeur


et non lorsque le système le décide. Elle retourne EOF en cas d'erreur et 0 dans les autres cas.

int fflush( FILE *flot);

❑ feof

La fonction feof teste l'indicateur de fin de fichier du flot spécifié par le paramètre flot et retourne
une valeur non nulle.

int feof(FILE * flot);

Dr Beman H. KAMAGATE, Enseignant-Chercheur à ESATIC 147