Langage C - Pages de Michel Deloizy - Free

LICENCE SPI - EEA
Langage C
Éléments de Cours
M. Deloizy Édition du 5 février 2009
http://michel.deloizy.free.fr

LICENCE SPI-EEA LANGAGE C M. Deloizy
INTRODUCTION
Le langage C est un langage structuré conçu pour obtenir un haut niveau dřoptimisation en produisant une taille de code
réduite et une grande rapidité dřexécution.
Son écriture peut sembler quelque peu hermétique au programmeur non initié ; elle permet cependant une écriture
efficace de programmes, le langage définissant très peu de mots clés et autorisant largement les omissions
(réglementées) et les contractions. Ceci constitue parfois une difficulté qui nécessite une bonne connaissance du langage
et une grande rigueur lors de la transcription de programmes.
Pour permettre au compilateur dřobtenir une bonne efficacité, le niveau de protection du langage est très faible (on
pourra fréquemment « planter » la machine). Par ailleurs, il permet de disposer des ressources avancées du système
comme les écrans, les claviers, les disques et autres périphériques ; Il permet également en standard dřaccéder aux
ressources proches du matériel (par exemple la mémoire) ce qui rend le langage C « universel » et explique sa fréquente
utilisation dans de nombreux domaines.
Une autre caractéristique très intéressante du langage C est quřil offre des mécanismes assurant une bonne portabilité, à
condition que le programmeur veuille bien se plier à lřécriture des programmes « dans les règles de lřArt ».
I. Constitution d’un programme C
DESCRIPTION DU LANGAGE
I.1. Généralités
Un programme C est un ensemble constitué de modules, eux-mêmes composés de fonctions.
Pour le programmeur, un module est en réalité un fichier texte (dřextension « .c ») que lřon saisit avec un éditeur de
textes ; il sřagit du fichier source codé en ASCII dans la machine.
Les fonctions décrivent les actions à réaliser dans le programme. Elles peuvent appeler dřautres fonctions qui ellesmêmes
peuvent en appeler dřautres, etc.
En C, une fonction particulière permet le démarrage du programme : elle se nomme main(), ce qui signifie
« principale ». Lorsque lřon exécute un programme C sur une machine, tout se passe comme si le système
dřexploitation de lřordinateur appelait cette fonction (le système dřexploitation étant alors vu comme étant, pour la
fonction main, une fonction de niveau supérieur).
I.2. Syntaxe
I.2.a. Commentaires.
En C, les commentaires sont encadrés par les séquences de caractères /* et */. Ils ne peuvent pas être
imbriqués (pas de commentaires en commentaire). Les commentaires peuvent occuper plusieurs lignes.
Toute information notée en commentaire sera ignorée par le compilateur.
Aujourd'hui, certains compilateurs reconnaissent la séquence // comme étant le début d'un commentaire
occupant le reste de la ligne (héritage du C++). Ceci n'est malheureusement pas le cas de tous les
compilateurs et devra être évité dans un souci de portabilité.
I.2.b. Noms de symboles.
Les symboles sont composés d'un ensemble de lettres, de chiffres et du caractère '_'. Le premier caractère
ne pouvant être un chiffre.
Les caractères accentués ne sont pas acceptés.
I.2.c. Minuscules et majuscules.
Les minuscules et majuscules sont différenciés en C (Toto est différent de toto). En règle générale, on
évitera d'utiliser des noms de symboles se différenciant uniquement par la présence de minuscules et/ou
majuscules, ceci étant source de confusion et d'erreurs.
-2-

LICENCE SPI-EEA LANGAGE C M. Deloizy
I.3. Mots clés
Le langage C utilise un nombre très restreint de mots réservés. Ces mots qui ne doivent pas être utilisés comme noms de
symboles sont les suivants :
auto break case char const continue default do
double else enum extern float for goto if
int long register return short signed sizeof static
struct switch typedef union unsigned void volatile while
II. Types de variables
Le langage C propose un jeu de types de données assez complet tout en offrant des outils permettant de sřaffranchir de
lřimplémentation.
II.1. Les types de base
II.1.a. char :
II.1.b. int :
est le type de données le plus petit. Il permet de manipuler des caractères et est souvent composé de
8 bits. Il est signé par défaut. Il peut être vu comme étant un entier très court. Cřest le type de données de
taille élémentaire.
est un entier. Cřest le type de données qui pris par défaut par le langage (quand le type de donnée nřest
pas précisé). Il est en général constitué du nombre de bits correspondant au processeur sur lequel est
exécuté le programme. En principe, le type int est composé dřau moins 16 bits. Il est signé par défaut.
II.1.c. float :
est un nombre codé en virgule flottante, permettant dřobtenir une grande dynamique. Il est adapté aux
calculs scientifiques et ne convient pas pour les énumérations (à cause de sa précision limitée).
II.2. Les types dérivés
II.2.a. unsigned char :
est un caractère non signé, permettant de manipuler uniquement des entiers (très courts) positifs.
II.2.b. signed char :
est un caractère signé. char étant signé par défaut, signed peut être utile dans certains environnements qui
prennent le type char comme non signé.
II.2.c. unsigned int ou unsigned :
est un entier non signé.
II.2.d. short :
est un entier signé qui peut être plus petit que int (souvent 16 bits).
II.2.e. unsigned short :
est un short non signé.
II.2.f. long int ou long :
est un entier signé à grande précision ; il est composé dřun nombre de bits supérieur ou égal à celui de int.
II.2.g. unsigned long int ou unsigned long :
est un long int non signé.
II.2.h. double :
correspond à un long float. Il contient un nombre à virgule flottante dont le nombre de chiffres
significatifs et la dynamique sont supérieurs ou égaux à float.
-3-

LICENCE SPI-EEA LANGAGE C M. Deloizy
II.2.i. long double :
contient un nombre à virgule flottante dont le nombre de chiffres significatifs et la dynamique sont
supérieurs ou égaux à double.
II.2.j. Dynamique des nombres :
A titre indicatif, la dynamique des nombres est indiquée dans les tableaux ci-dessous :
ENTIERS Valeur minimale Valeur maximale
8 bits signé -128 127
8 bits non signé 0 255
16 bits signé -32768 32767
16 bits non signé 0 65535
32 bits signé -2 147 483 648 2 147 483 647
32 bits non signé 0 4 294 967 295
VIRGULE FLOTTANTE Chiffres significatifs Exposant min/max
4 octets 7 38
8 octets 15 308
10 octets 19 4932
Remarques :
Le langage C ne définit pas un nombre de bits (donc une précision) correspondant à chaque type de données. Celui-ci
dépend donc du matériel sur lequel sera exécuté le programme, et surtout du compilateur utilisé. Il existe simplement
une recommandation concernant la taille des entiers (int) qui devront être codés sur au moins 16 bits.
La seule certitude concerne le classement des encombrements (notés E) :
E(char) E(short) E(int) E(long)
E(float) E(double) E(long double)
Lors dřopérations sur des entiers, le type int sera automatiquement utilisé par le compilateur (sauf si un terme long int
apparaît dans lřexpression). Cřest le cas également lors de la transmission de paramètres entiers à une fonction.
Lors dřopérations sur des nombres à virgule flottante, le type double sera utilisé par le compilateur ; Le type float sera
donc réservé au rangement de données en grande quantité.
Lřopérateur sizeof permet de connaître la taille dřune donnée, exprimée en nombre de données de taille élémentaire
(sizeof(char) vaut 1). En général, puisque le type char est souvent codé sur un octet, sizeof donne la taille des données
en octets.
Il nřexiste pas en C de type booléen. Le type entier (int) sera utilisé lors de lřévaluation dřune expression logique. Une
expression sera dite « vraie » si elle est non nulle ; Elle sera « fausse » si elle est nulle.
II.3. Les types composés
Les types de données énoncés précédemment permettent de constituer des données plus complexes :
II.3.a. les tableaux :
Ils sont constitués dřun ensembles de données de même type, placées de manière contiguë en mémoire.
II.3.b. les structures :
Elles sont constituées dřun ensemble de types de données. Elles permettent de décrire cette donnée en lui allouant un
ensemble de variables la caractérisant.
Par exemple, pour décrire un individu, on indiquera son nom, son âge, sa taille, son poids et son sexe (0 pour un
homme, 1 pour une femme).
Lřindividu constituera une donnée de type structure dont les « champs » seront :
- le nom (tableau de caractères)
- lřâge (un entier court non signé)
- la taille (un nombre à virgule flottante)
- le poids (un nombre à virgule flottante)
- le sexe (un caractère)
Les structures seront développées ultérieurement (page 28).
-4-

LICENCE SPI-EEA LANGAGE C M. Deloizy
II.3.c. les unions :
Il sřagit de structures particulières dans lesquelles tous les champs sont situés à la même adresse. Les unions sont utiles
lors du développement de programmes à bas niveau (proches du matériel), et permettent ainsi une bonne portabilité du
langage.
Remarque :
On peut évidemment combiner les structures et les tableaux, permettant ainsi dřobtenir des tableaux de
structures ou des structures contenant des tableaux.
II.4. Autres types
II.4.a.
II.4.b.
les types définis par le programmeur
le programmeur peut à son aise renommer un type de donnée par lřintermédiaire du mot clé typedef.
Utilisé à bon escient, cela permet souvent une meilleure lisibilité des programmes.
Exemples :
typedef unsigned char byte;
typedef unsigned short word;
typedef unsigned long dword;
void
nřest pas un type de donnée. Ce mot clé permet dřindiquer lřabsence de donnée ou la méconnaissance du
type de donnée.
III. La déclaration des variables
Pour déclarer une variable, il suffit dřindiquer le type choisi, suivi du nom de la variable. Plusieurs variables de même
type peuvent être déclarées simultanément.
La fin de la déclaration est marquée par le caractère Ř;ř
Exemples :
char x ; x est un caractère (sur 8 bits : [-128…+127])
int i, j, k ; i, j et k sont des entiers (sur 16 bits : [-32768…+32767])
unsigned arthur ; arthur est un entier non signé (sur 16 bits : [0…+65535])
unsigned char octet ; octet est un caractère non signé(sur 8 bits : [0…+255])
Pour déclarer des tableaux de données, on fait suivre le nom de variable par le nombre dřéléments que peut contenir
chaque ligne du tableau ; Cette valeur obligatoirement constante doit figurer entre crochets.
Exemples :
char tab[10] ; tab est un tableau pouvant contenir 10 caractères
double f[5][3] ; f est un tableau de 5 lignes et 3 colonnes (15 x double)
Remarques :
A lřutilisation, le premier élément du tableau est dřindice 0.
Les éléments dřun tableau sont rangés consécutivement en mémoire (Ex. de tab[0] à tab[9])
Pour les tableaux multi-dimensionnés, le dernier indice « court » le plus vite ; Par exemple, pour le tableau f, le
rangement en mémoire sera :
f[0][0], f[0][1], f[0][2], f[1][0], f[1][1], f[1][2], f[2][0], … , f[4][1], f[4][2]
IV. Constantes
Lors de lřécriture de données constantes, la syntaxe permet dřindiquer au compilateur le type de la constante :
Ecritures
Exemples
Caractère Řxř ŘAř, Ř=ř, Ř\\ř, Ř\řř
Entier nnn ou nnn 421, 0, -12, +456
Entier exprimé en octal 0nnn ou 0nnn 0712, 010, -057
Entier hexadécimal 0xnn ou 0xNN 0x4A, 0x00ff
double nnn.nn ou nnnEnn 1.0, -4., 3E4, 1.6e-19
Chaîne de caractères "xxxxxx" "Bonjour les amis"
-5-

LICENCE SPI-EEA LANGAGE C M. Deloizy
Remarque : le caractère \ est le caractère dŘéchappement en C. Il permet dřintroduire une séquence à signification
particulière.
Séquences dřéchappement possibles :
Séquence Signification Exemple Résultat
\r Retour chariot (en début de ligne). 0x0D printf("\rbonjour") bonjour
\n Saut à la ligne suivante. 0x0A printf("bonjour\n") bonjour
\t Tabulation. 0x09 printf("Rés.\tMoy.\n") Rés. Moy.
\\ Caractère \ printf("valeur : \\10\\\n") valeur : \10\
\ř Caractère ' x='\''-0x20 x=39-32x=7
\" Caractère " printf("Il dit : \"Bof!\"\n") Il dit : "Bof!"
\xnn ou \Xnn Nombre hexadécimal (n : digit hexa) 0x3B, 0xFA8 59, 4008
\ooo Nombre octal (o : digit octal) \012, \033 10, 27
On peut également préciser le type de constantes grâce à lřadjonction de suffixes :
Suffixe : sans U ou u L ou l F ou f
Entier int unsigned int long float
Virgule flottante double - long double Float
Exemples :
12L : valeur 12 codée sur un type long
40000u : codé sur un type unsigned int
13.4 : constante double
12.5f : constante float
12UL : constante unsigned long int
-6-

LICENCE SPI-EEA LANGAGE C M. Deloizy
V. Organisation générale d'un module
Un programme C est constitué de un ou plusieurs modules (fichiers sources d'extension ".c").
Chaque module sera organisé de la manière suivante :
déclarations
…
fonction1
…
fonction2
…
…
La zone de déclaration initiale permet de définir des données globales au module ; Elles seront reconnues par l'ensemble
des fonctions définies dans le module.
Pour l'ensemble des modules, on ne devra définir qu'une fonction main() qui sera le point de démarrage du programme.
VI. Constitution d'une fonction
VI.1. Définition d'une fonction
Pour définir une fonction, on déclare le nom de la fonction, avec le type de valeur retournée par la fonction, ainsi que
les noms et les types des arguments transmis.
Ensuite on définit le corps de la fonction (entre accolades). Celui-ci a la structure suivante :
déclarations de données locales à la fonction
blocs d'instructions
retour à la fonction appelante (avec un éventuel renvoi d'une valeur)
Exemple :
double somme(double a, double b)
{
double res;
res = a + b;
return res;
}
On rencontre encore quelques fois l'ancienne syntaxe (avant la standardisation du C Ansi) qu'il vaut mieux éviter, sauf
si le compilateur ne reconnaît que celle-ci :
double somme(a, b)
double a, b;
{
double res;
res = a + b;
return res;
}
Remarques :
lors de la définition d'une fonction, le caractère ";" doit être omis en fin de ligne
en C, les paramètres sont toujours transmis par valeur
si une fonction ne doit rien retourner (il s'agit alors d'une procédure), on la définit void :
-7-

LICENCE SPI-EEA LANGAGE C M. Deloizy
Exemple :
void init_glob()
{
A=0;
TOT=12E4;
}
si le type retourné par la fonction est omis, le compilateur supposera qu'elle retourne une valeur de type int.
lorsqu'une fonction n'a pas été déclarée antérieurement, le compilateur supposera qu'elle retourne un type int
(d'où la nécessité de définir des prototypes).
VI.2. Prototypes
Le prototypage permet d'indiquer au compilateur le type de donnée retourné par une fonction, ainsi que le nombre et le
type des arguments transmis ; Il s'agit donc en fait d'une déclaration de fonction.
Cette déclaration permet au compilateur de réaliser des contrôles (par exemple, il vérifie la cohérence des paramètres
transmis). Elle permet en outre la réalisation de transtypages automatiques, ce qui permet de lever bien des erreurs.
Exemple de prototype :
double sin(double);
Ce prototype indique au compilateur que la fonction sinus retourne une valeur de type double et qu'elle attend un
paramètre de type double.
Ce prototype est défini en standard dans "math.h".
Si ce prototype n'avait pas été défini, lors de l'écriture de la ligne
y = sin(3);
le nombre 3 écrit ainsi étant de type entier, la fonction sin attendant un double (dont le codage en mémoire est
différent), la fonction ne récupérerait pas la valeur "3.0" ; Le résultat fourni par la fonction sin serait dans ce cas
aléatoire.
Il en va de même pour la valeur retournée, puisque le compilateur suppose par défaut qu'une fonction retourne un type
int, ce qui n'est pas le cas dans cet exemple.
Par contre, si le prototype est lu par le compilateur avant l'utilisation de la fonction, les transtypages se font de manière
automatique, l'entier 3 devenant alors un nombre à virgule flottante (3.0) avant l'appel de la fonction.
Pour éviter toute erreur, il est donc essentiel de déclarer les prototypes des fonctions avant leur utilisation (ici, en
ajoutant par exemple la ligne : #include ).
On notera que la définition d'un prototype ne génère pas de code ; elle communique uniquement des informations à
l'attention du compilateur.
VII. Blocs d'instructions
Un bloc d'instructions est constitué soit :
d'une instruction élémentaire terminée par un caractère ";"
d'un ensemble d'instructions élémentaires encadrées par des accolades ; dans ce cas, le bloc d'instructions peut
comporter des déclarations (locales à ce bloc).
d'un simple caractère ';'. Dans ce cas, l'instruction est vide (sans effet).
Exemples de blocs d'instructions :
ou :
ou :
x = 2*a + b;
{
x = 2;
y = 4;
z = x+y;
}
{
int i;
i = 3;
x = 2*(i++);
y=i;
}
-8-

LICENCE SPI-EEA LANGAGE C M. Deloizy
VII.1. Opérateurs
Ils permettent l'évaluation d'expressions arithmétiques ou logiques.
VII.1.a. Opérateurs arithmétiques :
Opérateur Description Exemple (a=5, b=3, c=1)
* multiplication x = 20*a x = 100
/ division z = 10.0/4 z = 2.5
+ addition x = 3+b x = 6
- soustraction x = 3-b x = 0
% modulo (reste de la division entière) x = 8%a x = 3
^ ou exclusif (opération sur les bits) x = a^b x = 6
| ou (opération sur les bits) x = a|b x = 7
& et (opération sur les bits) x = a&b x = 1
>c x = 1
VII.1.b. Opérateurs logiques :
Ils donnent comme résultat un entier (0 pour faux, 1 pour vrai).
Opérateur Description Exemple (a=5, b=3)
== test d'égalité x = a==b x = 0
|| ou logique x = (a==1)||(a==2) x = 0
&& et logique x = (a>0) && (a4 x = 1
=4 x = 1
Remarques :
- Lors de l'exécution, il se peut que des termes ne soient pas évalués dans des expressions logiques ; cela
peut être le cas si le résultat final peut être déterminé avant l'évaluation totale de l'expression. Dans ce cas,
il est donc fortement déconseillé d'utiliser des appels de fonctions ou d'effectuer des affectations sur des
variables à l'intérieur d'expressions logiques (le résultat dépendra de la façon dont le compilateur aura
effectué la traduction de l'expression).
Par exemple, lors de l'écriture de la ligne
if ((a>5) || (somme(a,b)

LICENCE SPI-EEA LANGAGE C M. Deloizy
|= équivalent à # = # | … a |= b a = 7
&= équivalent à # = # & … a &= b a = 1
>= b-2 a = 2
Remarques :
En C, l'affectation est un opérateur à part entière : Elle donne un résultat qui peut être utilisé dans une expression, ce qui
permet les écritures suivantes :
x = (a=3)+1;
met 3 dans a et 4 dans x
x -= (a+=10); augmente a de 10 et soustrait le résultat de x
Il faut cependant noter que ces écritures concises risquent de rendre le programme moins lisible. D'autre part, il n'est pas
certain que le code généré soit amélioré par ce type d'écriture quelquefois plus difficile à interpréter par le compilateur ;
Tout dépend de la puissance du compilateur.
VII.1.d. Opérateur ternaire :
Opérateur Description Exemple (a=5, b=3, c=1)
: choix d'une valeur selon une condition
x=(a>4)(b*2):(c+1) x = 6
si la condition est vraie, la première expression est
retournée, sinon, la deuxième expression est retournée. x=(a3) x = 0
++ auto incrémentation (post ou pré) x = a++ x = 5, a = 6
x = ++a x = 6, a = 6
-- auto décrémentation (post ou pré) x = a-- x = 5, a = 4
x = --a x = 4, a = 4
sizeof donne la taille d'un objet (donnée ou type).
est équivalent à une constante, déterminée par le compilateur.
sizeof(char) vaut 1
sizeof sur un tableau donne le nombre d'octets occupé par le tableau
sizeof(int) vaut 2 si le type int est codé sur 16 bits
(type) opérateur cast (transtypage). Permet de modifier le type d'une expression ; type représente un
type de donnée prédéfini.
Exemples :
i = (int)(100.0*sin(2.45));
x = (double)(2*a+1);
-10-

LICENCE SPI-EEA LANGAGE C M. Deloizy
VII.2. Expressions
Les expressions utilisent des opérateurs. L'ordre d'évaluation des expressions dépend de la priorité des opérateurs. Dans
le doute, il est recommandé d'utiliser des parenthèses.
Exemples :
3b
x = 2*a + 3*b/4/c; est interprété comme : x 2
a
4 c
La priorité des opérateurs est indiquée ci-dessous :
Opérateurs
Priorité
() [] -> . 15
! ~ ++ -- + * - * * * & * (type) sizeof 14
* / % 13
+ - 12
> 11
< >= 10
== != 9
& 8
^ 7
| 6
&& 5
|| 4
: 3
= += -= *= /= %= &= ^= |= = 2
, 1
(*) : Opérateurs unaires & pointeurs
VII.3. Instructions de contrôle de déroulement
Les instructions de contrôle sont celles offertes par tous les langages évolués, avec toutefois une plus grande souplesse
procurée par l'écriture concise du langage.
Toute expression retournant une valeur peut être utilisée lors de l'utilisation d'une condition ; Si le résultat (converti en
int) est nul, la condition sera considérée comme fausse ; Elle sera vraie dans le cas contraire.
VII.3.a. Tests si … sinon …
if (condition)
bloc d'instructions à exécuter si la condition est vraie
else
bloc d'instructions à exécuter si la condition est fausse
optionnel
VII.3.b. Boucles tant que … faire :
while (condition)
bloc d'instructions à exécuter si la condition est vraie.
la condition est réévaluée à la fin de l'exécution du bloc d'instructions ; si
la condition est vraie, le bloc est exécuté de nouveau (voir graphe cicontre).
Exemple :
while(x

LICENCE SPI-EEA LANGAGE C M. Deloizy
VII.3.c. Boucles faire … tant que :
Exemple :
do
bloc d'instructions à exécuter.
while (condition);
Le bloc d'instructions est exécuté inconditionnellement ; La condition
est ensuite évaluée ; si la condition est vraie, le bloc est exécuté de
nouveau (voir graphe ci-contre).
non
bloc
d'instructions
condition
vraie
oui
do
{
printf("Entrer un nombre positif : ");
scanf("%d",&x);
}
while(x

LICENCE SPI-EEA LANGAGE C M. Deloizy
do
Exemple :
{
k = getchar(); /* Acquisition clavier -> k */
switch (k) /* Test de k */
{
case '1':
menu1(); /* Appeler menu1 si '1' tapé */
break; /* Quitter switch */
case '2':
menu2(); /* Appeler menu1 si '2' tapé */
break; /* Quitter switch */
case 'q':
case 'Q':
printf("Fin du programme.\n"); /* Quitter le programme si */
exit(0); /* 'q' ou 'Q' tapé */
default:
printf("\n"); /* Erreur */
}
}
while((k=='1') || (k=='2'));
VII.3.f. Rupture de séquence break :
break permet de sortir d'une boucle de type type while … , do … while , for ou d'un switch … case. On
peut noter un exemple d'utilisation dans l'exemple précédent.
VII.3.g. Rupture de séquence continue :
continue permet d'interrompre le déroulement normal d'une boucle de type while … , do … while ou for
en allant directement à la fin du bloc d'instructions.
Exemple :
for(i=0; i

LICENCE SPI-EEA LANGAGE C M. Deloizy
VIII.1. Donnée globale au programme
Pour qu'une donnée soit globale au programme, il
suffit de la définir à l'extérieur d'un bloc de fonction.
Pour y accéder depuis un autre module, ou avant sa
définition, il faut effectuer une déclaration de cette
donnée avec le spécificateur extern, afin que le
compilateur puisse connaître son existence.
On note que par défaut, les noms des fonctions sont
globaux au programme ; les fonctions des modules
sont dont accessibles par la totalité des modules.
module 1
...
double x;
...
...
x=2.0*a;
module 2
...
extern double x;
...
...
x = x+1.0;
VIII.2. Donnée locale à un module
Quelquefois, on souhaite définir une donnée globale à un ensemble de fonctions contenues dans un module, mais pas à
la totalité du programme ; C'est notamment le cas lors de l'écriture de bibliothèques de fonctions dont on ne veut pas
qu'un nom puisse interférer avec ceux de l'utilisateur de la bibliothèque.
Pour rendre une donnée globale au module, il suffit de la déclarer à l'extérieur d'un corps de fonction en ajoutant le
spécificateur static.
Exemple :
int x;
x est globale au programme (et donc au module aussi)
static double y;
y est locale au module (inconnue des autres modules)
void fct1(void)
{
...
}
static void fct2(void)
{
...
}
la fonction fct1 est accessible par tout le programme
la fonction fct2 n'est visible que dans ce module
VIII.3. Donnée locale à une fonction
Une donnée définie à l'intérieur d'un corps de fonction est locale à cette fonction et n'est donc accessible qu'à l'intérieur
de cette fonction. On notera que les paramètres transmis à la fonction sont vus comme des variables locales à cette
fonction.
Exemple :
void fonction(int a, double x) a et x sont des variables locales à la fonction
{
unsigned c,d;
c et d sont des variables locales à la fonction
...
}
VIII.4. Donnée locale à un bloc d'instructions
En C, il est possible de déclarer des données à l'intérieur d'un bloc d'instructions. Dans ce cas, ces données sont locales
au bloc d'instructions.
Exemple :
void fonction(int a, double x) a et x sont des variables locales à la fonction
{
unsigned i;
i est locale à la fonction
...
for(i=0; i

LICENCE SPI-EEA LANGAGE C M. Deloizy
IX.1. static
Ce mot clé signifie que la donnée doit être à allocation fixe pendant toute la durée d'exécution du programme ; il s'agit
d'une donnée statique, dont l'adresse demeure inchangée pendant l'existence du programme.
Remarques :
Les données globales sont statiques, car elles existent dès le démarrage du programme.
Déclarer une variable locale comme étant statique permet de retrouver sa valeur antérieure (lors du dernier passage dans
la fonction).
Les variables statiques peuvent être initialisées ; on spécifie alors la valeur que doit prendre la variable lors du
démarrage du programme.
Une variable statique non initialisée est par défaut mise à zéro au démarrage du programme ; Ceci n'est cependant pas
garanti sur tous les environnements.
Exemple :
void fonction(void)
{
{
static x;
x est de type int ; vaut 0 au démarrage du programme.
static long double pi=3.14L; pi vaut 3.14 au démarrage du programme
if(x

LICENCE SPI-EEA LANGAGE C M. Deloizy
entrée. On demande ainsi au compilateur de ne pas réaliser d'optimisation sur cette variable ; il devra évaluer sa valeur à
chaque accès, comme indiqué dans le programme.
Exemple :
...
volatile char x;
extern volatile unsigned char pio;
...
X. Les pointeurs
X.1. Définition
Les pointeurs permettent d'accéder à des données à partir de leur adresse.
Notation :
où
et
*nom_var
nom_var représente la variable pointeur (qui contient une adresse)
*nom_var représente la variable pointée.
Déclaration :
nom_type *nom_var;
Exemple :
char *c;
c contient l'adresse de la variable pointée
la variable pointée est de type char
Certaines données sont constantes et l'utilisation de pointeurs pourrait autoriser la modification de ces données. Dans ce
cas, les déclarations suivantes sont valides :
pointeur sur une chaîne de caractères constante : "chaîne de caractères"
pointeur sur une donnée constante : const char *c; (*c est constant)
pointeur constant : double * const v; (v est constant)
pointeur constant sur une donnée constante : const int * const p; (p et *p sont constants)
X.2. Arithmétique des pointeurs
Les opérations suivantes sont valides :
opérateur
pointeur + entier
pointeur - entier
pointeur - pointeur
pointeur comparaison pointeur
résultat
pointeur
entier
Lorsque l'on ajoute ou retranche un entier à un pointeur, on accède à un élément positionné en mémoire comme s'il était
dans un tableau. Par exemple, si p est un pointeur, les pointeurs (p+i) pointent sur les données situées à la suite de la
donnée pointée par p, tandis que les pointeurs (p-i) pointent sur les données situées avant, comme indiqué ci-dessous :
…
p-2
p-1
p p+1 p+2 …
Le programme suivant peut ainsi être utilisé pour parcourir une chaîne de caractères :
char *p, c;
p = "HELLO";
c = *p;
c = *(p+1);
p += 4;
p--;
c = 'H'
c = 'E'
*p = 'O'
*p = 'L'
Remarque :
Quand on ajoute (ou retranche) un entier à un pointeur, l'adresse est augmentée (ou diminuée) de la taille (en octets, ou
éléments de taille élémentaire) de l'élément pointé. C'est pourquoi le compilateur ne peut opérer des opérations sur les
-16-

LICENCE SPI-EEA LANGAGE C M. Deloizy
pointeurs que lorsqu'il connaît le type des données pointées ; L'arithmétique des pointeurs ne fonctionne donc pas avec
des pointeurs void.
X.3. Utilité des pointeurs
En C, l'usage des pointeurs est indispensable pour :
accéder aux éléments d'un tableau
manipuler les chaînes de caractères
permettre aux fonctions de retourner plusieurs valeurs
X.3.a. Les tableaux
Ils permettent de disposer de manière contiguë en mémoire des données de même type. Par exemple, la tableau déclaré
par :
double v[5];
place 5 variables en virgule flottante à partir de l'adresse v.
v est donc un pointeur. Il est constant (sinon on perdrait l'adresse de base du tableau).
v est l'adresse de la première donnée du tableau.
Pour accéder aux éléments du tableau, on utilise la notation v[i], où i est un entier et représente l'indice.
En C, l'indice du premier élément d'un tableau est toujours 0. Ainsi, pour le tableau v contenant 5 éléments, on pourra
accéder aux éléments v[0] à v[4].
Puisque v est un pointeur, on peut également accéder à l'élément i du tableau en écrivant : *(v+i).
Les notations v[i] et *(v+i) sont équivalentes ; Elles peuvent être utilisées même lorsque v n'est pas un tableau.
Pour connaître l'espace mémoire occupé par un tableau, on peut utiliser l'opérateur sizeof sur ce tableau. Par exemple,
dans le cas précédent, sizeof(v) donnerait 40 si le type double avait une taille de 8.
Pour déterminer le nombre d'éléments que l'on peut mettre dans un tableau, on peut donc écrire l'expression suivante :
sizeof(v)/sizeof(*v)
On divise la taille du tableau par la taille du premier élément du tableau, ce qui donne le nombre d'éléments contenus (5
dans l'exemple).
Par contre, il faut bien noter que l'opérateur sizeof appliqué à un pointeur donne la taille du pointeur. Par exemple, avec
la déclaration :
char *str = "Hello";
sizeof(str) donne la valeur 4 si les pointeurs occupent 4 octets. La déclaration ci-dessus indique simplement que
l'on définit un pointeur que l'on initialise sur une chaîne de caractères constante ("Hello").
Quant à la déclaration suivante :
char str[10] = "Hello";
l'utilisation de sizeof(str) dans ce cas donnera 10, car on a ici défini un tableau de 10 caractères, ce tableau étant
initialisé par les 6 caractères de la chaîne "Hello" (y compris l'octet nul).
X.3.b. Chaînes de caractères
En C, les chaînes de caractères sont des tableaux de caractères. Le caractère '\0' est le délimiteur de chaîne et sera pris
en compte par toutes les fonctions traitant des chaînes de caractères.
Une chaîne de caractères constante sera notée entre guillemets, par exemple : "Bonjour à tous". Les caractères
successifs sont placés en mémoire et l'octet nul est ajouté à la fin. La chaîne "toto" occupe donc 5 octets.
On trouvera des exemples d'initialisation de chaînes de caractères dans le paragraphe précédent.
X.3.c. Fonctions et pointeurs
Les fonctions retournent une valeur unique. Lorsque l'on désire qu'une fonction retourne plusieurs valeurs, on utilise des
pointeurs au niveau des paramètres transmis à la fonction : On transmet ainsi les paramètres par référence.
Exemple d'une fonction initialisant un tableau à 0 :
void InitTab(int *baseTab, unsigned nb)
{
unsigned i;
for(i=0; i

LICENCE SPI-EEA LANGAGE C M. Deloizy
La fonction InitTab aurait pu également être écrite ainsi :
void InitTab(int *baseTab, unsigned nb)
{
while(nb--) *(baseTab++)=0;
}
Les paramètres étant transmis à la fonction par valeur, et ces derniers étant locaux à la fonction, leur modification dans
la fonction ne change pas la valeur des données transmises en arguments lors de l'appel.
Par contre, on accède aux éléments de tableau par l'intermédiaire de l'adresse du tableau.
Autre exemple permettant la recherche de minima et maxima :
void MinMax(double x, double *Min, double *Max)
{
if(x < *Min) *Min = x;
else if(x > *Max) *Max = x;
}
...
double tab[100];
unsigned i;
double mini, maxi;
...
mini = maxi = *tab;
for(i=1; i

LICENCE SPI-EEA LANGAGE C M. Deloizy
Remarque :
Opérations sur les flux peuvent échouer (disque plein, fichier introuvable…)
Nécessité de vérifier validité opérations
Tester les codes dřerreurs (EOF ou NULL).
XI.2. Flux en sortie.
Par défaut lřécran (stdout) ne nécessite pas dřouverture.
Accès en écriture des fichiers.
Fonctions de gestion du flux :
printf, fprintf, sprintf,…
int printf(const char *format, …)
int fprintf(FILE *f, const char *format, …)
int sprintf(char *str, const char *format, …)
putchar, putc, fputc
int putchar(int x)
int putc(int x, FILE *f)
int fputc(int x, FILE *f)
puts, fputs
char *puts(const char *str)
char *fputs(const char *str, FILE *f)
fwrite
int fwrite(const void *buffer, size_t size, size_t nb, FILE *f)
XI.3. Flux en entrée.
Par défaut le clavier (stdin) ne nécessite pas dřouverture.
Accès en lecture des fichiers.
Fonctions de gestion du flux :
scanf, fscanf, sscanf,…
int scanf(const char *format,…)
int fscanf(FILE *f, const char *format,…)
int sscanf(char *s, const char *format,…)
getchar, getc, fgetc
int getchar(void)
int getc(FILE *f)
int fgetc(FILE *f)
gets, fgets
char *gets(void)
char *fgets(char *dest, size_t nb_max, FILE *f)
fread
int fread(void *buffer, size_t size, size_t nb, FILE *f)
XI.4. Fonctions de gestion
long ftell(FILE *f)
int fseek(FILE *f, long offset, int fromwhere)
void rewind(FILE *f)
int feof(FILE *f)
int fflush(FILE *f)
XII. Fonctions standard
XII.1. Manipulation de chaînes de caractères
memchr strcat strchr strrstr
memcmp strncat strrchr strlen
memcpy strcpy strspn strerror
memmove strncpy strcspn
memset strcmp strpbrk
strncmp
strtok
-19-

LICENCE SPI-EEA LANGAGE C M. Deloizy
XII.1.a. Traitement de données brutes
memchr : recherche le caractère c dans les n premiers octets du tableau s.
void *memchr(const void *s, int c, size_t n);
Cette fonction retourne un pointeur sur la première occurence de c dans s ; elle retourne NULL si c ne figure pas
dans le tableau s.
memcmp : compare deux blocs, s1 et s2, sur une longueur d'exactement n octets.
int memcmp(const void *s1, const void *s2, size_t n);
Cette fonction retourne une valeur < 0 si s1 est inférieur à s2, nulle si s1 est identique à s2 et > 0 si s1 est supérieur à
s2.
memcpy : copie un bloc de n octets de src dans dest.
void *memcpy(void *dest, const void *src, size_t n);
Cette fonction retourne le pointeur dest.
memmove : copie un bloc de n octets de src dans dest.
void *memmove(void *dest, const void *src, size_t n);
Cette fonction retourne le pointeur dest.
memset : initialise n octets de s avec l'octet c.
void *memset(void *s, int c, size_t n);
Cette fonction retourne le pointeur s.
XII.1.b. Copie et concaténation :
strcat : concatène la chaîne src à dest.
char *strcat(char *dest, const char *src);
Cette fonction retourne dest.
strncat : ajoute au plus maxlen caractères de la chaîne src à la fin de dest.
char *strncat(char *dest, const char *src, size_t maxlen);
Cette fonction retourne dest.
strcpy : copie la chaîne src dans dest.
char *strcpy(char *dest, const char *src);
Cette fonction retourne l'adresse de dest.
strncpy : copie jusqu'à maxlen caractères de la chaîne src dans la chaîne dest.
char *strncpy(char *dest, const char *src, size_t maxlen);
Si maxlen caractères sont copiés, aucun caractère nul n'est ajouté ; le contenu de la zone dest est une chaîne terminée
par un caractère nul.
Cette fonction retourne dest.
XII.1.c. Comparaisons de chaînes de caractères :
strcmp : compare la chaîne s2 à la chaîne s1.
int strcmp(const char *s1, const char *s2);
Cette fonction retourne une valeur < 0 si s1 est inférieur à s2, nulle si s1 est identique à s2 et > 0 si s1 est supérieur à
s2. La comparaison est signée.
-20-

LICENCE SPI-EEA LANGAGE C M. Deloizy
strncmp : compare les chaînes s2 et s1 en se limitant aux maxlen premiers caractères.
int strncmp(const char *s1, const char *s2, size_t maxlen);
Cette fonction retourne une valeur < 0 si s1 est inférieur à s2, nulle si s1 est identique à s2 et > 0 si s1 est supérieur à
s2. Effectue une comparaison signée.
XII.1.d. Recherche de séquences :
strchr : cherche le caractère c dans la chaîne str.
char *strchr(const char *str, int c);
Cette fonction retourne un pointeur sur la première occurrence du caractère c dans str ; si c ne figure pas dans str,
strchr retourne NULL.
strrchr : cherche dans la chaîne s la dernière occurrence du caractère c.
char *strrchr(const char *s, int c);
Cette fonction retourne un pointeur sur la dernière occurrence du caractère c dans s ; si c ne figure pas dans la
chaîne, elle retourne NULL.
strspn : cherche la longueur du segment initial de s1 formé uniquement de caractères figurant dans la chaîne s2.
size_t strspn(const char *s1, const char *s2);
strcspn : cherche la longueur du premier segment de s1 formé uniquement de caractères NE FIGURANT PAS dans la
chaîne s2.
size_t strcspn(const char *s1, const char *s2);
strpbrk : cherche dans la chaîne s1 la première occurrence d'un caractère quelconque de la chaîne s2.
char *strpbrk(const char *s1, const char *s2);
Cette fonction retourne un pointeur sur la première occurrence dans s1 d'un caractère de s2 ; si aucun des caractères
de s2 ne figure dans s1, c'est la valeur NULL qui est retournée.
strstr : cherche la première occurrence de la sous-chaîne s2 dans s1.
char *strstr(const char *s1, const char *s2);
Cette fonction retourne un pointeur sur la partie de s1 identique à s2 (un pointeur sur s2 dans s1). S'il n'y a pas
d'occurrence de s2 dans s1, c'est la valeur NULL qui est retournée.
strtok : cherche dans la chaîne s1 le premier élément ne figurant pas dans s2.
char *strtok(char *s1, const char *s2);
s2 définit des caractères séparateurs. strtok considère la chaîne s1 comme une suite d'éléments séparés par des
caractères de la chaîne s2. Si aucun élément n'est trouvé dans s1, la fonction retourne la valeur NULL. Si un élément
est trouvé, le caractère nul est écrit dans s1 à la suite de l'élément et strtok retourne un pointeur sur cet élément.
Les appels suivants à strtok avec NULL comme premier argument poursuivent la recherche dans la chaîne s1 de
l'appel précédent et continuent après le dernier élément trouvé.
XII.1.e. Fonctions diverses :
strlen : calcule la longueur de la chaîne s.
size_t strlen(const char *s);
Cette fonction retourne le nombre de caractères de la chaîne s, le caractère nul d'arrêt n'étant pas compté.
strerror : retourne un pointeur sur une chaîne contenant un message d'erreur.
char *strerror(int errnum);
Cette fonction retourne un pointeur sur le message d'erreur associé à errnum.
-21-

LICENCE SPI-EEA LANGAGE C M. Deloizy
XII.2. Entrées sorties
clearerr getc flushall rewind
fclose getchar fopen scanf
fcloseall gets fprintf setbuf
fdopen getw fputc setvbuf
feof perror fputchar sprintf
ferror printf fputs scanf
fflush putcs fread _strerror
fgetc putchar freopen strerror
fgetchar puts fscanf vfscanf
fgetpos tmpfile fseek vprintf
fgets tmpnam fsetpos vscanf
fileno ungetc putw vsprintf
ftell unlink remove vsscanf
fwrite vfprintf rename
XII.2.a. Entrées / Sorties formatées :
scanf : effectue des entrées formatées depuis le flux standard stdin
int scanf(const char *format, ...);
Cette fonction retourne le nombre de champs d'entrée traités correctement. Elle traite les entrées selon la chaîne de
format et place les résultats dans les emplacements mémoire pointés par les arguments.
printf : écrit des sorties formatées dans le flux standard stdout.
int printf(const char *format, ...);
Cette fonction applique une spécification de format à un nombre variable d'arguments et écrit les données formatées
dans le flux stdout. printf retourne le nombre d'octets écrits. En cas d'erreur, elle retourne EOF.
XII.2.b. Spécifications de format (pour printf et scanf) :
% [flags] [width] [.prec] [F|N|h|l] type
Type Format de la sortie
d : entier décimal signé
i : entier décimal signé
o : entier octal non signé
u : entier décimal non signé
x : avec printf = entier hexadécimal non signé en minuscules
: avec scanf = entier hexadécimal
X : avec printf = entier hexadécimal non signé en majuscules
: avec scanf = entier hexadécimal long
f : virgule flottante [-]dddd.ddd
e : virgule flottante avec exposant [-]d.ddd e [+/-]ddd
g : format e ou f suivant la précision
E : comme e mais l'exposant est la lettre E
G : comme g mais l'exposant est la lettre E
c : caractère simple
s : affiche les caractères jusqu'au caractère nul d'arrêt '\0' ou jusqu'à ce que la précision soit atteinte
% : caractère de pourcentage %
p : pointeur
n : range (à l'adresse pointée par l'argument d'entrée) le nombre de caractères écrits.
[flags] Signification
aucun : résultat justifié à droite et complété à gauche par des espaces ou des 0
- : résultat justifié à gauche et complété à droite par des espaces
+ : les résultats commencent toujours par le signe + ou -
espace : n'affiche le signe que pour les valeurs négatives
# l'argument doit être converti en utilisant une autre forme :
c,s,d,i,u : sans effet
-22-

LICENCE SPI-EEA LANGAGE C M. Deloizy
o : 0 sera placé devant l'argument s'il est non nul
x ou X : 0x ou 0X placé devant la valeur de l'argument
e, E, f : le résultat contiendra toujours un point décimal
g or G : même chose mais sans les zéros à droite
[width] Effet sur l'affichage
n : affichage d'au moins n caractères, au besoin complété par des espaces
0n : affichage d'au moins n caractères, au besoin complété à gauche par des chiffres 0
* : l'argument suivant de la liste contient la spécification de largeur
[.prec] Effet sur l'affichage
aucun : précision par défaut
.0 : avec d,i,o,u,x précision par défaut
: avec e, E, f pas de point décimal
.n : n caractères au plus
* : l'argument suivant de la liste contient la précision
Modificateur Comment arg est interprété
F : arg est interprété comme un pointeur long
N : arg est interprété comme un pointeur court
h : arg est interprété comme un entier de type short pour d,i,o,u,x,X
l : arg est interprété comme un entier de type long pour d,i,o,u,x,X
l : arg est interprété comme un réel de type double pour e,E,f,g,G (scanf)
L : arg est interprété comme un réel de type long double pour e,E,f,g,G
XII.2.c. Fonctions d'entrées :
getchar : (macro) retourne un caractère depuis le flux d'entrée stdin.
int getchar(void);
getchar retourne le caractère lu, après conversion en un entier de type int sans extension de signe. Elle retourne EOF à la
fin du fichier ou en cas d'erreur.
getc : (macro) retourne un caractère depuis un flux.
int getc(FILE *fp);
Cette macro retourne le caractère lu. Elle retourne EOF à la fin du fichier ou en cas d'erreur.
fgets : lit une chaîne dans un flux.
char *fgets(char *s, int n, FILE *fp);
Lorsqu'elle réussit, cette fonction retourne la chaîne s ; elle retourne NULL en fin de fichier ou en cas d'erreur.
XII.2.d. Fonctions de sorties :
putchar : envoie un caractère dans le flux standard stdout.
int putchar(int ch);
Si la sortie peut se faire, putchar retourne le caractère ch ; s'il y a une erreur, elle retourne EOF.
putc : sort un caractère dans un flux.
int putc(int ch, FILE *fp);
Si la sortie peut se faire, putc retourne le caractère ch ; s'il y a une erreur, elle retourne EOF.
fputs : envoie une chaîne dans un flux.
int fputs(const char *s, FILE *fp);
S'il n'y a pas d'erreur, cette fonction retourne le dernier caractère écrit ; sinon, c'est la valeur EOF qui est retournée.
-23-

LICENCE SPI-EEA LANGAGE C M. Deloizy
XII.2.e. Gestion de fichiers (flux) :
fopen : ouvre un flux.
FILE *fopen(const char *filename, const char *mode);
Si elle aboutit, cette fonction retourne un pointeur sur le flux qui vient d'être ouvert ; sinon, elle retourne NULL.
Types d'ouverture :
r : ouvert pour lecture
w : créé pour écriture
a : ouvert pour écriture en fin de fichier
+ : pour permettre un accès en lecture et en écriture
b : ouvert en mode binaire
t : ouvert en mode texte
fclose : ferme un flux.
int fclose(FILE *fp);
Cette fonction retourne 0 si elle réussit et EOF lorsqu'une erreur est détectée.
fflush : vide la mémoire tampon associée à un flux.
int fflush(FILE *fp);
Cette fonction retourne EOF lorsqu'une erreur est détectée.
fseek : repositionne le pointeur de fichier d'un flux.
int fseek(FILE *fp, long offset, int whence);
offset est le nouvelle position par rapport l'emplacement donné par whence. Cette fonction retourne 0 si le pointeur a
pu être déplacé et une valeur non nulle sinon.
Constantes symboliques :
Positionnement du pointeur de fichier.
SEEK_SET au début du fichier
SEEK_CUR à la position courante du pointeur
SEEK_END à la fin du fichier
fsetpos : positionne le pointeur de fichier d'un flux.
int fsetpos(FILE *fp, const fpos_t *pos);
Le nouvel emplacement pointé par pos est la valeur obtenue lors d'un précédent appel à fgetpos. Quand l'opération
aboutit, cette fonction retourne 0. Dans le cas contraire, elle retourne une valeur non nulle.
Rem. : fpos_t : Type pour les pointeurs de fichiers.
ftell : retourne la position courante du pointeur d'un fichier.
long ftell(FILE *fp);
Cette fonction retourne la position courante du pointeur de fichier ou la valeur -1L quand il y a une erreur.
fwrite : écrit dans un flux.
size_t fwrite(const void *ptr, size_t size, size_t n, FILE *fp);
fwrite écrit n objets ayant chacun une longueur de size octets. Cette fonction retourne le nombre d'objets (et non le
nombre d'octets) réellement écrits.
fread : lit des données depuis un flux.
size_t fread(void *ptr, size_t size, size_t n, FILE *fp);
Cette fonction lit n objets ayant chacun une longueur de size octets ; elle retourne le nombre d'objets (et non le
nombre d'octets) réellement lus.
-24-

LICENCE SPI-EEA LANGAGE C M. Deloizy
XII.2.f. Exemple : copie de fichier texte
#include
#include
#include
void erreur(int err, const char *fmt, ...)
{
va_list arg;
va_start(arg,fmt);
fprintf(stderr,"Erreur [%d] : ",err);
vfprintf(stderr,fmt,arg);
va_end(arg);
exit(err);
}
main(int argc, char *argv[])
{
FILE *fs, *fd ;
int x ;
if(argc>1)
{
fs=fopen(argv[1],"r");
if(fs==NULL) erreur(1,"Le fichier %s ne peut être ouvert.\n",argv[1]);
}
else fs=stdin;
if(argc>2)
{
fd=fopen(argv[2],"w");
if(fd==NULL) erreur(2,"Création de %s impossible.\n",argv[1]);
}
else fd=stdout;
while((x=getc(fs))!=EOF)
if(putc(x,fd)==EOF) erreur(3,"Erreur en écriture");
fclose(fd);
fclose(fs);
return 0;
}
XII.3. Fonctions utilitaires :
atof rand bsearch calloc abort abs
atoi srand qsort malloc exit labs
atol realloc atexit div
strtod free system ldiv
strtol
getenv
strtoul
XII.3.a. Conversion de chaînes de caractères :
atof : convertit une chaîne de caractères en un nombre à virgule flottante.
double atof(const char *s);
Cette fonction retourne le résultat de la conversion ou 0 si s ne peut pas être convertie.
atoi : convertit une chaîne en un entier
int atoi(const char *s);
Retourne le résultat de la conversion de la chaîne passée en argument. Si la chaîne ne peut pas être convertie, la
valeur retournée est 0.
atol : convertit une chaîne de caractères en un entier long.
long atol(const char *s);
Cette fonction retourne le résultat de la conversion en entier de la chaîne passée en argument. Si la chaîne ne peut
pas être convertie, la valeur retournée est 0.
-25-

LICENCE SPI-EEA LANGAGE C M. Deloizy
strtod : convertit une chaîne en une valeur de type double.
double strtod(const char *s, char **endptr);
Cette fonction retourne la valeur de la chaîne s convertie en une valeur de type double. s doit être une suite de
caractères correspondant au format :
[ws] [sn] [ddd] [.] [ddd] [fmt[sn]ddd]
strtol : convertit la chaîne s en une valeur de type long, exprimée dans la base indiquée par radix.
long strtol(const char *s, char **endptr, int radix);
Cette fonction retourne la valeur convertie de la chaîne s ou bien 0 en cas d'erreur. s doit être une suite de caractères
correspondant au format :
[ws] [sn] [0] [x] [ddd]
strtoul : convertit une chaîne en une valeur de type unsigned long, exprimée dans la base indiquée par radix.
unsigned long strtoul(const char *s, char **endptr, int radix);
Cette fonction retourne la valeur convertie de la chaîne ou bien 0 en cas d'erreur.
XII.3.b. Générateur de nombres aléatoires :
rand : générateur de nombres aléatoires.
int rand(void);
Cette fonction retourne un nombre aléatoire compris entre 0 et RAND_MAX. RAND_MAX est défini dans stdlib.h.
srand : initialise le générateur de nombres aléatoires.
void srand(unsigned seed);
srand ne retourne pas de valeur.
XII.3.c. Fouilles et tris :
bsearch : recherche dichotomique dans un tableau (binary search).
void *bsearch(const void *key, const void *base, size_t *nelem, size_t width,
int (*fcmp)(const void*, const void*));
bsearch retourne l'adresse du premier élément du tableau correspondant à la clé de recherche key. Si aucun élément
ne convient, elle retourne 0.
Dans bsearch, la valeur retournée par *fcmp est < 0 si *elem1 < *elem2, nulle si *elem1 est égal à *elem2 et > 0 if
*elem1 > *elem2.
Le tableau doit être trié en ordre croissant.
qsort : effectue un tri rapide (Quicksort).
void qsort(void *base, size_t nelem, size_t width,
int(*fcmp)(const void *, const void *));
Cette fonction effectue le tri des nelem éléments de taille width, situés dans le tableau pointé par base.
XII.3.d. Allocation de mémoire :
calloc : alloue de la mémoire.
void *calloc(size_t nelem, size_t elsize);
Alloue un bloc pour nelem items formés de elsize octets ; initialise le bloc avec des zéros. Cette fonction retourne un
pointeur sur le bloc nouvellement alloué ou la valeur NULL lorsqu'il n'y a pas assez de place.
malloc : alloue de la mémoire.
void *malloc(size_t size);
L'argument size est exprimé en octets. Cette fonction retourne un pointeur sur le bloc nouvellement alloué, ou bien
la valeur NULL quand il n'y a pas assez d'espace pour un nouveau bloc. Si size = 0, elle retourne NULL.
-26-

LICENCE SPI-EEA LANGAGE C M. Deloizy
realloc : réalloue de la mémoire.
void *realloc(void *block, size_t size);
Cette fonction tente d'ajuster (augmenter ou diminuer) la taille d'un bloc précédemment alloué pour l'amener à une
taille de size octets. Elle retourne l'adresse du bloc réajusté qui n'est pas toujours la même que le bloc d'origine. Si
l'opération n'a pas été possible ou si size vaut 0, elle retourne la valeur NULL.
free : libère des blocs alloués par malloc ou calloc.
void free(void *block);
XII.3.e. Fonctions système :
abort : arrêt anormal d'un programme.
void abort(void);
exit : met fin à un programme.
void exit(int status);
Avant la sortie, les mémoires tampons sont vidées, les fichiers sont fermés et les fonctions de sortie sont appelées.
atexit : enregistre une fonction de sortie.
int atexit(atexit_t func);
Cette fonction retourne 0 si l'enregistrement de la fonction peut avoir lieu et une valeur non nulle en cas d'anomalie.
system : lance une commande du système d'exploitation.
int system(const char *command);
system exécute une commande du système d'exploitation
Cette fonction retourne zéro si l'opération a pu se réaliser et -1 sinon.
getenv : retourne un élément de l'environnement.
char *getenv(const char *name);
Si l'opération est possible, cette fonction retourne un pointeur sur la valeur associée à son argument name ; si le nom
n'est pas défini dans l'environnement, retourne NULL.
XII.3.f. Opérations sur des entiers :
abs : retourne la valeur absolue d'un entier.
int abs(int x);
labs : valeur absolue pour des valeurs de type long.
long labs(long x);
div : divise deux entiers.
ldiv : divise deux entiers de type long.
div_t div(int numer, int denom);
ldiv_t ldiv(long lnumer, long ldenom);
Chaque fonction retourne une structure dont les éléments sont quotient (quot) et le reste (rem). Les éléments sont
des entiers pour div et des entiers longs pour ldiv.
Type div_t : Type des valeurs retournées par la fonction de division entière.
typedef struct
{
int quot, rem;
} div_t;
Type ldiv_t : Type des valeurs retournées par la fonction de division entre entiers longs.
typedef struct
{
long quot, rem;
} ldiv_t;
-27-

LICENCE SPI-EEA LANGAGE C M. Deloizy
XIII. Structures
Ces données sont construites par le programmeur à partir des données déjà définies (par le langage ou le programmeur).
Les structures permettent au programmeur de rassembler dans une même donnée un ensemble dřinformations liées.
Par exemple, on souhaite se constituer un fichier dřindividus contenant le nom, le prénom, lřage et le poids pour chaque
individu ; Ces informations étant propres à chaque individu, on préfère constituer une donnée unique contenant
lřensemble de ces informations ; Cette nouvelle donnée sřappelle en C une structure.
On pourra déclarer cette structure de la manière suivante :
struct T_Individu
{
char nom[40] ;
char prenom[40] ;
unsigned age ;
float poids;
} ;
champs de la structure
struct : mot clé définissant une structure
T_Individu : Nom du type de structure défini par le
programmeur.
Cette structure est composée de quatre champs (nom, prénom, âge et poids).
Avec cette définition, on a défini un type de donnée (de type struct T_Individu). On peut alors définir de nouvelles
données dans ce type :
struct T_Individu toto ;
struct T_Individu x, individu[20] ;
Dans cet exemple, toto représente une variable contenant le nom, le prénom, lřâge et le poids dřun individu.
Pour accéder à un champ de la variable toto, on utilise le caractère Ř.ř.
On pourra ainsi écrire :
printf("Entrer le nom : ") ;
scanf("%s",toto.nom) ;
toto.age=4 ;
toto.poids=12.3 ;
On peut mettre les structures sous forme de tableaux avec une déclaration du type :
struct T_Individu individu[20] ;
Dans ce cas, on peut accéder à lřélément i du tableau en écrivant individu[i], soit, par exemple pour son âge,
individu[i].age, comme dans lřexemple suivant :
printf("Entrer le nom n°%d : ",n) ;
scanf("%s",toto[n].nom) ;
scanf("%u",&toto[n].age) ;
scanf("%f",&toto[n].poids) ;
printf("%s : %u ans (%f kg)\n",toto[n].nom,toto[n].age,toto[n].poids) ;
Il est possible de définir une structure sans définir un type de structure avec la déclaration suivante :
struct
{
int forme ;
double perimetre ;
double aire ;
} objet[200], rectangle, disque;
Dans ce cas, il est bien sûr nécessaire de définir une ou plusieurs variables.
On peut initialiser les structures par la notation suivante :
struct T_Individu Homme =
{
"Dupont",
"Marcel",
24,
84.5
} ;
Cette initialisation peut se faire dans les classes dřallocation const, static ou auto (attention alors à lřefficacité du
programme).
Les structures étant des données de taille importante, il est plus efficace de les transmettre aux fonctions par
lřintermédiaire de pointeurs :
-28-

LICENCE SPI-EEA LANGAGE C M. Deloizy
Exemple :
struct T_Complexe {double re, im ; } ;
double module(struct T_Complexe *x)
{
return (*x).re*(*x).re+(*x).im*(*x).im;
}
Lřusage des pointeurs étant fréquent avec les structures et cette notation étant lourde et peu lisible, le C a défini une
autre notation lors de lřutilisation de pointeurs de structures :
double module(struct T_Complexe *x)
{
return x->re* x->re + x->im * x->im;
}
x->re se lit : le champ re de la structure pointée par x.
XIV. Le préprocesseur
Le préprocesseur est un programme invoqué automatiquement par le compilateur avant la réalisation de la compilation.
Son rôle est dřeffectuer des transformations sur le fichier source. Cřest en réalité le fichier texte créé qui sera transmis
au compilateur.
Les commandes du préprocesseur débutent par le caractère Ř#ř. Elles occupent toute la ligne débutant par Ř#ř et ne sont
pas terminées par Ř ;ř. On peut les étendre sur plusieurs lignes en ayant recours au caractère dřéchappement Ř\ř situé en
fin de ligne.
XIV.1. Commande include.
#include
ou
#include "fichier2"
Permet de substituer en lieu et place de la commande le contenu du fichier désigné.
Les caractères Řř indiquent au préprocesseur de rechercher dans les répertoires pris par défaut par le compilateur (en
général les fichiers dřen-tête livrés avec le compilateur). Si le fichier nřa pas été trouvé, il sera recherché dans le
répertoire de travail courant.
Les caractères Ř""ř demandent au préprocesseur de rechercher dans le répertoire de travail courant. Le programmeur
utilise en général cette notation pour inclure les fichiers ".h" conçus par lui-même.
XIV.2. Commande define.
Cette commande permet de définir des constantes ou des macro-définitions.
Constantes :
Exemple :
#define PI 3.14159265
Macro-définitions :
On définit ici la constante PI en indiquant sa valeur (sans Ř ;ř ni Ř=ř,…).
Par la suite, à chaque fois que le préprocesseur voit une donnée se nommant PI, il la substitue par sa
valeur (en réalisant une substitution de texte).
Exemple :
x = 3 * PI / 4 ;
sera remplacé par :
x = 3 * 3.14159265 / 4 ; (cette ligne sera effectivement lue par le compilateur).
Il est très important de ne pas mettre de Ř ;ř en fin de define, sinon, le compilateur lirait :
x = 3 * 3.14159265 ; / 4 ;
ce qui provoquerait évidemment une erreur à la compilation sur la ligne :
x = 3 * PI / 4 ;
qui paraît syntaxiquement correcte.
Les macro-définitions permettent de réaliser des pseudo-fonctions avec une transmission de paramètres
ressemblant à celui utilisé dans les fonctions. Le fonctionnement est cependant totalement différent,
puisque les paramètres seront utilisés pour réaliser des substitutions de texte. Ce dispositif sera donc
-29-

LICENCE SPI-EEA LANGAGE C M. Deloizy
beaucoup plus efficace en terme de rapidité dřexécution ; Par contre, la taille du code généré sera plus
importante.
Exemple :
#define produit(a,b) a*b
On pourra ensuite utiliser la macro-fonction produit de la manière suivante :
y = produit(3.0,4) ;
Le premier paramètre (a) sera remplacé par (3.0), et le second (b) par (4). Le compilateur verra donc la
ligne :
y = 3.0*4 ;
On peut utiliser la macro-fonction produit avec des expressions plus compliquées :
y = produit(3+1,4*2) ;
ce qui sera transposé par :
y = 3+1*4*2 ;
qui, compte tenu de la priorité des opérateurs, donne comme résultat 11 au lieu de 32 attendu.
Pour éviter ce type de problème, il est préférable dřencadrer lřexpression et les paramètres par des
parenthèses lors de la définition de macro-fonctions :
#define produit(a,b) ((a)*(b))
Ainsi, la substitution de texte donnera la ligne suivante :
y = ((3+1)*(4*2)) ;
qui est cette fois correcte.
XIV.3. Compilation conditionnelle
La compilation conditionnelle permet au programmeur dřexclure ou non des lignes de programmes selon la valeur ou
lřexistence de constantes.
Exemples :
#if test==1
… lignes source C 1
#else
… lignes source C 2
#endif
optionnel
Les lignes « source C 1 » seront compilées si la constante test vaut 1. Sinon, seules les lignes « source C 2 » seront
compilées.
On peut également utiliser à la place de la commande if les commandes :
#ifdef nom_de_constante
#ifndef nom_de_constante
Ces commandes permettent de tester lřexistence ou non dřune constante et de compiler ou non la suite.
Exemples :
#ifndef DEJA_COMP
#define DEJA_COMP
…
#endif
#if __TURBOC__
#include
#endif
Permet de ne pas compiler plusieurs fois la même section de
programme (utile lors de l’inclusion de fichiers).
Détection de la "signature" du compilateur afin d’inclure un
fichier d’en-tête non portable.
-30-

LICENCE SPI-EEA TRAVAUX DIRIGÉS M. Deloizy
TD1 : TYPES DE DONNÉES – CODAGE
I. Caractères.
I.1. Indiquer les codes ASCII des caractères suivants :
'A', 'B', 'q', '','*', '0' (zéro), '8', '\r', '\n', '\t'
I.2. La mémoire contient les données suivantes (hexadécimal) :
adresses
données
2A3C 43 27 65 73 74 20 65 6E
2A44 20 41 53 43 49 49 2E 00
Indiquer pour chaque octet le caractère correspondant.
II. Entiers.
On suppose ici que les poids faibles sont situés en adresse basse.
II.1. Écrire en hexadécimal puis en binaire le contenu de la mémoire pour les valeurs suivantes (entiers sur 16 bits) :
1234, 37840, 65535, -128, -1
II.2. Donner les résultats des opérations suivantes :
pour des entiers signés codés sur 16 bits
pour des entiers non signés codés sur 16 bits
pour des entiers signés codés sur 32 bits
1000 - 1024
25000 + 30535
65536 - 1
II.3. Calculer les résultats des opérations suivantes (opérateurs du C) :
Mettre le résultat en binaire, hexadécimal et décimal sur 8 bits.
25 & 51
25 | 51
25 ^ 51
~25
-25
III. Chaînes de caractères.
Indiquer le contenu mémoire obtenu avec les chaînes de caractères suivantes, selon deux codages possibles (nombre de
caractères en tête ou zéro terminal) :
"TOTO"
"Il fait chaud\n"
"02 + 20 = 22\n"
IV. Virgule flottante.
Étudier les résultats obtenus avec les nombres en virgule flottante codés sur 64 bits, selon la norme IEEE 754 :
e
x m2
S E' F
b 63 b 62 b 52 b 51 b 0
e : exposant
m : mantisse. 1.0 m < 2.0
S : signe. 1 bit. 0 : positif, 1 : négatif
E' = e+1023. 11 bits. 1 E' 2047
F = m-1. Partie fractionnaire de la mantisse. 52 bits.
Représenter le contenu mémoire correspondant aux valeurs 1.0, 2.0 et 5.0.
Quelle est la valeur positive la plus petite possible
Quelle est la valeur positive la plus grande possible
Quel est le nombre de chiffres significatifs
V. Tableaux
Soit un tableau d'entiers codés sur 16 bits et contenant les valeurs : { 2, 4, 8, 16, 32 }
Représenter le contenu de la mémoire correspondant à ce tableau.
Quel est le nombre d'octets nécessaire au stockage du tableau
-31-

LICENCE SPI-EEA TRAVAUX DIRIGÉS M. Deloizy
I. Écrire un programme affichant « BONJOUR » à lřécran.
TD2 : PREMIERS PROGRAMMES
II. Écrire un programme qui demande le prénom de lřutilisateur ainsi que son année de naissance. Ensuite, le
programme affichera un texte sous la forme suivante :
Bonjour "xxxxx" (prénom).
Ton année de naissance est dddd. (année de naissance)
III.a. Écrire un programme qui affiche la table de multiplication par 5 sous la forme :
5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
....
5 x 9 = 45
III.b. Modifier le programme précédent en créant une fonction mult à laquelle on transmet le numéro de la table à
afficher :
void mult(int table)
Utiliser cette fonction dans un programme qui demande à lřutilisateur le numéro de la table quřil souhaite visualiser. Le
programme continuera tant que lřutilisateur entre une valeur strictement positive.
TD3 : UTILISATION DE TABLEAUX.
I. Écrire une fonction qui demande à lřutilisateur de faire lřacquisition de n entiers sous la forme suivante :
Nombre de valeurs :
Valeur n° 1 :
Valeur n° 2 :
Valeur n° 3 :
....
Le prototype de cette fonction sera :
unsigned AcqTab(int tb[], unsigned NbMax);
La fonction retourne le nombre de valeurs saisies
tb est le tableau qui doit être chargé
NbMax est le nombre maximal de valeurs que peut contenir tb
II. Écrire une fonction qui compte le nombre de valeurs paires dans un tableau. Le prototype de cette fonction sera :
int nbpairs(int tab[], unsigned nbval);
nbval indique le nombre d'éléments contenus dans le tableau. Pourquoi ce paramètre est-il indispensable
III. Écrire une fonction qui remplit un tableau avec des nombres ni pairs, ni multiples de 3, en commençant par 5. Le
prototype de cette fonction sera :
void inittab(int tab[], unsigned nbval);
IV. Écrire une fonction trouvant le minimum et le maximum dans un tableau. Le prototype de cette fonction sera :
void minmax(double *tab, unsigned nbval, double *min, double *max);
V. Soient les valeurs suivantes stockées dans un tableau : { 2, -3, 1, 0, 5, 2 }
V.1 Effectuer une rotation à gauche du tableau afin d'obtenir : { -3, 1, 0, 5, 2, 2 }. Afficher le résultat.
V.2. Effectuer une rotation à droite du tableau initial afin d'obtenir : { 2,2,-3, 1, 0, 5 }
-32-

LICENCE SPI-EEA TRAVAUX DIRIGÉS M. Deloizy
TD4 : CONVERSIONS ASCII / NUMÉRIQUES
I. Écrire une fonction retournant un entier correspondant à la valeur numérique contenue dans une chaîne transmise en
paramètre. Le prototype de cette fonction sera :
int AscToInt(const char *decstr);
Cette fonction pourra être utilisée par exemple de la manière suivante :
...
x = AscToInt("26789");
...
Dans ce cas, x prendra la valeur numérique 26789.
On rappelle qu'un nombre abc peut s'écrire : a
10
b10
c
II. Écrire une fonction équivalente à la précédente permettant de convertir un nombre écrit en binaire, dont le prototype
sera :
int AscBinToInt(const char *binstr);
III. Faire de même pour un nombre écrit en hexadécimal.
int AscHexToInt(const char *hexstr);
IV. Que se passe-t-il si un caractère non prévu est contenu dans la chaîne Proposer un moyen de remédier à ce
problème.
TD5 : TRAITEMENTS SUR LES CHAÎNES
I. Écrire une fonction comptant le nombre de caractères contenus dans une chaîne. Le prototype de cette fonction sera :
int strlen(const char *str);
II.a. Écrire une fonction comptant le nombre de caractères identiques x contenus dans une chaîne. Le prototype de cette
fonction sera :
int nbcar(char x, const char *str); /* recherche x dans str */
II.b. Modifier la fonction précédente pour qu'elle ne différencie pas les minuscules et majuscules.
III. Écrire une fonction permettant de comparer deux chaînes de caractères. Le prototype de cette fonction sera :
int cmpstr(const char *str1, const char *str2);
L'entier retourné sera positif si str2 est situé après str1 dans un classement alphabétique et 0 si les chaînes sont
identiques.
IV. Écrire une fonction comptant le nombre de mots dans une phrase. Le prototype de cette fonction sera :
int nbmots(const char *str);
Par exemple, si str contient " le petit train passe dans l'alpage…\n " la fonction doit retourner la valeur 7.
TD6 : FICHIERS
I. Écrire un programme affichant à l'écran les fichiers textes dont les noms seront transmis sur la ligne de commande
lors de l'appel du programme.
II. Écrire un programme affichant le contenu d'un fichier quelconque en hexadécimal et en ASCII, sous la forme
suivante :
0000 4D 5A 78 00 BC 00 00 00 A0 04 01 00 FF FF 00 00 MZx.............
0010 00 00 00 00 00 01 00 00 1E 00 00 00 01 00 00 00 ................
0020 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0030 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0040 F6 38 F6 38 46 52 41 01 00 52 03 4E 53 43 4F 00 .8.8FRA..R.NSCO.
0050 03 06 00 16 00 1A 00 01 04 FF FF 48 03 02 00 56 ...........H...V
0060 03 03 00 66 03 08 00 7D 03 02 01 FF FF 8C 03 03 ...f............
0070 CC EA 03 9A 03 EB 03 D2 03 EC 03 FC 03 ED 03 14 ................
0080 04 EE 03 33 04 EF 03 69 04 F0 03 8A 04 F1 03 AE ...3...i........
0090 04 F2 03 C9 04 F3 03 00 05 F4 03 23 05 F5 03 57 ...........#...W
00A0 05 F6 03 7A 05 F7 03 84 05 F8 03 B1 05 F9 03 DE ...z............
00B0 05 FA 03 02 06 FB 03 17 06 FC 03 26 06 FD 03 35 ...........&...5
III. Statistiques sur un fichier
III.1. Écrire un programme qui compte les mots contenus dans un fichier texte.
III.2. (optionnel) Modifier le programme pour indiquer (dans l'ordre de la fréquence d'apparition) les mots présents dans
le fichier.
-33-

LICENCE SPI-EEA TRAVAUX PRATIQUES M. Deloizy
TP1 : DÉCLARATIONS, PREMIERS PROGRAMMES, DÉBOGAGE
I. Écrire un programme affichant "Bonjour".
II. Soit le programme suivant :
#include
/* Affichage de la table de multiplication par m */
void mtable(int m, int nmax)
{
int i;
for(i=1; i

LICENCE SPI-EEA TRAVAUX PRATIQUES M. Deloizy
TP2 : MANIPULATIONS DE CHAÎNES DE CARACTÈRES
I. Saisie de chaînes
Définir un tableau de 80 caractères.
Faire la saisie d'une chaîne de caractères (limitée à 20 caractères) en utilisant :
la fonction scanf
la fonction gets
la fonction fgets
Dans chaque cas,
Afficher normalement la chaîne saisie (en utilisant printf)
Afficher en hexadécimal le code ASCII des 80 octets du tableau. (On pourra concevoir une fonction qui
affiche en hexadécimal le contenu d'un tableau de caractères)
Y a-t-il des caractères indésirables dans la chaîne saisie
Que se passe-t-il si l'utilisateur entre plus de 20 caractères Comment remédier à ce problème
Écrire une fonction qui "nettoie" une chaîne saisie par fgets (en enlevant le caractère '\n' résiduel).
II. Traitements sur les chaînes
II.1. Écrire une fonction qui compte le nombre de voyelles contenues dans une chaîne (sans distinction des minuscules
et majuscules).
II.2. Écrire une fonction qui renverse une chaîne ("Toto" devient "otoT").
II.3. Écrire une fonction qui duplique chaque caractère d'une chaîne ("Toto" devient "TToottoo").
II.4. Écrire une fonction qui compte le nombre de mots contenus dans une chaîne.
-35-

LICENCE SPI-EEA TRAVAUX PRATIQUES M. Deloizy
TP3 : TABLEAUX DE DONNÉES
I. Acquisition de données
I.1. Déclarer un tableau de 40 entiers
Écrire une fonction permettant de saisir au clavier les nb premiers éléments du tableau (0 nb < 40).
Le prototype de cette fonction sera :
void AcqTab(int *tab, unsigned nb);
I.2. Écrire une fonction affichant à l'écran les n premiers nombres d'un tableau, en mettant nbl valeurs par ligne.
Le prototype de cette fonction sera :
void AffTab(int *tab, unsigned n, unsigned nbl);
II. Nombres aléatoires
II.1. Écrire une fonction qui remplit un tableau avec n valeurs aléatoires. On utilisera la fonction rand(), définie dans
stdlib.h. Afficher les résultats obtenus.
Exécuter plusieurs fois le programme. Conclure.
II.2. 2 Initialiser le générateur de nombres aléatoires en utilisant la fonction srand() (voir prototype). L'initialisation sera
réalisée à l'aide de la fonction time() (définie dans time.h).
Observer de nouveau les résultats obtenus.
II.3. Écrire une nouvelle fonction qui effectue un tirage de 6 valeurs aléatoires distinctes, et comprises entre 1 et 49.
Le prototype de cette fonction sera :
unsigned *Loto(void);
Cette fonction retourne un pointeur sur le tableau contenant les 6 valeurs du tirage.
III. Tris
III.1. Constituer un tableau de N valeurs aléatoires.
Classer en ordre croissant ce tableau en utilisant l'algorithme de votre choix.
III.2. Définir un tableau de chaînes de caractères.
Classer en ordre croissant, puis en ordre décroissant ce tableau en utilisant la fonction qsort.
2 Exercice optionnel
-36-

LICENCE SPI-EEA TRAVAUX PRATIQUES M. Deloizy
TP4 : FICHIERS
I. Lecture d'un fichier texte
Éditer (avec un éditeur de textes) un texte quelconque de quelques lignes.
Enregistrer ce fichier sur le disque.
Créer un programme qui lit ce fichier et affiche son contenu.
Le programme affichera finalement le nombre de lignes et de caractères composant le fichier.
II. Écriture d'un fichier texte
Écrire un programme qui demande à l'utilisateur son nom, prénom, poids, age et sexe (cf. TP1) et sauvergarde ces
informations sur le disque dans un fichier texte.
Le nom du fichier sera composé du nom de l'individu, suivi d'un nombre de 3 chiffres. Ce nombre est incrémenté
automatiquement si nécessaire, afin de ne pas effacer un fichier éventuellement existant :
Par exemple, pour Dupont, lors de la 1 ère sauvegarde on écrit dans "Dupont000.dat".
Lors de la 2 ème sauvegarde, le fichier créé serait : "Dupont001.dat", etc …
III. Lecture / Écriture d'un fichier texte
Écrire un programme qui lit un fichier texte, renverse les lignes et écrit le résultat dans un nouveau fichier.
Si le fichier à lire contient à l'origine :
Bonjour
Il fait beau
On doit obtenir dans le nouveau fichier :
ruojnoB
uaeb tiaf lI
-37-

LICENCE SPI-EEA TRAVAUX PRATIQUES M. Deloizy
TP5 : STRUCTURES
I. Définition d'une structure
Définir la structure T_Quot de la manière suivante :
typedef struct {
int num ;
int den ;
} T_Quot ;
Cette structure permet de manipuler des nombres rationnels en indiquant par la valeur du numérateur et la valeur du
dénominateur.
II. Encombrement mémoire
Observer (avec l'opérateur sizeof) l'encombrement mémoire de cette structure.
III. Tableau de structures
Définir un tableau permettant de mémoriser 1000 structures, en initialisant les deux premières structures avec les
valeurs 16/9 et 4/3.
Indiquer l'encombrement mémoire de ce tableau.
IV. Acquisition et affichage des champs
Écrire une fonction permettant d'acquérir au clavier une structure T_Quot.
Cette fonction posera les questions suivantes :
Entrer le numérateur :
Entrer le dénominateur :
Le prototype de cette fonction sera :
void AcqQuot(T_Quot *q);
Écrire une fonction qui affiche la valeur de la structure sous la forme : nnn / ddd (Ex : 16/9)
Le prototype de cette fonction sera :
void AffQuot(T_Quot *q);
Écrire une fonction qui affiche la valeur numérique de la structure sous la forme : xxx.xxx (Ex. : 1.778)
Le prototype de cette fonction sera :
void AffValQuot(T_Quot *q);
V. Fonctions de manipulation associées :
Écrire les fonctions suivantes :
Multiplication de 2 rationnels :
T_Quot *MulQuot(T_Quot *q1, T_Quot *q2) ;
Multiplie (*q1) et (*q2). Range le résultat dans une mémoire interne à la fonction dont lřadresse est renvoyée.
Addition de 2 rationnels :
T_Quot *AddQuot(T_Quot *q1, T_Quot *q2) ;
Ajoute (*q1) et (*q2). Range le résultat dans une mémoire interne à la fonction dont lřadresse est renvoyée.
3 Simplification de rationnels :
void SimplQuot(T_Quot *q) ;
Simplifie la fraction contenue dans (*q). Range le résultat dans (*q).
On utilisera un algorithme de recherche du pgcd :
Algorithme d’Euclide
ENTREE : Deux entiers a et b. - SORTIE : Leur plus grand diviseur commun, pgcd(a,b).
1. Faire tant que le reste est non nul :
Division entière avec reste de a et b : a = q · b + r
a ← b; b ← r
2. Retourner b, qui est alors le plus grand diviseur commun.
Exemple : Calcul du pgdc de 2926 et 30030. On obtient le tableau suivant.
a b q r
2926 30030 0 2926
30030 2926 10 770
2926 770 3 616
770 616 1 154
616 154 4 0
Le resultat est donc : pgdc(30030, 2926) = 154.
3 Exercice optionnel
-38-

LICENCE SPI-EEA TRAVAUX PRATIQUES M. Deloizy
TP6 : ÉTUDE DE FONCTIONS MATHÉMATIQUES
I. Définition de fonctions mathématiques
Écrire les fonctions (informatiques) permettant de calculer les fonctions mathématiques suivantes :
f ( x)
1
10
i0
sin (2 i
1)
x
2 i
1
sin( x)
f
2
( x)
f3(
x)
sin(10
x)
exp(
x)
x
Constituer un tableau de pointeurs de fonctions, permettant d'accéder par la suite aux fonctions préalablement définies.
II. Calcul des fonctions
Écrire un programme qui demande à l'utilisateur :
le numéro de la fonction qu'il souhaite étudier (1, 2 ou 3)
la valeur minimale de l'abscisse (Xmin)
la valeur maximale de l'abscisse (Xmax)
le nombre de points à utiliser pour l'étude (nbp)
Le programme devra créer de manière dynamique un tableau permettant de ranger les nbp points calculés (les
ordonnées) de la fonction (utiliser malloc(), définie dans stdlib.h)
On cherchera ensuite dans ce tableau les valeurs minimale et maximale de la fonction. Ces informations seront affichées
à l'écran.
Remarque : On n'oubliera pas de libérer l'espace mémoire alloué dynamiquement dès que les données ne sont plus
nécessaires (utilisation de free()).
III. Traitement des exceptions.
Dans certains cas, la fonction mathématique peut déclencher une erreur (par exemple une division par 0). Prévoir la
résolution du problème en utilisant la fonction signal(), définie dans signal.h. Cette fonction permet l'appel d'une
fonction de gestion d'erreur dès qu'un "signal" est capté. Dans notre cas, on utilisera le signal SIGFPE (Floating Point
Exception).
IV. Écriture des résultats dans un fichier
Écrire une fonction permettant de ranger les couples (abscisses, ordonnées) dans un fichier texte. Chaque ligne du
fichier qui contiendra les valeurs de l'abscisse et de l'ordonnée, séparées par un caractère ';'.
Ce fichier pourra être récupéré par un autre programme, comme un tableur (type Excel) et ceci permettra ainsi de
manière simple de réaliser le tracé de la fonction 4 .
V. Écriture d'une fonction de gestion d'erreur
Le programme écrit peut provoquer des erreurs. Écrire une fonction permettant de mettre fin au programme (utiliser la
fonction exit()), en affichant un message d'erreur explicite.
Cette fonction aura le prototype suivant (et utilisera vprintf()) :
void ErrPrintf(const char *format, ...);
On pourra ainsi appeler cette fonction de la manière suivante :
ErrPrintf("Xmax [%G] doit être supérieur à Xmin [%G].",Xmax,Xmin);
ou bien :
ErrPrintf("Le fichier '%s' ne peut être ouvert",nom_fichier);
etc.…
4 Exercice facultatif.
-39-

LICENCE SPI-EEA TRAVAUX PRATIQUES M. Deloizy
TP7 : ACQUISITION ET TRAITEMENT DE DONNÉES
I. Signal analogique
I.1 Échantillonner un signal analogique avec les cartes d'entrées-sorties.
On prendra :
F E = 1KHz
Nombre d'échantillons = 1024
I.2. Déterminer numériquement :
Les valeurs extrêmes du signal (en volts)
La valeur et l'instant de la plus forte pente
II. Filtre numérique.
On met en œuvre un filtre dont l'équation de récurrence s'écrit :
ek
1
yk
yk
1
yk
N
U
filtre
Y
Déterminer expérimentalement la nature du filtre.
La fréquence d'échantillonnage est égale à 1 kHz.
Quels sont le gain et la fréquence de coupure pour N = 1 et N = 16
-40-

LICENCE SPI-EEA TABLES DE CODAGE DES CARACTÈRES M. Deloizy
ASCII :
EBCDIC :
Windows-1252 (CP1252)
x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI
1x DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US
2x SP ! " # $ % & ' ( ) * + , - . /
3x 0 1 2 3 4 5 6 7 8 9 : ; < = >
4x @ A B C D E F G H I J K L M N O
5x P Q R S T U V W X Y Z [ \ ] ^ _
6x ` a b c d e f g h i j k l m n o
7x p q r s t u v w x y z { | } ~ DEL
8x € ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ Ţ
9x Ř ř Ŗ ŗ • Ŕ ŕ ˜ š › œ ţ Ÿ
Ax NBSP ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ® ¯
Bx ° ± ² ³ ´ µ · ¸ ¹ º » ¼ ½ ¾ ¿
Cx À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï
Dx Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß
Ex à á â ã ä å æ ç è é ê ë ì í î ï
Fx ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ
-41-

LICENCE SPI-EEA PROTOTYPES (CSTDLIB) M. Deloizy
void assert(int expression);
int isalnum(int c);
int isalpha(int c);
int iscntrl(int c);
int isdigit(int c);
int isgraph(int c);
int islower(int c);
int isprint(int c);
int ispunct(int c);
int isspace(int c);
int isupper(int c);
int isxdigit(int c);
int tolower(int c);
int toupper(int c);
errno
EDOM
ERANGE
FLT_RADIX
FLT_ROUNDS
FLT_DIG
DBL_DIG
LDBL_DIG
FLT_EPSILON
DBL_EPSILON
LDBL_EPSILON
FLT_MANT_DIG
DBL_MANT_DIG
LDBL_MANT_DIG
FLT_MAX
DBL_MAX
LDBL_MAX
FLT_MAX_EXP
DBL_MAX_EXP
LDBL_MAX_EXP
FLT_MIN
DBL_MIN
LDBL_MIN
FLT_MIN_EXP
DBL_MIN_EXP
LDBL_MIN_EXP
BIBLIOTHÈQUES (CSTDLIB)
CHAR_BIT
CHAR_MAX
CHAR_MIN
SCHAR_MAX
SCHAR_MIN
UCHAR_MAX
SHRT_MAX
SHRT_MIN
USHRT_MAX
INT_MAX
INT_MIN
-42-

LICENCE SPI-EEA PROTOTYPES (CSTDLIB) M. Deloizy
UINT_MAX
LONG_MAX
LONG_MIN
ULONG_MAX
struct lconv
struct lconv* localeconv(void);
char* setlocale(int category, const char* locale);
LC_ALL
LC_NUMERIC
LC_MONETARY
LC_COLLATE
LC_CTYPE
LC_TIME
NULL
HUGE_VAL
double exp(double x);
double log(double x);
double log10(double x);
double pow(double x, double y);
double sqrt(double x);
double ceil(double x);
double floor(double x);
double fabs(double x);
double ldexp(double x, int n);
double frexp(double x, int* exp);
double modf(double x, double* ip);
double fmod(double x, double y);
double sin(double x);
double cos(double x);
double tan(double x);
double asin(double x);
double acos(double x);
double atan(double x);
double atan2(double y, double x);
double sinh(double x);
double cosh(double x);
double tanh(double x);
jmp_buf
int setjmp(jmp_buf env);
void longjmp(jmp_buf env, int val);
SIGABRT
SIGFPE
SIGILL
SIGINT
SIGSEGV
SIGTERM
SIG_DFL
SIG_ERR
SIG_IGN
void (*signal(int sig, void (*handler)(int)))(int);
int raise(int sig);
-43-

LICENCE SPI-EEA PROTOTYPES (CSTDLIB) M. Deloizy
va_list
void va_start(va_list ap, lastarg);
type va_arg(va_list ap, type);
void va_end(va_list ap);
NULL
offsetof(stype, m)
ptrdiff_t
size_t
BUFSIZ
EOF
FILENAME_MAX
FOPEN_MAX
L_tmpnam
NULL
SEEK_CUR
SEEK_END
SEEK_SET
TMP_MAX
_IOFBF
_IOLBF
_IONBF
stdin
stdout
stderr
FILE
fpos_t
size_t
FILE* fopen(const char* filename, const char* mode);
FILE* freopen(const char* filename, const char* mode, FILE* stream);
int fflush(FILE* stream);
int fclose(FILE* stream);
int remove(const char* filename);
int rename(const char* oldname, const char* newname);
FILE* tmpfile();
char* tmpnam(char s[L_tmpnam]);
int setvbuf(FILE* stream, char* buf, int mode, size_t size);
void setbuf(FILE* stream, char* buf);
int fprintf(FILE* stream, const char* format, ...);
int printf(const char* format, ...);
int sprintf(char* s, const char* format, ...);
int vfprintf(FILE* stream, const char* format, va_list arg);
int vprintf(const char* format, va_list arg);
int vsprintf(char* s, const char* format, va_list arg);
int fscanf(FILE* stream, const char* format, ...);
int scanf(const char* format, ...);
int sscanf(char* s, const char* format, ...);
int fgetc(FILE* stream);
char* fgets(char* s, int n, FILE* stream);
int fputc(int c, FILE* stream);
char* fputs(const char* s, FILE* stream);
int getc(FILE* stream);
int getchar(void);
char* gets(char* s);
int putc(int c, FILE* stream);
int putchar(int c);
int puts(const char* s);
int ungetc(int c, FILE* stream);
size_t fread(void* ptr, size_t size, size_t nobj, FILE* stream);
-44-

LICENCE SPI-EEA PROTOTYPES (CSTDLIB) M. Deloizy
size_t fwrite(const void* ptr, size_t size, size_t nobj, FILE* stream);
int fseek(FILE* stream, long offset, int origin);
long ftell(FILE* stream);
void rewind(FILE* stream);
int fgetpos(FILE* stream, fpos_t* ptr);
int fsetpos(FILE* stream, const fpos_t* ptr);
void clearerr(FILE* stream);
int feof(FILE* stream);
int ferror(FILE* stream);
void perror(const char* s);
EXIT_FAILURE
EXIT_SUCCESS
RAND_MAX
NULL
div_t
ldiv_t
size_t
int abs(int n);
long labs(long n);
div_t div(int num, int denom);
ldiv_t ldiv(long num, long denom);
double atof(const char* s);
int atoi(const char* s);
long atol(const char* s);
double strtod(const char* s, char** endp);
long strtol(const char* s, char** endp, int base);
unsigned long strtoul(const char* s, char** endp, int base);
void* calloc(size_t nobj, size_t size);
void* malloc(size_t size);
void* realloc(void* p, size_t size);
void free(void* p);
void abort();
void exit(int status);
int atexit(void (*fcm)(void));
int system(const char* s);
char* getenv(const char* name);
void* bsearch(const void* key, const void* base, size_t n, size_t size, int
(*cmp)(const void* keyval, const void* datum));
void qsort(void* base, size_t n, size_t size, int (*cmp)(const void*, const
void*));
int rand(void);
void srand(unsigned int seed);
NULL
size_t
char* strcpy(char* s, const char* ct);
char* strncpy(char* s, const char* ct, size_t n);
char* strcat(char* s, const char* ct);
char* strncat(char* s, const char* ct, size_t n);
int strcmp(const char* cs, const char* ct);
int strncmp(const char* cs, const char* ct, size_t n);
int strcoll(const char* cs, const char* ct);
char* strchr(const char* cs, int c);
char* strrchr(const char* cs, int c);
size_t strspn(const char* cs, const char* ct);
size_t strcspn(const char* cs, const char* ct);
char* strpbrk(const char* cs, const char* ct);
char* strstr(const char* cs, const char* ct);
size_t strlen(const char* cs);
char* strerror(int n);
char* strtok(char* s, const char* t);
-45-

LICENCE SPI-EEA PROTOTYPES (CSTDLIB) M. Deloizy
size_t strxfrm(char* s, const char* ct, size_t n);
void* memcpy(void* s, const void* ct, size_t n);
void* memmove(void* s, const void* ct, size_t n);
int memcmp(const void* cs, const void* ct, size_t n);
void* memchr(const void* cs, int c, size_t n);
void* memset(void* s, int c, size_t n);
CLOCKS_PER_SEC
NULL
clock_t
time_t
struct tm
clock_t clock(void);
time_t time(time_t* tp);
double difftime(time_t time2, time_t time1);
time_t mktime(struct tm* tp);
char* asctime(const struct tm* tp);
char* ctime(const time_t* tp);
struct tm* gmtime(const time_t* tp);
struct tm* localtime(const time_t* tp);
size_t strftime(char* s, size_t smax, const char* fmt, const struct tm* tp);
-46-

LICENCE SPI-EEA MÉMENTO M. Deloizy
MÉMENTO DU LANGAGE C
D’après : http://www.inln.cnrs.fr/IMG/pdf/memento-2.pdf
Structure de base
#include
#include
int main()
{
// Programme...
return 0 ;
}
inclusion des en-têtes de librairie
début de la fonction principale
retour de la fonction principale système dřexploitation
Variables et constantes
int i=165;
Nombre entier
long j=8219829; short k=1; Nombres entiers long et courts
char c=’z’;
Caractère (1 octet en général).
float x=3.162e0 ;
Flottant codé souvent sur 4 octets (32 bits)
double y=3.1415926535e0 ; Flottant codé souvent sur 8 octets
double tab[10] ; Tableau de dix double. Indices 0 à 9.
char nom[30] = "fichier" ; Chaîne de caractères (tableau de char)
const int N=10 ;
Constante
#define N 10
ŖConstanteŗ (en fait substitution)
Entrées et sorties
Entrées/sorties standards :
float x;
scanf("%f", &x); lecture de x au clavier
printf("Le resultat est : %f \n", x); écriture de x à lřécran
Les indicatifs suivants sont utilisés pour les différents types de données.
%f float %lf double %s char[], chaîne
%d int %c char %x entier en hexadécimal, adresse
On peut également entrer %15.10lf pour avoir un double affiché sur 15 cases avec 10 chiffres après la virgule.
Fichiers :
FILE *masortie, *monentree ;
pointeurs sur des fichiers
monentree = fopen("entree.txt","r") ; ouverture en lecture du fichier entree.txt
masortie = fopen("sortie.txt","w") ; ouverture en écriture du fichier sortie.txt
fscanf(monentree,"%f",&x);
lecture de la variable x dans le fichier entree.txt
fprintf(masortie,"%f\n",x);
écriture dans le fichier sortie.txt
close(monentree) ; close(masortie) ; fermeture des fichiers
Tests, choix, boucles
La structure de contrôle if-else if-else
if (x == y && a != b )
{ à faire si x = y ET a b
}
else if (x > y || a y OU a ≤ b
}
else
{ à faire si les deux premières propositions sont fausses
}
-47-

LICENCE SPI-EEA MÉMENTO M. Deloizy
La boucle for
for(i=0;i 0.001)
{ action à répéter tant que > 10 −3
}
La boucle do-while
do
{ action à répéter tant que > 10 −3
} while(Delta > 0.001) ;
Dans la boucle while, le test sřeffectue une première fois avant de commencer la boucle. Dans la boucle do-while, le
test sřeffectue après la boucle et la boucle sera donc faite au moins une fois.
Fonctions
Fonction retournant une valeur
int f1(float x, char c) fonction prenant un flottant et un char et retournant un entier
{ texte de la fonction
· · ·
return 1 ; retourne un entier à la fin
}
Fonction ne retournant rien
Une fonction de type void ne retourne pas de valeur.
void f2(float x[]) fonction prenant un tableau de flottants et ne retournant rien
{ texte de la fonction
pas de retour à la fin ou return seul. (return ;)
}
Déclaration d’une fonction et utilisation
On déclare une fonction pour lřutiliser dans une autre :
int f1(float, char) ;
void f2(float[]) ;
On lřutilise avec des variables ou des constantes comme paramètres :
i = f1(y,c);
j = f1(10.0,’y’);
f2(tab) ;
Pointeurs et allocation de mémoire
Pointeurs
float *pf ; un pointeur sur float (variable contenant une adresse mémoire)
float x=3 ; un float égal à 3
pf = &x ; le pointeur devient égal à lřadresse de x
*pf = 4 ; la valeur stockée à cette adresse est modifiée
Allocation de mémoire
On peut réserver de lřespace en mémoire après le démarrage du programme grâce à la fonction malloc qui retourne un
pointeur sans type particulier.
pf = (float*) malloc(10*sizeof(float));
malloc réserve 10 cases en mémoire pouvant chacune contenir un flottant. Elle renvoie lřadresse de la première case
mémoire. On transforme cette adresse en type float*, puis on la stocke dans pf.
On accède au contenu de la case mémoire 5 de différentes manières
x = pf[5] ; ou bien x = *(pf+5) ;
On libère la mémoire à lřaide de la commande free
free(pf) ;
-48-

LICENCE SPI-EEA MÉMENTO M. Deloizy
Pointeur de fonction
double (*pfonc)(double) ; Pointeur de fonction pouvant pointer vers une fonction qui prend un double en
paramètre et retourne un double.
pfonc = cos ; Le pointeur pointe sur cosinus
x = pfonc(3.14) ; il remplace cosinus
Structures et définition de type
On peut définir un type comp (nombres complexes) de la manière suivante :
typedef struct
{ double re ;
double im;
} comp ;
On lřutilise
comp z1 ;
z1.re = 1.0 ; z1.im = 2.0 ;
En vrac...
On dispose des opérateurs arithmétiques : +, -, *, / et %. Ce dernier donne le reste dans une division entière.
Lřopérateur ^ correspond au OU exclusif (opération bit à bit)
On dispose des raccourcis i++ pour i=i+1, x+=3.5 pour x = x + 3.5 .
De même on a les raccourcis : i--, x*=2, x/=1.5...
Lřopérateur (float) convertit en flottant, (int) en entier...
Des constantes mathématiques sont définies avec une grande précision dans math.h. Notamment π sous le nom
de M_PI.
-49-

LICENCE SPI-EEA TABLE DES MATIÈRES M. Deloizy
Table des Matières
Introduction .................................................................................................................................................................. 2
Description du langage ................................................................................................................................................. 2
I. Constitution dřun programme C ......................................................................................................................... 2
I.1. Généralités .................................................................................................................................................. 2
I.2. Syntaxe ....................................................................................................................................................... 2
I.2.a. Commentaires. ................................................................................................................................. 2
I.2.b. Noms de symboles. .......................................................................................................................... 2
I.2.c. Minuscules et majuscules. ............................................................................................................... 2
I.3. Mots clés ..................................................................................................................................................... 3
II. Types de variables ............................................................................................................................................. 3
II.1. Les types de base ....................................................................................................................................... 3
II.1.a. char : ................................................................................................................................................ 3
II.1.b. int : .................................................................................................................................................. 3
II.1.c. float : ............................................................................................................................................... 3
II.2. Les types dérivés ....................................................................................................................................... 3
II.2.a. unsigned char : ................................................................................................................................ 3
II.2.b. signed char : .................................................................................................................................... 3
II.2.c. unsigned int ou unsigned : ............................................................................................................... 3
II.2.d. short : .............................................................................................................................................. 3
II.2.e. unsigned short : ............................................................................................................................... 3
II.2.f. long int ou long : .............................................................................................................................. 3
II.2.g. unsigned long int ou unsigned long : .............................................................................................. 3
II.2.h. double : ........................................................................................................................................... 3
II.2.i. long double : .................................................................................................................................... 4
II.2.j. Dynamique des nombres : ................................................................................................................ 4
II.3. Les types composés ................................................................................................................................... 4
II.3.a. les tableaux : .................................................................................................................................... 4
II.3.b. les structures : ................................................................................................................................. 4
II.3.c. les unions : ...................................................................................................................................... 5
II.4. Autres types ............................................................................................................................................... 5
II.4.a. les types définis par le programmeur .............................................................................................. 5
II.4.b. void ................................................................................................................................................. 5
III. La déclaration des variables ............................................................................................................................. 5
IV. Constantes ....................................................................................................................................................... 5
V. Organisation générale d'un module ................................................................................................................... 7
VI. Constitution d'une fonction ............................................................................................................................. 7
VI.1. Définition d'une fonction ......................................................................................................................... 7
VI.2. Prototypes ................................................................................................................................................ 8
VII. Blocs d'instructions ........................................................................................................................................ 8
VII.1. Opérateurs ............................................................................................................................................... 9
VII.1.a. Opérateurs arithmétiques :............................................................................................................ 9
VII.1.b. Opérateurs logiques : ................................................................................................................... 9
VII.1.c. Opérateurs d'affectation : ............................................................................................................. 9
VII.1.d. Opérateur ternaire : .................................................................................................................... 10
VII.1.e. Séquenceur : ............................................................................................................................... 10
VII.1.f. Opérateurs unaires : .................................................................................................................... 10
VII.2. Expressions ........................................................................................................................................... 11
VII.3. Instructions de contrôle de déroulement ............................................................................................... 11
VII.3.a. Tests si … sinon … ..................................................................................................................... 11
VII.3.b. Boucles tant que … faire : .......................................................................................................... 11
VII.3.c. Boucles faire … tant que : .......................................................................................................... 12
VII.3.d. Boucles for .............................................................................................................................. 12
VII.3.e. Tests énumératifs (switch … case) ............................................................................................. 12
VII.3.f. Rupture de séquence break : .................................................................................................... 13
VII.3.g. Rupture de séquence continue : ............................................................................................ 13
VII.3.h. Branchements inconditionnels ................................................................................................... 13
VIII. Portée des données ...................................................................................................................................... 13
VIII.1. Donnée globale au programme ............................................................................................................ 14
VIII.2. Donnée locale à un module ................................................................................................................. 14
VIII.3. Donnée locale à une fonction .............................................................................................................. 14
-50-

LICENCE SPI-EEA TABLE DES MATIÈRES M. Deloizy
VIII.4. Donnée locale à un bloc d'instructions ................................................................................................ 14
IX. Classes d'allocation........................................................................................................................................ 14
IX.1. static ....................................................................................................................................................... 15
IX.2. auto ......................................................................................................................................................... 15
IX.3. const ....................................................................................................................................................... 15
IX.4. register.................................................................................................................................................... 15
IX.5. volatile.................................................................................................................................................... 15
X. Les pointeurs ................................................................................................................................................... 16
X.1. Définition ................................................................................................................................................ 16
X.2. Arithmétique des pointeurs...................................................................................................................... 16
X.3. Utilité des pointeurs ................................................................................................................................. 17
X.3.a. Les tableaux ..................................................................................................................................... 17
X.3.b. Chaînes de caractères ....................................................................................................................... 17
X.3.c. Fonctions et pointeurs ...................................................................................................................... 17
XI. Les fichiers .................................................................................................................................................... 18
XI.1. Notion de flux ........................................................................................................................................ 18
XI.2. Flux en sortie. ......................................................................................................................................... 19
XI.3. Flux en entrée. ........................................................................................................................................ 19
XI.4. Fonctions de gestion ............................................................................................................................... 19
XII. Fonctions standard ....................................................................................................................................... 19
XII.1. Manipulation de chaînes de caractères ............................................................................... 19
XII.1.a. Traitement de données brutes ..................................................................................................... 20
XII.1.b. Copie et concaténation : ............................................................................................................. 20
XII.1.c. Comparaisons de chaînes de caractères : .................................................................................... 20
XII.1.d. Recherche de séquences : ........................................................................................................... 21
XII.1.e. Fonctions diverses : .................................................................................................................... 21
XII.2. Entrées sorties ...................................................................................................................... 22
XII.2.a. Entrées / Sorties formatées : ....................................................................................................... 22
XII.2.b. Spécifications de format (pour printf et scanf) : ......................................................................... 22
XII.2.c. Fonctions d'entrées : ................................................................................................................... 23
XII.2.d. Fonctions de sorties : .................................................................................................................. 23
XII.2.e. Gestion de fichiers (flux) :.......................................................................................................... 24
XII.2.f. Exemple : copie de fichier texte ................................................................................................. 25
XII.3. Fonctions utilitaires : ........................................................................................................... 25
XII.3.a. Conversion de chaînes de caractères : ........................................................................................ 25
XII.3.b. Générateur de nombres aléatoires : ............................................................................................ 26
XII.3.c. Fouilles et tris : ........................................................................................................................... 26
XII.3.d. Allocation de mémoire : ............................................................................................................. 26
XII.3.e. Fonctions système : .................................................................................................................... 27
XII.3.f. Opérations sur des entiers : ......................................................................................................... 27
XIII. Structures .................................................................................................................................................... 28
XIV. Le préprocesseur ......................................................................................................................................... 29
XIV.1. Commande include. ............................................................................................................................. 29
XIV.2. Commande define. .............................................................................................................................. 29
Constantes : ................................................................................................................................................. 29
Macro-définitions : ..................................................................................................................................... 29
XIV.3. Compilation conditionnelle ................................................................................................................. 30
TD1 : Types de données – Codage ............................................................................................................................ 31
TD2 : Premiers programmes ..................................................................................................................................... 32
TD3 : Utilisation de tableaux. .................................................................................................................................... 32
TD4 : Conversions ASCII / numériques ................................................................................................................... 33
TD5 : Traitements sur les chaînes ............................................................................................................................. 33
TD6 : Fichiers ............................................................................................................................................................. 33
TP1 : Déclarations, Premiers programmes, Débogage ........................................................................................... 34
TP2 : Manipulations de Chaînes de Caractères....................................................................................................... 35
TP3 : Tableaux de données ........................................................................................................................................ 36
TP4 : Fichiers .............................................................................................................................................................. 37
TP5 : Structures ......................................................................................................................................................... 38
-51-

LICENCE SPI-EEA TABLE DES MATIÈRES M. Deloizy
TP6 : Étude de fonctions mathématiques ................................................................................................................. 39
TP7 : Acquisition et Traitement de données ............................................................................................................ 40
Bibliothèques (Cstdlib)............................................................................................................................................... 42
................................................................................................................................................................. 42
................................................................................................................................................................. 42
................................................................................................................................................................. 42
................................................................................................................................................................... 42
................................................................................................................................................................. 42
................................................................................................................................................................ 43
.................................................................................................................................................................. 43
............................................................................................................................................................... 43
................................................................................................................................................................ 43
................................................................................................................................................................ 44
................................................................................................................................................................ 44
.................................................................................................................................................................. 44
................................................................................................................................................................. 45
................................................................................................................................................................. 45
................................................................................................................................................................... 46
Mémento du langage C .............................................................................................................................................. 47
Structure de base ...................................................................................................................................................... 47
Variables et constantes ............................................................................................................................................. 47
Entrées et sorties ...................................................................................................................................................... 47
Fichiers : .................................................................................................................................................................. 47
Tests, choix, boucles ................................................................................................................................................ 47
La structure de contrôle if-else if-else ................................................................................................................. 47
La boucle for ........................................................................................................................................................ 48
La boucle while ................................................................................................................................................... 48
La boucle do-while .............................................................................................................................................. 48
Fonctions .................................................................................................................................................................. 48
Fonction retournant une valeur ............................................................................................................................ 48
Fonction ne retournant rien .................................................................................................................................. 48
Déclaration dřune fonction et utilisation ............................................................................................................. 48
Pointeurs et allocation de mémoire .......................................................................................................................... 48
Pointeurs .............................................................................................................................................................. 48
Allocation de mémoire ........................................................................................................................................ 48
Pointeur de fonction............................................................................................................................................. 49
Structures et définition de type ................................................................................................................................ 49
En vrac... .................................................................................................................................................................. 49
Table des Matières ........................................................................................................................................................... 50
-52-