Algorithmique et Langage - Pages de Michel Deloizy - Free

Licence L1 

Algorithmique et Langage 

II22 

Cours 

Travaux dirigés 

Travaux pratiques 

M. Deloizy http://michel.deloizy.free.fr 

Édition du 15 janvier 2005

Introduction à l'informatique 

Notion d'algorithme 

Généralités 

Rappels 

M. Deloizy Informatique - Généralités 1 


Algorithme 

• Ensemble de règles opératoires propres à 

un calcul 

• Calcul, enchaînement des actions 

nécessaires à l'accomplissement d'une 

tâche 

• Petit Robert : 

Méthode proposée pour le traitement d'un 

problème par un automate 

Humain ou machine Traitement systématique 


Exemple d'algorithme 

• Recette de cuisine : 

– Nom de la recette 

– Ingrédients 

– Réalisation 

… Gâteau au yaourt … 


1

Définition d'un algorithme 

• But recherché 

– (que doit faire l'algorithme ?) 

… un gâteau au yaourt pour 6 personnes 

• Outils disponibles 

– Opérateurs, données, règles associées 

Yaourts, œufs, sucre, huile, sel, levure, moule, four 

• Enchaînement des actions 

– Ordre de traitement 

Description de la séquence d'actions nécessaires à la 

réalisation de la recette 

Algorithme universel 

• Non lié à un langage de programmation 

• Non lié à une machine 

Mais 

• Peut être plus ou moins adapté à un type 

d'automate 



Exemple : Multiplication 

Multiplication à la Russe 

• Classique : 

34 x 15 → 510 

Nécessite la connaissance des tables de 

multiplication 

34 

17 

8 

4 

2 

1 

15 

30 

60 

120 

240 

480 

510 

Uniquement 

des multiplications 

par 2, 

des divisions par 2 

et des additions 

→ adapté au calcul 

par des circuits 

logiques 



2

Algorithmes multiples 

• Pour résoudre une application, il existe 

souvent plusieurs algorithmes. 

Le choix sera fait selon : 

– La rapidité d'exécution 

– La facilité de mise en œuvre par l'automate 

– Le type de données à traiter 

Support matériel 

Architecture d'un ordinateur 



Architecture d'un ordinateur 

• 3 éléments : 

– Le processeur 

– La mémoire 

– Les périphériques 

Le processeur 

• Le cœur du système 

• Rôle : 

– Traiter des informations binaires 

• Lire des informations depuis la mémoire 

• Écrire des informations dans la mémoire 

• Réaliser des opérations élémentaires sur infos. 

• Traitement des informations selon un "programme" 

→ lu de manière séquentielle au rythme d'une horloge 



3

La mémoire 

• Stockage 

– Des informations 

– Des programmes 

•ROM 

– Données permanentes 

•RAM 

– Données temporaires 

– Utilisée par le processeur pour le traitement 

des données et des programmes 

La mémoire de masse 

• Stockage de grande capacité 

– Bandes magnétiques, disques, CD, DVD 

• Mémoire non volatile 

• Réinscriptible 

• Pas d'accès direct par le processeur 

→ mémoire "lente" (quelques ms) 

RAM : quelques ns 



Les Périphériques 

• Organes de communication 

• Disposés entre le processeur et le monde 

extérieur 

• Permettent les échanges avec : 

– L'utilisateur 

– Une autre machine 

• Exemples : 

– Écran, clavier, ports série ou parallèle, USB, 

réseaux, modem 

Le système d'exploitation 

• Permet le dialogue entre l'utilisateur et la 

machine 

• Gestion des ressources de l'ordinateur 

• Scrutation permanente des sollicitations de 

l'environnement 

→ Contient un interpréteur de commandes 


–MS-DOS 

– Windows 

–Unix, … 



4

Les outils de développement 

• L'éditeur de texte 

• L'assembleur 

• Le compilateur 

• L'éditeur de liens 

• Le débuggeur 

• L'interpréteur 


L'éditeur de textes 

• Programme permettant la saisie du texte 

contenant le programme source 

– Éditeur pleine page 

– Enregistrement et récupération de fichier en 

mémoire de masse 

– Modification aisée du texte 

– Outils divers : 

• Copier-coller 

• Recherche, remplacement 

– Aide à la lisibilité (indentation, coloration, …) 


Le code machine 

• Programme "lu" par le processeur : binaire 

→ code machine 

Exemple : 

B6 30 00 charger A par cont. 3000H 

8B 05 ajouter 05H à A 

F7 30 01 ranger le résultat en 3001H 

• Programmation longue et fastidieuse 

• Très peu lisible, risque d'erreurs élevé 


L'assembleur 

• Écriture du code machine en texte clair 

→ utilisation de mnémoniques 

Exemple : 

LDAA $3000 charger A par cont. 3000H 

ADDA #$05 

ajouter 05H à A 

STAA $3001 ranger le résultat en 3001H 

• Saisie du texte par un éditeur de textes 

• Texte traduit en code machine par un 

programme : l'assembleur 

→ Amélioration de la lisibilité 


5

Problèmes liés à l'assembleur 

• Langage du processeur 

– Très différent du langage naturel 

– Pas de gestion évoluée des données 

– Pas de système de protection 

– Propre à chaque processeur 

→ Maintenance difficile 

→ Portabilité nulle 

Mais : 

grande efficacité (pour un bon programmeur) 

Le compilateur 

•But : 

– S'affranchir du type de processeur 

– S'affranchir de l'environnement matériel et 

logiciel 

– Écriture des programmes en langage naturel 

→ langage évolué 

• Compilateur : 

– Traduit le texte (source) en code machine 



Utilisation d'un compilateur 

• Bonne lisibilité des programmes 

• Bonne portabilité 

• Gestion de données complexes 

• Gestion de la mémoire du système 

• Gestion standard des périphériques 

• Rapidité d'écriture des programmes 

• Maintenance aisée 

En + : 

• Optimisation des programmes 

• Systèmes de protection, garde-fous 

Défaut des compilateurs 

• Langage évolué très différent du langage 

machine 

→ traduction parfois difficile 

→ surcode parfois excessif 

– Exécutable volumineux, lent 

• Vrai avec processeurs anciens ou peu 

performants 



6

L'éditeur de liens 

• Création d'un programme : 

– Écriture d'un programme source (texte) 

Compilation 

– Programme objet (binaire, code machine 

incomplet) 

Éditeur de liens 

Bibliothèques personnelles 

Bibliothèques du langage 

– Programme exécutable (binaire autonome) 

Utilisation de l'éditeur de liens 

• Bibliothèques personnelles 

→ extension du langage à sa convenance 

• Portions de programmes réutilisables 

• Dépannage ou amélioration d'une 

bibliothèque 

⇒ dépannage ou amélioration de tous les 

programmes qui en dépendent 



Le débuggeur 

• Outil permettant le dépannage des programmes 

(exécutables) 

– Consultation des données 

– Exécution instruction par instruction 

– Points d'arrêt 

• Souvent intégré dans 

IDE (Integrated Development Environment) 

ou EDE (Embedded Development Environment) 

→ Éditeur + Compilateur + Éditeur de liens + Débugger 


L'interpréteur 

• Exécute le programme pendant la lecture 

du code source 

– Très lent (chaque instruction est interprétée 

puis exécutée à chaque utilisation) 

– Présence de la totalité des bibliothèques du 

langage indispensable 

– Le programme n'est pas autonome (exécuté 

sous le contrôle de l'interpréteur) 

– Pas d'éditeur de liens 

– Pas d'optimisation de code 


7

Représentation des données 

Données utilisées en 

informatique 

• Types des données 

– Choisi en fonction de l'utilisation 

Exemples : 

• Comptage d'un nombre d'étudiants 

• Calcul du sinus d'un angle 

• Écriture d'un texte 

• Données codées en binaire 

– Pour le traitement par le processeur 

– Définition d'un mode de rangement en mémoire pour 

chaque type de donnée 

• Limitations liées au codage utilisé 



Le type entier 

Valeurs limites 

•Signé : 

– …, -2, -1, 0, 1, 2, … 

• Non signé 

– 0, 1, 2, … 

• Traitement de données entières 

– Adapté aux énumérations 

Codage 

8 bits 

16 bits 

32 bits 

Signé 

min max 

-128 127 

80 H 7F H 

-32768 

-2147483648 

32767 

2147483647 

min 

0 

0 H 

0 

0 

Non signé 

max 

255 

FF H 

65535 

4294967295 


Rem. : En représentation signée, le signe du nombre est donné 

par le bit de poids le plus fort (1 pour négatif) 


8

Opérations possibles 

• Arithmétiques 

! Addition (+) 

! Soustraction (-) 

! Multiplication(*) 

! Division entière (/) 

! Modulo (%) Reste de la division entière 


• Logiques (bit à bit) 

! ET logique (&) 

! OU logique (|) 

! OU exclusif (^) 

! Complément à 1 (~) 

• Comparaisons 

! ==, , =, != 



• ±nnn 

! 12, -5, +3, 0 

Notation 

Utilisation 

• Intérêt des entiers : 

– Valeurs exactes, pas d'imprécision 

– Adaptés au comptage, dénombrement 

• Inconvénient : 

– Dynamique limitée 

• Pas de très grand nombre 

• Pas de très petit nombre 

– Inadaptés au calcul scientifique 



9

Le type booléen 

• Résultat d'une expression logique 

• 2 valeurs possibles : 

– Vrai ou Faux 

• Opérateurs : 

– ET, OU, NON : résultat booléen 

Ex. : Vrai OU Faux → Vrai 

Vrai ET Vrai → Vrai 

NON Vrai → Faux 

• Codage : 

– 1 bit suffit 


Le type à virgule flottante 

• Nombres réels (positifs et négatifs) 

• Notation mantisse – exposant 

• Permettent une grande dynamique : 

– Très petites valeurs (Ex. : ±1.6 10 -19 ) 

– Très grandes valeurs (Ex. : 25.2 10 47 ) 

• Problème d'imprécision : 

– Ex. : entre 2.0 et 2.1 → infinité de valeurs 

codage machine ⇒ nombre de valeurs fini 

– Présence d'arrondis 


Codage 

• Exemple de codage sur 32 bits (IEEE) 

– Mantisse sur 24 bits 

– Exposant sur 8 bits 

± m . 2 e 

! S : signe (1 : négatif, 0 : positif) 

! m : mantisse (1 ≤ m < 2) ⇒ m = 1.xxxxx 

! e : exposant (-128 ≤ e ≤ 127) 

! f : partie fractionnaire de la mantisse 

! e' : e+127 (1 ≤ e' ≤ 254) 

e' 

f 

S 

b 31 b 30 b 23 b 22 

… b 0 


Valeurs limites 

e' 

f 

S 

b 31 b 30 b 23 b 22 

… b 0 

• Valeur la plus petite positive : 

–S = 0 

–e' = 1 ⇒ e = -126 

–f = 0 ⇒ m = 1.0 

V min = 1.0 2 -126 ≈ 1.175 10 -38 

• Valeur la plus grande positive : 

–S = 0 

– e' = 254 ⇒ e = 127 

– f = 0.11111… ⇒ m = 1.11111… = 2.0 – 2 -23 

V max = (2.0 – 2 -23 ) 2 127 ≈ 3.403 10 38 


10

Résolution 

• Valeur suivante de 1.0 : 

1.0 + 2 -23 = 1.0 + 1.2 10 -7 

→ 6 chiffres significatifs 

Valeurs particulières 

± m . 2 e avec m>1 ne permet pas de coder 0.0 

• Si e' = 0 → codage de 0.0 

• Si e' = 255 → codage de ±NAN 



• Sur 64 bits (8 octets) : 

– Mantisse sur 52 bits 

– Exposant sur 11 bits 

– Signe sur 1 bit 

Autres codages 

– 15 chiffres significatifs 

– Valeurs limites ≈ 10 ±308 


• Arithmétiques 

! Addition (+) 

! Soustraction (-) 

! Multiplication(*) 

! Division (/) 

• Comparaisons 

! ==, , =, != 

• Sur 80 bits → 18 chiffres significatifs, ≈ 10 ±4932 M. Deloizy Informatique - Généralités 44 


11

Notation 

Forme générale : 

±dd.ddE±xx ⇔ ±dd.dd 10 ±xx 

• ±nnn.nnn 

! 2.0, -1.432, +4.5, 0.0 

• ±.nnn ou ± nnn. 

! 1. , -.2, 0. 

• ± nnE ±nn ou ± nne ±nn 

! 1E3, 5.22e-23, +3.2E-2 


Le type caractère 

• Caractères codés pour représentation en 

machine 

• 7 bits suffisent (128 caractères) 

• Exemple de code : ASCII 

– American Standard Code for Information 

Interchange 

– Défini par ANSI (American National Standard 

Institute) 


Codage ASCII 

• Contient : 

– Lettres minuscules et majuscules (ordre 

alphabétique) : 2x26 caractères 

– Chiffres (ordre croissant de 0 à 9) 

– Ponctuations, caractères typographiques, … 

– Caractères de contrôle (codes 0 à 31) 


– 'A' = 65, 'B' = 66, 'Z' = 90, 'a' = 97, '0' = 48 

– CR = 13, LF = 10, TAB = 9, FF = 12, BEL = 7 

Autres codages 

• EBCDIC (IBM) 

• ANSI (jeux de caractères internationaux) 

• ASCII étendu 

Souvent sur 1 octet 

Rem. : le langage informatique prend en charge le 

codage (pas nécessaire de le connaître) 



12

Notation et opérations possibles 

• Notation : 

– 'X', '0', '2' 

– '\r', '\n', '\t' 

– '\\', '\'' (caractère d'échappement : \ ) 

• Opérations possibles : 

– Additions, soustraction avec des entiers 

Ex. : 'A' + 1 → 'B' 

– Comparaisons 

Ex. : 'A' < 'E' 

Chaînes de caractères 

• Ensemble ordonné de caractères 

représentant un mot, une phrase. 

• Particularité : 

– Nombre de caractères variable 

→ Taille très variable 



Codage 

• Codages possibles : 

–

Le type adresse 

• Données et programmes 

rangés en mémoire 

→ Chaque donnée, 

chaque instruction a une 

adresse propre 

→ Le processeur accède 

aux données et aux 

instructions grâce à leur 

adresse 

Contenu 

adresse mémoire 

C32C H 2A H 

C32D H F0 H 

C32E H 12 H 

C32F H 45 H 

C330 H C5 H 

Variable 

toto 

c1 

c2 

x 

Indirection 

• Une donnée peut 

contenir une adresse 

→ pointe sur une autre adresse 

donnée 

C32C H 

→ Ex. : ptr pointe sur c2 C32D H 

→ Pointeur 

C32E H 

→ On peut modifier c2 de C32F H 

manière indirecte en C330 

agissant sur ptr 

H 

→ Indirection 

Contenu 

mémoire 

C3 H 

2F H 

12 H 

45 H 

C5 H 

Variable 

ptr 

c1 

c2 

x 

Remarque : On peut avoir des indirections multiples 



Les tableaux 

• Données rangées de manière contiguë en 

mémoire 

• Données indicées (vecteurs) 

• Tout type de donnée peut être organisé en 

tableau 

Exemple : 

• Caractéristiques d'un tableau : 

– Adresse du 1er élément 

– Nombre d'éléments 

– Type des données contenues 

Constantes 

• Données non modifiables 

• Utilisées dans des expressions 

• Exemple : 

P = 2.0 * PI * Rayon 

Constantes 

t 0 t 1 t 2 t n 



14

Constantes explicites 

• Valeur écrite explicitement 

– L'écriture indique le type de la constante : 

• 2, -3 : entiers 

• 1.0, 2E4 : virgules flottantes 

• 'z', '2' : caractères 

• "TOTO" : chaîne de caractères 


Constantes prédéfinies 

• Utilisées par l'intermédiaire d'un nom de 

symbole 

• Utilisation identique à constante explicite 

• Avantages : 

– Permet une meilleure lisibilité 

– Facilite la maintenance 

– Évite des écritures & modifications multiples 

→ réduit le risque d'erreurs 

Exemple : constante TVA = 0.196 

Pull_ttc = Pull_ht*(1+TVA) 

Chemise_ttc = Chemise_ht*(1+TVA) 


Constitution d'un programme 

Écriture d'un programme 

• Ensemble de fonctions ou procédures 

• Une fonction particulière : 

– démarrage du programme, point d'entrée 

Principes de base 



15

Fonctions 

• Composées d'instructions 

– Exécutées séquentiellement 

• Instructions : 

– Expressions, ex. : y=a+b, y=sin(a) 

– Contrôle de déroulement, ex. : si y

Classe d'allocation 

• Façon dont la donnée est créée par le 

compilateur : 

– Allocation statique : 

• Donnée créée au chargement du programme 

• Emplacement fixe pendant durée d'exécution 

• Valeur laissée précédemment retrouvée à chaque 

accès 

– Allocation dynamique : 

• Donnée créée lors de la déclaration 

• Valeur initiale aléatoire 

• Donnée détruite en fin d'utilisation 

Portée des données 

• Données connues par la totalité du 

programme ou par une portion seulement : 

– Donnée globale 

• Toutes les fonctions du programme peuvent y 

accéder 

– Donnée locale 

• Définie pour une portion de programme (par 

exemple une fonction) 

• Inconnue hors de cette portion 



Règles de portée 

• Deux variables ne peuvent pas avoir le 

même nom dans la même zone de portée 

• Si une donnée locale porte le même nom 

qu'une donnée globale, la donnée globale 

devient inaccessible 

→ masquage de la donnée globale 

Structures conditionnelles 

Contrôle du déroulement du 

programme 



17

Structure conditionnelle simple 

• Si alors … 

finsi 

if (x

Structure itérative Pour 

• Pour jusqu'à faire … FinPour 

– Facilité d'écriture 

– Peut être remplacé par Tant que 

for(i=0; i

Affectations autorisées 

• Entier ← Entier 

← Virgule flottante 

← Caractère 

• Virgule flottante ← Virgule flottante 

← Entier 

• Caractère ← Caractère 

← Entier 

• Booléen ← Booléen 

• Adresse ← Adresse 

Expressions 

• Arithmétiques ou logiques 

• Utilisation d'opérateurs : 

– Lecture de gauche à droite 

– Prise en compte des priorités 

Ex. : y = 2*a + 3*b ⇔ y = (2*a) + (3*b) 

– Utilisation de ( ) pour forcer la priorité 

• Priorités classiques : 

! * et / ont la même priorité 

! - et + ont la même priorité 

! * et / sont prioritaires sur + et – 

– Les opérateurs logiques utilisent l'algèbre de Boole 



Exemple : 

y = a / 2 / x + 3* b / 2 

Priorités 

⇔ 

y = 

2⋅ 

Quand appel de fonction : 

– Arguments évalués avant l'appel 

– Fonction ⇔ variable calculée 

Ex. : y = 2 * sin(x) 

y = sin(a + acos(b)*2) 

a 

x 

3⋅b 

+ 

2 

Opérateurs logiques 

• Utilisés dans les structures conditionnelles 

• Utilisent l'algèbre de Boole 

• ==, !=, , =, &&, ||, ! 

Exemple : 

if( !( (x'z') ) ) … 

A B 

A + B = A⋅ 

B 

if( (x>='a') && (x

Utilité des fonctions 

Fonctions 

• Décomposer un problème complexe en sous problèmes 

plus simples 

– Analyse descendante 

• Éviter la répétition de lignes de programmes 

• Améliorer la lisibilité 

• Faciliter la maintenance (constitution de bibliothèques) 

• Renvoie une valeur dépendant de paramètres transmis 

• Fonction qui ne renvoie rien : 

– Procédure, sous-programme 



Définition d'une fonction 

• À définir : 

– Nom de la fonction 

– Type de la valeur renvoyée 

– Type des paramètres transmis 

Exemples : Utilisation : 

double sin(double x) 

y = sin(3.0); 

void clrscr(void) clrscr( ); 

double pow(double y, double x) y = pow(2.0, 0.5)/2.0; 

Fonctions et paramètres 

• Lors de l'appel d'une fonction, les paramètres : 

– Sont tout d'abord évalués 

– Sont transmis dans l'ordre de leur écriture 

→ le type doit être compatible 

Exemple : 

void fct(int a, double x) { 

… 

} 

a, x : variables locales à fct 

… 

fct(3,2.0*sin(1.0)); 



21

Transmission par valeur 

• La valeur du paramètre est recopiée 

→ Valeur initiale du paramètre (variable locale de la 

fonction) 

int somme(int a, int b) { 

int s; 

s = a+b; 

(15) 

return s; 

} 

… 

X = somme(2, 5*3); 

Inconvénients de la transmission 

par valeur 

• Paramètre encombrant (ex. : tableau) 

• Une fonction ne renvoie qu'une valeur 



Transmission par référence 

Pointeurs 

• On transmet l'adresse du paramètre plutôt que 

sa valeur 

→ utilisation d'un pointeur (type adresse) 

int v; 

int *p; 

p = &v; 

v est un entier 

p est l'adresse d'un entier (*p : entier) 

p prend comme valeur l'adresse de v 

Pour accéder à v, on utilise la notation *p 

→ signifie : l'entier pointé par p (ici : v) 

Pour charger 5 dans v, on peut donc écrire : 

v = 5 

*p = 5 

*(&v) = 5 



22

Pointeurs et fonctions 

int ProdQuot(int a, int b, int *p, int *q) { 

*p = a * b; 

if (b != 0) return 0; 

*q = a / b; 

return 1; 

} 

int main( ) { 

int u, v, x; 

x = 3; 

if (ProdQuot(x,2,&u,&v) == 0) { 

printf("%d x 2 = %d\n", x, u); 

} 

else { 

printf("%d x 2 = %d et %d / 2 = 

%d\n",x,u,x,v); 

} 


} 


Fonctions réentrantes 

• Fonction exécutée plusieurs fois simultanément 

→ appelée de nouveau pendant son exécution 

– Systèmes multi-tâches 

– Interruptions 

• Contrainte : 

– Pas de donnée statique 

– Utilisation de données dynamiques 

→ Nouvelles données à chaque déclaration 

→ Données propres à chaque appel de fonction 


Fonctions récursives 

• Fonction qui se rappelle elle-même 

• L'appel peut être direct ou non 

• Particularités : 

– Fonctions réentrantes 

– Un point de sortie doit être prévu 

• Intérêt : 

– Écriture condensée et rapide de programmes 

• Inconvénients : 

– Peu efficace à l'exécution 

– Gourmand en ressources 


Langage C 


23

Histoire 


C ANSI 

Brian KERNIGHAN & Dennis RITCHIE 

! Principes issus du BCPL et du B (1970) 

→ premier système UNIX 

! 1978 : Parution du livre "Le langage C" 

! Souvent associé à UNIX (écrit( 

en C) 

! Lié à aucune machine 

Lié à aucun système d'exploitation 

! 1988 : C norme ANSI 

M. Deloizy Langage C 1 

M. Deloizy Langage C 

2 

Intérêt du langage 

! Langage non spécifique (généraliste) 

! Bonne portabilité 

! Bonne efficacité (peu de sur-code 

code) 

! Base du C++ (objet) 

Constitution d’un 

programme C 

Programme 

Module 

1 

Module 

2 

Module 

Fonction1( ) { 

... 

} 

Module 

n 

Fichier .c 

(texte) 

Fonction1( ) { 

... 

} 

main( ) { 

... 

} 


3 


4 

1

Syntaxe 

Mots clés 

! Commentaires. 

! /* Ceci est un commentaire */ 

! Noms de symboles. 

! Symboles autorisés : 

! toto Toto 

t123 

_tx_ 

_12 ___ 

! Symboles non autorisés : 

! 12_ 2t 

été m% bon jour 

! Minuscules et majuscules. 

! Les minuscules et majuscules sont différenciés en C. 

a 

auto 

continue 

enum 

if 

short 

switch 

volatile 

break 

default 

extern 

int 

signed 

typedef 

while 

case 

do 

float 

long 

sizeof 

union 

char 

double 

for 

register 

static 

unsigned 

const 

else 

goto 

return 

struct 

void 


5 


6 

! Les types de base 

! char : 

Types de variables 

! Caractères (8 bits). 

! Entier court (signé par défaut). 

! Type de données de taille élémentaire. 

! int : 

! Entier (signé par défaut). 

! Type pris par défaut. 

! Au moins 16 bits. 

! float : 

! Nombre en virgule flottante. 

Types dérivés 

! unsigned char 

! signed char 

! unsigned int ou unsigned 

! short 

! unsigned short 

! long int ou long 

! unsigned long int ou unsigned long 

! double 

! long double 


7 


8 

2

Dynamique des nombres 

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é -22 147 483 648 2 147 483 647 

32 bits non signé 0 4 294 967 295 

VIRGULE 

FLOTTANTE 

Dynamique des nombres 

Chiffres 

significatifs 

Exposant 

min/max 

4 octets 7 ±38 

8 octets 15 ± 308 

10 octets 19 ± 4932 


9 


10 

Taille des données 

! Si E représente l’encombrement mémoire d’un type : 

E(char) ≤ E(short) ≤ E(int 

int) ≤ E(long) 

E(float 

float) ≤ E(double) ≤ E(long double) 

! Opérateur sizeof. 

! Pas de type booléen. 

Résultat nul ⇒ faux 

Résultat non nul ⇒ vrai 

Types composés 

! les tableaux 

! les structures 

! les unions 

! Remarque : 

! On peut combiner les structures et les tableaux 

! " tableaux de structures 

! " structures contenant des tableaux. 


11 


12 

3

Autres types 

! les types définis par le programmeur 

! typedef 

! void 

! typedef unsigned char byte; 

! typedef unsigned short word; 

! typedef unsigned long dword; 

Déclaration des variables 

! 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]) 

! 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) 


13 


14 

Tableaux 

! Le premier élément d’un tableau est d’indice 0. 

! Rangement consécutif en mémoire (Ex. de tab[0] à 

tab[9]) 

! Tableaux multi-dimensionnés 

: le dernier indice « court » 

le plus vite : 

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] 

Constantes 

Types 

Écritures 

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 ± nnnE ± nn 1.0, -4., 3E4, 1.6e-19 

19 

Chaîne de caractères 

"xxxxxx" 

"Bonjour les amis" 

Remarque : \ est le caractère d‘échappement en C 


15 


16 

4

Constantes particulières 

Séquence 

Signification 

\r Retour chariot (en début de ligne). 

\n Saut à la ligne suivante. 0x0A 

\t Tabulation. 0x09 

\\ Caractère \ 

\’ Caractère ' 

\" Caractère " 

\xnn 

\ooo 

Exemple 

printf(" 

("\rbonjour") 

printf("bonjour 

("bonjour\n") n") 

printf("Rés. 

("Rés.\tMoy.\n") 

Nombre hexadécimal 

Nombre octal (o : digit octal) \012, 

Résultat 

") bonjour 

bonjour! 

Rés. 

Moy. ! 

printf("valeur : \\10\\\n") 

valeur : \10\! 

x='\'' 

''-0x20 

x=39-32 

32 ⇒ x=7 

printf("Il dit : \"Bof!\"\n") 

Il dit : "Bof!" 

0x3B, 0xFA8 59, 4008 

012, \033 

10, 27 

Suffixe : 

Entier 

Virgule flottante 

Suffixes 

sans 

U ou u 

L ou l 

int 

unsigned int 

long 

double - long double 

! 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 

Applications : 

unsigned x = 120000UL*4/10000; 

long y = 15000L*4; 

F ou f 

float 

Float 


17 


18 

Organisation générale d’un module 

Déclarations 

… 

Fonction1 

… 

Fonction2 

… 

Définition d’une fonction 

! Déclaration : 

! du nom de la fonction, 

! du type de valeur retournée par la fonction 

! des noms et des types des arguments transmis. 

! Corps de la fonction (entre accolades) : 

! déclarations de données locales à la fonction 

! blocs d'instructions 

! retour à la fonction appelante (avec un éventuel 

renvoi d'une valeur) 


19 


20 

5

Exemple 

Ancienne syntaxe 

double somme(double a, double b) 

{ 

double res; 

res = a + b; 

return res; 

} 


21 

void init_glob( ( ) 

{ 

A=0; 

TOT=12E4; 

} 

double somme(a, b) 

double a, b; 

{ 

double res; 

res = a + b; 


} 


22 

double somme(double a, double b) 

{ 

double res; 

res = a + b; 


} 

! ‘;’ omis en fin de ligne de définition 

! Paramètres transmis par valeur 

void init_glob() 

{ 

A=0; 

TOT=12E4; 

} 

Fonction ne renvoie rien → void 


23 


24 

6

somme(int 

a, int b) 

{ 

int s; 

s=a+b; 

return s; 

} 

Type de la fonction est omis → int 

double pi(void 

void) 

{ 

double x; 

x=atan 

atan(1.0)*4; 

return x; 

} 

Fonction non déclarée → int 

Ici : inclure math.h 


25 


26 

Prototype 

! Permet d'indiquer : 

! le type de donnée retourné par une fonction 

! le nombre et le type des arguments transmis. 

# Déclaration de fonction. 

Exemples de prototype : 

double sin(double); 

double somme(double a, double b); 

Blocs d’instructions 

! Constitué : 

! d'une instruction élémentaire terminée par un 

caractère ";" 

ou 

! 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). 

ou 

! d'un simple caractère ';'.' 

'. Dans ce cas, l'instruction est 

vide (sans effet). 


27 


28 

7

x = 2*a + b; 

ou : 

{ 

x = 2; 

y = 4; 

z = x+y; 

} 

ou : 

{ 

int i; 

i = 3; 

x = 2*(i++); 

y=i; 

} 

Exemples 


29 

Opérateur 

* 

/ 

+ 

- 

% 

^ 

| 

& 

> 

Opérateurs arithmétiques 

Description 

multiplication 

division 

addition 

soustraction 

modulo (reste de la division entière) 

ou exclusif (opération sur les bits) 

ou (opération sur les bits) 

et (opération sur les bits) 

décalage à gauche 

décalage à droite 

Exemple (a=5, b=3, c=1) 

x = 20*a x = 100 

z = 10.0/4 z = 2.5 

x = 3+b x = 6 

x = 3-b x = 0 

x = 8%a x = 3 

x = a^b x = 6 

x = a|b x = 7 

x = a&b x = 1 

x = ac x = 1 


30 

Opérateurs logiques 

Opérateurs d’affectation 

Opérateur 

== 

|| 

&& 

!= 

< 

> 

= 

Description 

test d'égalité 

ou logique 

et logique 

différent 

inférieur 

supérieur 

inférieur ou égal 

supérieur ou égal 

Exemple (a=5, b=3) 

x = a==b x = 0 

x = (a==1)||(a==2) x = 0 

x = (a>0) && (a … 


x = a 

⇒ x = 5 

a += 1 

⇒ a = 6 

a -= b 

⇒ a = 2 

a /= b-c 

⇒ a = 2 

a *= 8 

⇒ a = 40 

a %= b 

⇒ a = 2 

a ^= b 

⇒ a = 6 

a |= b 

⇒ a = 7 

a &= b 

⇒ a = 1 

a = b-2 

⇒ a = 2 


31 


32 

8

Écritures possibles 

Opérateur ternaire 

! 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 

! x = y = 2; 

met 2 dans y puis y dans x 

! x = a+=2; 

ajoute 2 à a, puis met le résultat dans x 

Opérateur 

?: 

Description 

choix d'une valeur selon une 

condition 

si la condition est vraie, la 

première expression est 

retournée, sinon, la 

deuxième expression est 

retournée. 


x=(a>4)?(b*2):(c+1) ⇒ x = 6 

x=(a3) 

x = a++ 

x = ++a 

⇒ x = -5 

⇒ x = 5 

⇒ x = -6(0xFA) 

⇒ x = 0 

⇒ x = 5, a = 6 

⇒ x = 6, a = 6 

-- 

auto décrémentation (post ou pré) 

x = a— 

x = --a 

⇒ x = 5, a = 4 

⇒ x = 4, a = 4 


35 


36 

9

Sizeof & Cast 

Expressions 

Opérateur 

sizeof 

(type) 

Description 

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 

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( 

int)(100.0*sin(2.45)); 

x = (double)(2*a+1); 

! Utilisent des opérateurs selon leur priorité 

Exemple : 

x = 2*a + 3*b/4/c; $ 


37 


38 

Priorités 

Opérateurs 

Priorité 

() [] -> . 

15 

! ~ ++ -- + * - * * * & * (type) sizeof 

14 

* / % 

13 

+ - 

12 

> 

11 

< >= 

10 

== != 

9 

& 

8 

^ 

7 

| 

6 

&& 

5 

|| 

4 

?: 

3 

= += -= *= /= %= &= ^= |= = 

2 

, 

1 

(*) : Opérateurs unaires & pointeurs 


39 

Structures conditionnelles 

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 


40 

10

Structure itérative tant que 

Structure itérative faire … tant que 

Boucles tant que … faire : 

Boucles faire … tant que : 

while (condition) 

bloc d'instructions à exécuter si la condition est vraie. 

Exemple : 

while(x

Exemple : 

do 

{ 

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')); 

Rupture de séquence break 

Sortir d'une boucle : 

! while … 

! do … while 

! for 

! switch … case 


45 


46 

Rupture de séquence continue 

Interrompre le déroulement d'une boucle 

! while … 

! do … while 

! for 

→ directement à la fin du bloc d'instructions 

Exemple 

for(i=0; i

Branchements inconditionnels 

Jamais utilisés 

Portée des données 

Exemple : 

... 

x = 3+i; 

if (x

Donnée locale à une fonction 

void fonction(int 

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 

Donnée locale à un bloc 

d’instructions 

void fonction(int 

int a, double x) a et x sont des variables locales à la fonction 

{ 

unsigned i; i est locale à la fonction 

... 

for(i=0; i

Exemple 

Allocation dynamique 

Exemple : 

void fonction(void 

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

Données volatiles 

volatile 

Donnée dont le contenu est susceptible d’être modifié 

« tout seul ». 

⇒ Pas d’optimisation. 

Exemple : 

... 

volatile char x; 

extern volatile unsigned char pio; 

... 

Pointeurs 

Accès aux données à partir de leur adresse 


61 


62 

Notation : 

où 

et 

nom_var 

*nom_var 

*nom_var 

Déclaration : 

nom_type *nom_var; 

Exemple : 

char *c; 

Déclaration 

représente la variable pointeur (qui contient une adresse) 

représente la variable pointée. 

c contient l'adresse de la variable pointée 

la variable pointée est de type char 


63 

Pointeurs et constantes 

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) 


64 

16

Arithmétique des pointeurs 

Pointeurs et tableaux 

Opérations valides 

pointeur 

pointeur 

pointeur 

pointeur 

Opérateur 

+ 

- 

- 

comparaison 

entier 

entier 

pointeur 

pointeur 

Résultat 

Pointeur 

Entier 

… 

p+i accès au 

p pointeur 

i entier 

élément situé à partir de p 

accès au i ème élément situé à partir de 

⇒ fonctionnement identique aux tableaux 

p-2 

p-1 

p p+1 p+2 … 


65 


66 

Parcours d’une chaîne de caractères 

char *p, c; 

p = "HELLO"; 

c = *p; ⇒ c = 'H' 

c = *(p+1); 

p += 4; 

p--; ⇒ *p = 'L' 

⇒ c = 'E' 

⇒ *p = 'O' 

Types des données pointées 

Pointeur ± entier ⇒ Valeur du pointeur ± n fois la taille de l'élément pointé. 

Exemple : 

char *pc ; pc pointe sur un caractère (taille : 1 octet) 

int *pi ; pi pointe sur un entier (taille : 4 octets ici) 

.... 

On suppose que pc=0x3AB0 et pi=0xE020 

pc+1 ; → vaut 0x3AB1 

pc+5 ; → vaut 0x3AB5 

pi+1 ; → vaut 0xE024 

pi+5 ; → vaut 0xE034 

⇒ nécessité de connaître le type de la donnée pointée 

l'arithmétique des pointeurs ne fonctionne pas avec des pointeurs void 


67 


68 

17

Utilité des pointeurs 

! accéder aux éléments d'un tableau 

! manipuler les chaînes de caractères 

! permettre aux fonctions de retourner plusieurs 

valeurs 

Tableaux 

Données de même type disposées de manière contiguë en 

mémoire. 

Exemple : 

double v[5]; 

→ place 5 variables en virgule flottante à partir de 

l'adresse v. 

! v est un pointeur constant → adresse de la première donnée 

du tableau. 

! v[i] permet d’accéder au i ème élément du tableau (i entier). 

! Le premier élément d'un tableau est toujours d’indice 0. 

Exemple : v[0] à v[4]. 


69 


70 

Accès aux éléments des tableaux 

v pointeur ⇒ accès à l'élément i du tableau : 

*(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 

Sizeof et tableaux 

sizeof appliqué sur un tableau 

⇒ espace mémoire occupé par le tableau. 

Exemple : 

double v[5] → sizeof(v) vaut 40 

(si le type double a une taille de 8) 


71 


72 

18

Sizeof et pointeurs 

sizeof(v)/ 

(v)/sizeof(*v) 

indique le nombre d'éléments que peut contenir un tableau. 

!!! % sizeof appliqué à un pointeur donne 

la taille du pointeur. 

Exemple : 

char *str* 

= "Hello"; ⇒ sizeof(str 

str) ) donne 2 

(si pointeurs sur 2 octets) 

char str[10] = "Hello"; ⇒ sizeof(str 

str) ) donne 10 


73 



→ tableaux de caractères. 

→ '\0' est le délimiteur de chaîne. 

notée entre guillemets. 

Exemple : "Bonjour à tous" 


74 

Fonctions et pointeurs 

Langage C ⇒ Transmission des paramètres par valeurs. 

Transmission par référence → utilisation de pointeurs 

Exemple 1 

Fonction initialisant un tableau à 0 : 

void InitTab(int 

int *baseTab, unsigned nb) 

{ 

unsigned i; 

for(i=0; i

Exemple 2 

Autre écriture possible de InitTab : 

void InitTab(int 

int *baseTab, unsigned nb) 

{ 

while(nb 

(nb--)) *(baseTab 

baseTab++)=0; 

} 

Exemple 3 

Recherche de minimum et maximum : 

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

Opérations sur les flux 

! « Ouverture » 

→ création du buffer 

→ création du lien avec le dispositif physique (FILE *) 

→ FILE* fopen(char *NomFichier* 

NomFichier, , char *Mode) 

! Opérations d’entrées/sorties 

→ Entrées/sorties séquentielles 

→ Opérations binaires ou formatées 

→ Gestion du flux (positionnement, mise à jour buffer…) 

Utilisation des flux 

Nécessite l’utilisation de 

Remarque : 

Opérations sur les flux peuvent échouer (disque plein, fichier 

introuvable…) 

→ Nécessiter de vérifier validité opérations 

→ Tester les codes d’erreurs (EOF ou NULL). 

! « Fermeture » 

→ mise à jour des données contenues dans le buffer 

→ destruction du buffer 

→ int fclose(FILE *f) 


81 


82 

Flux en sortie 

Flux en entrée 

! Accès en écriture des fichiers. 

! Par défaut l’écran (stdout( 

tdout) → ne nécessite pas d’ouverture. 

! Fonctions de gestion du flux : 

! printf, fprintf, sprintf,… 

int printf(const 

char *format, …) 

int fprintf(FILE *f, const char *format, …) 

int sprintf(char *str* 

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) 


83 

! Accès en lecture des fichiers. 

! Par défaut le clavier (stdin( 

stdin) → ne nécessite pas d’ouverture. 

! Fonctions de gestion du flux : 

! scanf, fscanf, sscanf,… 

int scanf(const 

const char *format,…) 

int fscanf(FILE *f, const char *format,…) 

int sscanf(char *s, const char *format,…) 

! getchar, getc, fgetc 

int getchar(void 

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) 


84 

21

Gestion des flux 

! long ftell(FILE *f) 

! int fseek(FILE *f, long offset, int fromwhere) 

! void rewind(FILE *f) 

! int feof(FILE *f) 

! int fflush(FILE *f) 

Entrées sorties formatées 

Spécifications de format (pour printf et scanf) ) : 

% [flags[ 

flags] ] [width[ 

width] ] [.prec 

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 


85 


86 


% [flags[ 




Type Format de la sortie 

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 ou jusqu'à ce que e 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[ 




[flags] Signification 

aucun 

: résultat justifié à droite et complété à gauche par des espaces s 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 

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 


87 


88 

22


% [flags[ 




[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 


% [flags[ 




[.prec 

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 


89 


90 


% [flags[ 



prec] ] [F|N|h|l[ 

F|N|h|l] ] type 

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( 

scanf) 

L : arg est interprété comme un réel de type long double 

pour e,E,f,g,G 


91 

Copie de fichier texte 

#include 

 


 


 

void erreur(int 

err, const char *fmt* 

fmt, , ...) 

{ 

va_list arg; 

va_start(arg 

arg,fmt); 

fprintf(stderr 

stderr,"Erreur [%d] : ",err 

err); 

vfprintf(stderr 

stderr,fmt,arg); 

va_end(arg 

arg); 

exit(err 

err); 

} 

main(int 

int argc, , char *argv* 

argv[]) 

{ 

FILE *fs* 

fs, , *fd* 

; 

int x ; 

if(argc 

argc>1) 

{ 

fs=fopen 

fopen(argv[1],"r"); 

if(fs 

fs==NULL) 

erreur(1,"Le fichier %s ne peut être 

ouvert.\n", 

n",argv[1]); 

} 

else fs=stdin 

stdin; 

if(argc 

argc>2) 

{ 

fd=fopen 

fopen(argv[2],"w"); 

if(fd 

fd==NULL) 

erreur(2,"Création de %s 

impossible.\n", 

n",argv[1]); 

} 

else fd=stdout 

stdout; 

while((x= 

((x=getc(fs))!=EOF) 

if(putc 

putc(x, (x,fd)==EOF) erreur(3,"Erreur 

en écriture"); 

fclose(fd 

fd); 

fclose(fs 

fs); 


} 


92 

23

Fonctions standard 

Manipulation de chaînes de 

caractères 

memchr 

strcat 

strchr 

strrstr 

Définies par le C 

memcmp 

memcpy 

strncat 

strcpy 

strrchr 

strspn 

strlen 

strerror 

memmove 

strncpy 

strcspn 

memset 

strcmp 

strpbrk 

strncmp 

strtok 


93 


94 

Entrées sorties 

clearerr 

fclose 

fcloseall 

fdopen 

feof 

ferror 

fflush 

fgetc 

fgetchar 

fgetpos 

fgets 

fileno 

ftell 

getc 

getchar 

gets 

getw 

perror 

printf 

putcs 

putchar 

puts 

tmpfile 

tmpnam 

ungetc 

unlink 

fwrite 

flushall 

fopen 

fprintf 

fputc 

fputchar 

fputs 

fread 

freopen 

fscanf 

fseek 

fsetpos 

putw 

remove 

vfprintf 

rewind 

scanf 

setbuf 

setvbuf 

sprintf 

scanf 

_strerror 

strerror 

vfscanf 

vprintf 

vscanf 

vsprintf 

vsscanf 

rename 


95 

Fonctions utilitaires 

atof 

atoi 

atol 

strtod 

strtol 

strtoul 

rand 

srand 

bsearch 

qsort 

calloc 

malloc 

realloc 

free 

abort 

exit 

atexit 

system 

getenv 

abs 

labs 

ldiv 


96 

div 

24

Structures 

→ Agglomérats de données 

! Exemple : 

! Un individu : 

! Nom – Age – Profession – Poids 

& Ensemble de données propres à chaque individu 

& Informations rangées dans une variable unique (pour 

chaque individu) 

→ Champs de la structure 

Déclaration des structures 

Déclaration : 

struct [TypeStructure] 

{ 

TypeVar1 var1; 

TypeVar2 var2; 

… 

} [NomStruct1][,NomStruct2][,…] ; 


97 


98 

Utilisation des structures 

Exemple de déclaration : 

struct TIndividu 

{ 

char Nom[40]; 

unsigned age; 

char Profession[80]; 

float Poids; 

}; 

struct TIndividu Marcel, Maurice; 

Utilisation : 

Chaque champ de la structure est utilisable comme une 

variable ordinaire (de type défini lors de la 

déclaration de la structure). 

On utilise la notation : 

. 

Exemples : 

scanf("%s", 

("%s",Marcel.Nom); 

Maurice.Age=32; 

Marcel.Poids=58.6; 


99 


100 

25

Types de données contenues 

Les données contenues dans une structure sont 

toutes celles autorisées par le langage C : 

! Types de base,… 

! Types utilisateurs 

! Structures 

! Tableaux 

! Pointeurs 

! … 

Exemple 

Exemple : 

struct 

{ 

int ac; 

double t[10]; 

struct { int a, ab, ac[3]; } si; 

}tv, tbv[10]; 

… 

tv.t[4]=5; 

tv.ac=3; 

tv.si.ac[2]=0; 

tbv[0]. 

[0].si.ac[0]=1; 


101 


102 

Structures et pointeurs 

Structure : donnée à fort encombrement mémoire 

→ Éviter la transmission par valeur lors d’un d 

appel de fonction 

→ Utilisation de pointeurs 

Exemple : 

void AcqParam(struct 

TIndividu *x); 

… 

struct TIndividu Marcel, Maurice, Groupe[30]; 

AcqParam(&Marcel); 

AcqParam(Groupe+2); ou AcqParam(&(Groupe[2])); 

Pointeurs de structures 

Si x est un pointeur de structure, on accède 

à la variable 

pointée e par la notation : 

(*x). ou 

x -> 

Exemple : 

void AcqParam(struct 

TIndividu *x) 

{ 

scanf("%s",(*x).nom); 

ou scanf("%s",x 

("%s",x->nom); 

scanf("%u",&(x 

("%u",&(x->age)); 

x->Poids=60.0; 

} 


103 


104 

26

Champs de bits 

→ Définition de données 

entières 

de petite taille (nombre de 

bits indiqué) 

→ Utilisation : Indicateurs (flags( 

flags), programmation bas niveau 

Exemple : 

struct 

{ 

unsigned CopyOnly:1; 

unsigned CaseDepend:1; 

unsigned Mode:2; 

:4; 

int Rsv:8; 

}Options; 


105 

Unions 

Déclaration & utilisation identiques aux structures 

Mais 

Tous les champs sont situés à la même adresse 

Exemple : (pour examiner le codage d'un nombre 

double) 

union { 

double vd; 

unsigned char vb[sizeof 

sizeof(double)]; 

}x; 

… 

x.vd = 0.25; 

for(i=0; i

La commande include 

→ permet d’insérer le fichier texte spécifié, à l’endroit où la 

commande apparaît 

! Syntaxe : 

! #include 

"nom_de_fichier" 

ou 

! #include 

 

→ Souvent utilisé pour charger les fichiers d’en-tête (headers, .h) 

Exemples : 


 

#include 

→ fichiers livrés avec le compilateur 

→ contiennent des définitions standard compatibles avec les bibliothèques 

→ ne pas les modifier !!! 

Recherche le fichier dans le 

répertoire pris par défaut pour le 

compilateur 

Recherche le fichier dans le répertoire 

courant, puis, s’il n’a pas été trouvé, 

dans le répertoire pris par défaut 

pour le compilateur 

Contenu : 

• déclarations de fonctions (prototypes) 

• définition de données externes (Exemple errno) 

• définition de constantes prédéfinies (Exemple : M_PI) 

• macro-définitions 


109 


110 

La commande define 

Constantes prédéfinies 

permet de définir : 

des constantes 

ou 

des macros 


111 

#define 

Nom_Symbole Expression 

→ substitue par la suite dans le source toutes les occurrences de 

Nom_Symbole par l’expression 

(remplacement intégral de texte) 

Exemple : 


M_PI 3.14159265 


PI2 (M_PI*2.0) 

Par la suite, si dans un programme on utilise l’instruction suivante 

: 

x = PI2*r ; 

le préprocesseur remplace la ligne par : 

x = (3.14159265*2.0)*r; 

→ utilisation efficace de constantes 


112 

28

Macros 

Définition de macros 

→ s’apparentent visuellement à des fonctions, mais 

fonctionnement plus efficace 

→ fonctionnent par substitution de texte 

Exemple : 


MEAN(a,b) (a+b)/2 

à l’utilisation, on écrit : z = MEAN(x,2-i); 

le préprocesseur remplace la ligne par : z = (x+2-i)/2 

; 

→ les arguments ont été remplacés par substitution de texte 

→ la macro MEAN( ) a été remplacée par substitution de texte 


113 

!! ATTENTION !! 


114 

Exemple 


PRODUIT(u,v) u*v 

à l’utilisation : z = PRODUIT(3+2,5) ; 

donnera : z = 3+2*5 ; (13 au lieu de 25 ! ) 

→ Utiliser des parenthèses ! 

Exemples : 


PRODUIT(u,v) 

u * v 


Mini(a,b) a 


115 


116 

29

Exemples : 


PRODUIT(u,v) (u)*(v) 

Exemples : 


PRODUIT(u,v) (u)*(v) 


Mini(a,b) 

(a)

Les commandes if, ifdef, ifndef, endif 

Exemple 

→ Compilation conditionnelle 

#if expression 

#else 

Source compilé dans le 

cas contraire 

#endif 

Source compilé si 

l’expression est vraie 

#ifdef symbole 

#else 

Source compilé si le 

symbole est défini 


cas contraire 

#endif 

#ifndef symbole 

#else 

Source compilé si le 

symbole n’est pas 

défini 


cas contraire 

#endif 

#ifdef 

__TURBOC__ 


 

#if MODEL== __SMALL__ 

int *px 

; 

#else 

void *px 

; 

#endif 

#endif 


121 


122 

Transtypage 

Initialisation de données 

! cast 

→ Conversion de type explicite 

→ Permet d'indiquer au compilateur le type à utiliser 

Exemples : 

x = (long)a * b/c; 

void CopyDat(void 

*d, void *s, size_t sz) 

{ 

size_t i; 

for(i=0; i

o Classe static : 

o Donnée e initialisée e au chargement du programme 

(expression constante évaluée e par le compilateur) 

o La valeur peut changer au cours du programme 

o Pas de code générég 

lors de la déclarationd 

Exemple : 

static int x=4; 

o Constantes : 

o Idem static, , avec valeur non modifiable 

o Exemple : 

void fonctionX(void) 

{ 

char t1[ ]="toto est le plus beau"; 

→ t1 est un tableau dynamique de 22 caractères 

→ la chaîne de caractères est recopiée à chaque appel 

de la fonction fonctionX 

→ le contenu de t1 est modifiable 

} 


125 


126 

! Initialisation de données 

o Exemple : 

void fonctionY(void) 

{ 

static char t1[ ]="toto est le plus beau"; 

→ t1 est un tableau statique de 22 caractères 

→ la chaîne de caractères est chargée au démarrage 

du programme 

→ le contenu de t1 est modifiable 

} 


o Exemple : 

void fonctionZ(void) 

{ 

const char t1[ ]="toto est le plus beau"; 

→ t1 est un tableau constant de 22 caractères 

→ la chaîne de caractères est chargée au démarrage 

du programme 

→ le contenu de t1 n'est pas modifiable 

} 


127 


128 

32


o Exemple : 

void fonctionW(void) 

{ 

char *t1="toto est le plus beau"; 

→ t1 est un pointeur initialisé sur une chaîne de 

caractères constante (à chaque appel de fonctionW) 

} 


o Exemple : 

void fonctionY(void) 

{ 

static char *t1="toto est le plus beau"; 

→ t1 est un pointeur initialisé au chargement du 

programme sur une chaîne de caractères constante 

chaîne) 

} 

→ t1 pourra être modifié (pour pointer sur une autre 


129 


130 

Fonction main 


o Exemple : 

double tab[ ]={1.0, 3.0, 5.0, 7.0}; 

char *mots[ ]={"toto","titi","tata",0}; 

struct { 

char *nom; 

double val; 

} liste[100] = { 

{ "pi", 3.14 }, 

{ "x", 200.12 }, 

}; 


131 

! Démarrage du programme 

! Renvoie une valeur entière au système d'exploitation 

→ code d'erreur 

! Admet 3 paramètres : 

int main(int 

int argc, , char *argv* 

argv[ [ ], char *arge* 

arge[ [ ]) 

! Paramètres "transmis" par le système d'exploitation 

! argc : nombre de paramètres sur la ligne de commande (à l'invocation 

du programme) 

! argv : chaînes de caractères contenant les paramètres 

! arge : variables d'environnement 


132 

33

Exemple 

pgm.exe –x3 

toto.dat titi.out 

• argc = 4 

• argv[0]=" 

[0]="pgm.exe"" (avec le chemin d'accès complet) 

• argv[1]=" 

[1]="-x3" 

• argv[2]=" 

[2]="toto.dat" 

• argv[3]=" 

[3]="titi.out" 


133 

Pointeurs de fonctions 

Nom de fonction → adresse de la fonction 

→ Pointeur de fonction 

Peut être utilisé pour indexer une fonction parmi plusieurs. 

Exemple : 

void TriBulle(int 

int t[ ], int nb); 

void TriInsertion(int 

int t[ ], int nb); 

void (*fctTri 

fctTri)( )(int 

t[ ], int nb); 

… 

int tab[ ] = {1, 4, 0, -1, 2}; 

fctTri = TriBulle; 

fctTri(tab, 

(tab,sizeof(tab)/sizeof(*tab)); 

fctTri = TriInsertion; 

fctTri(tab, 

(tab,sizeof(tab)/sizeof(*tab)); 


134 

Allocation dynamique de mémoire 

→ Quand un espace mémoire m moire est requis, de taille 

inconnue lors de la conception du programme 

→ Pour optimiser l'utilisation de la mémoirem 

moire 

→ Demande de mémoire m moire à l'environnement 

Fonctions : 

• void * malloc(size_t 

sz); 

Renvoie un pointeur sur la zone allouée 

ou NULL si pas d'espace disponible 

• void free(void 

* ptr); 

Libère l'espace mémoire m moire attribué par malloc 


135 

Exemple 

int nb, , *tab; 

printf("Nombre de valeurs à acquérir :"); 

scanf("%d",& 

("%d",&nb); 

tab = malloc(nb 

nb*sizeof(*tab)); 

if(tab!=NULL) { 

int i; 

for(i=0; i

Fonctions à liste de paramètres 

variable 

! En C, on peut définir des fonctions avec un 

nombre de paramètres inconnu : 

Exemples : 

void FctErr(int 

err, , …); 

int printf(const 

char *format, …); 

! Nécessité d'avoir au moins un paramètre connu 

! Gestion par va_list, va_start, va_arg, va_end 

→ définis dans stdarg.h 


137 

Exemple 

void ErrPrintf(int ext, const char *fmt, …) 

{ 

va_list ap; 

printf(ext ? "Erreur : " : "Avertissement : "); 

va_start(ap,fmt); 

vprintf(fmt,ap); 

va_end(ap); 

if(ext) exit(ext); 

} 

… 

F = fopen(nf="toto.dat","r"); 

if(F==NULL) ErrPrintf(1,"Le fichier '%s' ne peut être 

ouvert.\n",nf); 

… 


138 

Signal 

! Gestion d'événements exceptionnels 

! Défini dans signal.h 

void (*signal(int 

int sig, void (*handler 

handler)( )(int)))(int); 

Détermine la façon dont les signaux ultérieurs seront traités. 

handler : fonction de traitement du signal 

Fonctions prédéfinies : 

SIG_DFL : comportement par défaut 

SIG_IGN : le signal sera ignoré 

Retour : handler ou SIG_ERR en cas d'erreur 


139 

Signaux : 


SIGABRT : arrêt anormal 

SIGFPE 

: erreur arithmétique 

SIGILL 

SIGINT 

: instruction illégale 

: appel au système invalide 

SIGSEGV : accès mémoire interdit 

SIGTERM : demande d'arrêt du programme 

Quand signal survient : 

1. Le comportement par défaut est rétabli 

2. La fonction handler est appelée 

3. Si la fonction rend la main, le programme se poursuit à 

l'endroit où il avait été interrompu 


140 

35

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 = ± m⋅2 

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 ?

TD2 : PREMIERS PROGRAMMES 

I. Écrire un programme affichant « BONJOUR » à l’écran. 

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 : 



.... 

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. 


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 }

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. 

a ⋅10 

+ b ⋅10 

+ 

On rappelle qu'un nombre abc peut s'écrire : (( ) ) 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.

TP1 : DÉCLARATIONS, PREMIERS PROGRAMMES, DÉBOGUAGE 

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

TP2 : MANIPULATIONS DE CHAÎNES DE CARACTÈRES 

I. Saisie de chaînes 

Définir un tableau de 256 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 premiers 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 caractères contenus dans une chaîne. Comparer les résultats 

obtenus avec la fonction strlen. 

II.1.a. 2 Comparer les temps d'exécution de votre fonction par rapport à strlen. On pourra utiliser pour cela la 

fonction difftime (définie dans time.h) appliquée sur un très grand nombre d'appels de chacune des fonctions. 

Essayer d'optimiser votre fonction afin qu'elle s'exécute en un temps minimal. 

II.2. Écrire une fonction qui compte le nombre de voyelles contenues dans une chaîne de caractères (sans 

distinction des minuscules et majuscules). 

II.3. Écrire une fonction qui compte le nombre de mots contenus dans une chaîne. 

III. Interprétation d'une chaîne de caractères. 

III.1. Faire la saisie d'une chaîne donnée sous la forme : valeur numérique opérateur valeur numérique 

Par exemple : "2.4 + -3.5" 

L'opérateur pourra être un caractère parmi +, -, *, / et ^ (élévation à la puissance) 

Faire une fonction qui retourne la valeur numérique correspondant à l'expression écrite dans la chaîne. On pourra 

utiliser la fonction strtod pour l'évaluation des données numériques. 

III.2. 2 Améliorer cette fonction pour qu'elle prenne en charge les parenthèses, permettant ainsi d'écrire par 

exemple : 2.4 + (-3.5) 

Pourrait-on envisager d'évaluer une expression du type : 2.4 + (0.5-4.0) 

2 Exercices optionnels

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). 


void AcqTab(int *tab, unsigned nb); 

I.2. Écrire une fonction affichant à l'écran les n premiers nombres d'un tableau, en passant une ligne toutes les nbl 

valeurs. 


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. 3 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. 


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 les algorithmes 

suivants : 

tri à bulle 

tri par sélection 

tri de Hoare 

III.2. 3 Mesurer les durées d'exécution des différents algorithmes appliqués sur les mêmes tableaux, en utilisant la 

fonction clock() pour différentes valeurs de N. 

Comparer les résultats obtenus avec la fonction qsort() définie dans stdlib.h. 

III.3. 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. 

3 Exercices optionnels.

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 composant le fichier. 

II. Cryptage d'un fichier 

On se propose de crypter de manière simple le fichier précédemment créer (afin d'en interdire la lecture avec un 

simple éditeur de textes). 

II.1. Faire la fonction de cryptage 

L'octet transmis sera divisé en deux quartets. Les bits des quartets seront ensuite mélangés comme indiqué cidessous. 

La fonction retournera le complément du résultat obtenu. 

Exemple : Soit le caractère 'A' de code ASCII 0x41 

On coupe ce code ASCII en deux quartets ; on obtient 4 et 1, soit en binaire : 0100 et 0001. 

On mélange les quartets en alternant les bits : 

0 1 0 0 

0 0 0 1 

0 

1 0 0 1 0 0 0 

On obtient alors un octet contenant 0x48, soit, en binaire : 01001000 

Ensuite on prend le complément de cette valeur et on obtient 10110111, soit en hexadécimal 0xB7. 

Si le caractère 'A' est transmis à la fonction, celle-ci retournera donc la valeur B7 H (soit 183 en décimal). 

II.2. Écrire une fonction réalisant la lecture du fichier Fin, qui crypte ce fichier et écrit le résultat dans Fout. 


int CryptFile(FILE *Fin, FILE *Fout); 

Cette fonction retournera 1 si le cryptage s'est bien passé, et 0 en cas d'erreur. 

Remarque : Le fichier Fout devra avoir été ouvert en binaire pour assurer une écriture correcte dans le fichier. 

II.3. Faire le programme complet. 

L'utilisateur devra entrer le nom du fichier à crypter et le nom du fichier crypté. 

II.4. 4 On souhaite appeler le programme de cryptage selon la syntaxe suivante : 

NomProg NomFichier 

où NomProg est le nom du programme exécutable (.exe) et NomFichier est le nom du fichier à crypter. 

Le fichier transmis sera alors crypté, le résultat étant mis à la place du fichier d'origine. 

Faire la lecture des arguments de la fonction main(), en sachant que le prototype de main() est 

int main(int argc, char *argv[]); 

où argc représente le nombre d'arguments sur la ligne de commande (y compris le nom du programme) et argv est 

un tableau de chaînes de caractères contenant les différents arguments. 

Écrire le programme complet. On pourra utiliser les fonctions tmpnam() , rename() et remove() en s'assurant que le 

fichier d'origine ne doit être détruit que si le fichier crypté a été construit sans erreur. 

Proposer un système permettant de crypter ou décrypter de manière automatique le fichier transmis en argument. 

4 Exercice optionnel.

TP5 : STRUCTURES 

I. Définition d'une structure 

Définir un type de structure TInfo pouvant contenir des informations sur des personnes : 

le nom (chaîne de caractères - maximum 40 caractères) 

le prénom (chaîne de caractères - maximum 40 caractères) 

le jour de naissance (entier court - char) 

le mois de naissance (entier court - char) 

l'année de naissance (entier court - short) 

le numéro de téléphone (tableau de 15 entiers courts – type char) 

le nombre de chiffres composant le numéro de téléphone (entier court - char) 

l'adresse Email (chaîne de caractères - maximum 60 caractères) 

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 TInfo, en initialisant les deux premières structures avec 

vos coordonnées. 

Indiquer l'encombrement mémoire de ce tableau. 

IV. Acquisition des champs 

Ecrire une fonction permettant d'acquérir au clavier une structure TInfo. 

Cette fonction posera les questions suivantes : 

Entrer le nom : 

Entrer le prénom : 

Entrer la date de naissance sous la forme jj/mm/aaaa : 

Entrer le numéro de téléphone (max 15 chiffres) : 

Entrer l'Email : 


void AcqInfo(struct TInfo *info); 

V. Acquisition et enregistrement dans un fichier 

Faire un programme permettant d'acquérir au clavier des informations sur des personnes et de les enregistrer dans 

un fichier disque. On pourra utiliser pour ceci la fonction fwrite(), définie dans stdio.h. 

Le fichier créé peut-il être visualisé à l'aide d'un simple éditeur de textes ? 

VI. Relecture du fichier 

Modifier le programme précédent pour initialiser le tableau de structures à partir du fichier enregistré sur le disque, 

s'il existe. 

VII. 5 Classement des informations. 

Réaliser le tri du tableau de structures selon différents critères (par exemple, le nom, le prénom ou l'âge). 

5 Exercice optionnel

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 

∑ 

sin 

((2 

⋅i 

+ 1) ⋅ x) 

i= 0 2 ⋅i 

+ 

1 

sin( x) 

f 

2 

( x) 

= f 

3( 

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. Ecriture 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 6 . 

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.… 

6 Exercice facultatif.

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 

+ 

U 

N 

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 

filtre 

Y

Algorithmique et Langage - Pages de Michel Deloizy - Free

Create successful ePaper yourself

Delete template?

Save as template?