Algo

Données et Algorithmique
Données et Données et Algorithmique

Algorithmique Ce document décrit les structures de données et les algorithmes
que l'on peut leur associer. Contrairement à beaucoup d'ouvrages
- Sommaire d'algorithmique, j'ai préféré mettre l'accent sur le choix des
structures de données. Il est avant tout important de définir coment
● INTRODUCTION modéliser le problème à traiter, ainsi que ses données. Ce choix
fait, on cherchera ensuite l'algorithme optimal, adapté aux types
● LES VARIABLES de données choisies. Ce document n'est pas spécifique à un
SCALAIRES langage (il suffit qu'il soit structuré). Les exemples par contre sont
❍ codage binaire tous donnés en C (ANSI), mais sont facilement transposables dans
un autre langage. Vous trouverez les informations nécessaires
❍ boucles
dans mon document sur le langage C ou, pour un détail particulier,
❍ récursivité son index.
● LES TABLEAUX
Autres sites sur l'algorithmique : Jean-Jacques Levy
STATIQUES
(Polytechnique), Jean Beuneu (EUDIL Lille), cours de JL
❍ tableaux Bienvenu (CNAM Bordeaux), les polycopiés de Jean Fruitet (IUT
unidimensionnels Marne la Vallée)
■ généralités
■ fonctions de base ● INTRODUCTION
(fichier inclus
● LES VARIABLES SCALAIRES
base_tus)
● LES TABLEAUX STATIQUES
■ manipulations
dans les tableaux ● LES TABLEAUX DYNAMIQUES
(mani_tus) ● LES LISTES
■ tris ● LES PILES ET FILES
■ généralités ● LES ARBRES
(valables ● LES GRAPHES
également ● LES FICHIERS
pour
● CORRECTION DES EXERCICES
d'autres
types de ● Sommaire
données)
■ le tri bulle
■ le tri par
insertion
http://www-ipst.u-strasbg.fr/pat/program/algo.htm (1 of 4) [21-11-2001 17:39:47]

■ le tri par
sélection
■ le tri shell
■ le tri rapide
(Quick
Sort)
■ le tri par
création
■ d'autres tris
■ recherches
■ la
recherche
séquentielle
■ la
dichotomie
■ calculs
mathématiques
■ calcul
vectoriel
■ polynômes
❍ tableaux
multidimensionnels
❍ conclusions
● LES TABLEAUX
DYNAMIQUES
❍ tableaux
unidimensionnels en C
❍ la méthode du
super-tableau
❍ les tableaux
multidimensionnels
■ matrices pleines
(matrices
rectangulaires
dynamiques :
mrd)
■ tableaux de
tableaux

dynamiques
❍ conclusions
● LES LISTES
❍ fonctions de base et
manipulations (base_lst)
❍ les tris
■ le tri bulle
■ le tri par insertion
■ le tri par sélection
■ le tri par création
■ les autres tris
❍ problèmes
mathématiques
❍ conclusions
● LES PILES ET FILES
❍ définition
❍ fonctions de base
❍ utilisations
● LES ARBRES
❍ introduction
❍ expressions
arithmétiques (arb_expr)
❍ listes triées
❍ les arbres généraux
● LES GRAPHES
● LES FICHIERS
❍ les fichiers séquentiels
❍ les fichiers à accès
direct
❍ l'indexation
● CORRECTION DES
EXERCICES
❍ BOUCLE
❍ TUSEXO_A
❍ TUSEXO_B

❍ GAUSS_MRD
❍ INSE_TTD
● recherche dans l'index de mon
document sur le langage C

Données et Algorithmique - P.TRAU
Ce document décrit les structures de données et les algorithmes que l'on peut leur associer. Contrairement
à beaucoup d'ouvrages d'algorithmique, j'ai préféré mettre l'accent sur le choix des structures de données.
Il est avant tout important de définir coment modéliser le problème à traiter, ainsi que ses données. Ce
choix fait, on cherchera ensuite l'algorithme optimal, adapté aux types de données choisies. Ce document
n'est pas spécifique à un langage (il suffit qu'il soit structuré). Les exemples par contre sont tous donnés
en C (ANSI), mais sont facilement transposables dans un autre langage. Vous trouverez les informations
nécessaires dans mon document sur le langage C ou, pour un détail particulier, son index.
Autres sites sur l'algorithmique : Jean-Jacques Levy (Polytechnique), Jean Beuneu (EUDIL Lille), cours
de JL Bienvenu (CNAM Bordeaux), les polycopiés de Jean Fruitet (IUT Marne la Vallée)
● INTRODUCTION
● LES TABLEAUX DYNAMIQUES
● LES LISTES
● LES ARBRES
● LES GRAPHES
● LES FICHIERS
● Sommaire
http://www-ipst.u-strasbg.fr/pat/program/algo_t.htm [21-11-2001 17:39:57]

Données et Algorithmique - INTRODUCTION
INTRODUCTION
Lorsque l'on désire créer un programme répondant à un cahier des charges bien défini (condition
préalable évidement nécessaire), il faut déterminer quelles données il va falloir traiter, et comment les
traiter. La première étape est donc de choisir comment représenter en mémoire ces données, et si
plusieurs possibilités sont envisageables, choisir la plus appropriée aux traitements qu'il faudra effectuer
(c'est à dire celle pour laquelle les algorithmes seront le plus facile à mettre en oeuvre). Dans un gros
programme (C.A.O. par exemple), on appelle modèle la structure choisie pour stocker les données en
mémoire.
Une fois ce modèle défini, le programme doit être écrit de manière structurée, c'est à dire être décomposé
en petites entités (sous programmes, fonctions en C), réalisant chacune une tâche bien définie, en ayant
bien défini quelles sont les données nécessaires en entrée du sous programme, et quelles seront les
données retournées en sortie du sous programme (arguments ou dans certains cas variables globales). La
réalisation pratique de la tâche doit ne dépendre que de ses entrées et sorties, et n'accéder à aucune autre
variable (par contre elle peut utiliser pour son propre compte autant de variables locales que nécessaire).
Ceci permet d'éviter les effets de bord, qui rendent la recherche d'erreurs (débogage) presque impossible.
Le choix d'un modèle est capital : devoir le modifier une fois le programme bien avancé nécessite en
général la réécriture complète du programme, alors que modifier certaines fonctionnalités du programme
correspond à ajouter ou modifier des sous programmes sans modifier les autres. C'est un des intérêts de la
programmation structurée. Par contre, pour pouvoir plus facilement modifier le modèle, il faut des
structures de données hiérarchisées et évolutives (disponibles dans les langages orientés objets). Un autre
avantage de la programmation structurée est la possibilité de créer dans un premier temps chaque sous
programme réalisant une tâche déterminée grâce à un algorithme simple, puis d'optimiser uniquement les
sous-programmes souvent utilisés, ou demandant trop de temps de calcul, ou nécessitant trop de
mémoire.
Parlons encore de l'optimisation d'un programme. On n'optimise un programme (ou du moins certaines
parties) que si l'on estime que son fonctionnement n'est pas acceptable (en temps ou en consommation de
mémoire). On devra choisir un algorithme en fonction des conditions d'utilisation du programme (on ne
trie pas de la même manière un fichier totalement mélangé et un fichier déjà trié , mais avec quelques
valeurs non triées en fin de fichier). A partir d'un moment, on ne peut plus optimiser en temps et en
mémoire. Il faut alors choisir. Par exemple, un résultat de calcul qui doit être réutilisé plus tard peut être
mémorisé (gain de temps) ou on peut préférer refaire le calcul (gain de mémoire). Par exemple, il est rare
de passer par une variable intermédiaire pour utiliser deux fois i+1.
http://www-ipst.u-strasbg.fr/pat/program/algo01.htm [21-11-2001 17:40:12]

Sommaire général PROGRAMMATION
Sommaire général
PROGRAMMATION
Vous trouverez ici mes (gros) documents sur la programmation : C, C++, algorithmique, infographie,
Pascal). ainsi que la possibilité de télécharger les exemples (bien que le copier - coller sous Netscape ou
IE marche également très bien), mais aussi les corrections des exercices, la bibliothèque graphique, des
exemples supplémentaires, des sujets de TP, d'examens....
Copyright : utilisation de ces documents libre pour tout usage personnel. Utilisation autorisée pour tout
usage public non commercial, à condition de citer son auteur (Patrick TRAU, IPST, Université Louis
Pasteur Strasbourg, email : ) et de me signaler tout usage intensif. Utilisation commerciale interdite sans
accord écrit de ma part.
Cliquez sur l'icône (à droite) pour voter pour le site n°3464 du TOP Ouaibe (cours en
ligne de P. TRAU).
vous pouvez accéder à :
● Cours sur le C (ANSI) (y compris correction des exercices), qui détaille complètement le langage
C
● Données et Algorithmes : les différents algorithmes classiques, expliqués, comparés, en fonction
des types de données choisies. Chaque algorithme est accompagné de sa mise en oeuvre en C
● Infographie : comment dessiner sur un matériel (écran, imprimante...) sur lequel on sait au moins
allumer un point. Les tracés de base (droites, courbes...), les remplissages et hachurages, clipping,
tracés 3D,... La documentation de la bibliothèque graphique téléchargeable. Les exemples sont en
C ANSI.
● sommaire et instructions de téléchargement de la disquette d'accompagnement concernant les trois
documents cités ci-dessus (mais aussi la bibliothèque graphique en version Pascal)
● le C++ (ce document suppose que vous connaissez déjà le C)
● Cours de Pascal
● évaluez vous avec mes sujets d'examens (dont certains avec correction) (en particulier en C)
● Plus spécifiquement pour les étudiants d'IUP2 à l'IPST (les autres ont aussi le droit de regarder) :
les sujets et correction des TP (97/98 en version détaillée, et ceux de l'année en cours, au fur et à
mesure).
● Certains points du C expliqués par les étudiants de DEUG TI
La plupart de ces documents contiennent des frames (écran séparé en deux parties). Pour revenir à cette
page (et quitter les frames), une solution est de cliquer sur le bon (à vous de trouver lequel).
http://www-ipst.u-strasbg.fr/pat/program/ (1 of 2) [21-11-2001 17:40:27]

Sommaire général PROGRAMMATION
Bonne lecture !
Pour toute question, envoyez moi un , ou regardez mes FAQ. S'il vous plait, signalez moi toute erreur !
Liens externes : Vous cherchez un compilateur gratuit (C/Pascal) ? utilisez gcc, gpp sous Linux/Unix,
Sous DOS regardez l'ABC de la Programmation : Olivier Pecheux vous aide à démarrer (y compris à
installer le compilateur freeware DJGPP). si vous cherchez d'autres sites sur la programmation, en voici
des listes : en français ou en anglais.
Depuis le 20/3/1997, vous êtes le ème lecteur de cette page

P. TRAU, ULP-IPST, 20/3/97
Vous pouvez ici accéder aux autres informations sur ce serveur, normalement ou par carte.
http://www-ipst.u-strasbg.fr/pat/program/ (2 of 2) [21-11-2001 17:40:27]

Données et Algorithmique - Sommaire

● INTRODUCTION
❍ codage binaire
❍ boucles
❍ récursivité
❍ tableaux unidimensionnels
■ généralités
■ fonctions de base (fichier inclus base_tus)
■ manipulations dans les tableaux (mani_tus)
■ tris
■ généralités (valables également pour d'autres types de données)
■ le tri bulle
■ le tri shell
■ le tri rapide (Quick Sort)
■ d'autres tris
■ recherches
■ la recherche séquentielle
■ la dichotomie
■ calculs mathématiques
■ calcul vectoriel
■ polynômes
❍ tableaux multidimensionnels
❍ conclusions
http://www-ipst.u-strasbg.fr/pat/program/algo_c.htm (1 of 3) [21-11-2001 17:40:36]

❍ tableaux unidimensionnels en C
❍ la méthode du super-tableau
❍ les tableaux multidimensionnels
■ matrices pleines (matrices rectangulaires dynamiques : mrd)
■ tableaux de tableaux dynamiques
❍ conclusions
● LES LISTES
❍ fonctions de base et manipulations (base_lst)
❍ les tris
■ le tri bulle
■ les autres tris
❍ problèmes mathématiques
❍ conclusions
❍ définition
❍ utilisations
● LES ARBRES
❍ introduction
❍ expressions arithmétiques (arb_expr)
❍ listes triées
● LES GRAPHES
● LES FICHIERS
❍ les fichiers à accès direct
❍ l'indexation
❍ BOUCLE
❍ TUSEXO_A

❍ TUSEXO_B
❍ GAUSS_MRD
❍ INSE_TTD
● recherche dans l'index de mon document sur le langage C

Données et Algorithmique - Index

A,B,C,D,E,F,G,I,L,M,N,O,P,Q,R,S,
T,U,V,W
A
● accès
● direct [1]
[2]
❍ séquentiel [1] [2]
● allocation dynamique [1]
● arbre [1]
● binaire [1]
[2]
● argument [1]
B
● bande [1] [2]
● binaire [1]
● bit [1]
● boucles [1]
C
● index du langage C
● chiffres significatifs [1]
● clef [1] [2]
http://www-ipst.u-strasbg.fr/pat/program/algo_i.htm (1 of 6) [21-11-2001 17:40:43]

D
● débogage [1]
● décalage [1]
● décalages [1]
● défiler [1]
● dépiler [1]
● define [1]
● deuxaire [1]
● dichotomie [1] [2]
[3]
● dimension [1] [2]
● do-while [1]
● dynamique [1] [2]
[3] [4]
E
● effet de bord [1]
● empiler [1]
● encombrement [1]
● enfiler [1]
F
● feuille [1]
● fichier [1]
● FIFO [1]
● file [1]
● fils [1]
● float [1]
● for [1]
● free [1]

G
● Gauss [1] [2]
● graphe [1]
I
● index [1]
● indexation [1]
● infixé [1] [2]
● insertion [1] [2]
[3] [4] [5]
● interpolation [1]
L
● Lagrange [1]
● largeur de bande [1]
● LIFO [1]
● ligne de ciel [1] [2]
● liste [1] [2]
[3]
M
● malloc [1]
● mathématiques [1] [2]
[3] [4]
● matrice [1] [2]
[3]
❍ triangulée [1]
● modèle [1]

N
● noeud [1]
● notation polonaise [1]
● NULL [1] [2]
[3]
O
● objets [1]
● optimisation [1]
P
● parcours [1] [2]
[3]
● pile [1] [2]
[3]
● pivot [1]
● de Gauss [1]
● pointeur [1] [2]
[3]
● polynôme [1] [2]
● postfixé [1] [2]
● préfixé [1] [2]
Q
● queue [1]
● Quick Sort [1]
R
● récursif [1]
● récursivité [1] [2]

[3]
● racine [1]
● recherche [1] [2]
● retassage [1]
S
● séquentiel [1] [2]
● sentinelle [1]
● spline [1]
● stable [1]
● (tri) [1]
● stack [1]
● strcmp [1]
● structuré [1]
● suites [1]
● super-tableau [1] [2]
● suppression [1] [2]
[3]
T
● tableau [1] [2]
[3] [4] [5] [6] [7]
❍ dynamique [1]
❍ multidimensionnel [1]
❍ statique [1]
● ternaire [1]
● tri [1]
❍ bulle [1] [2]
● tri par
● arbre [1]
❍ comptage [1]
❍ création [1] [2] [3]

❍ fusion [1] [2]

❍ insertion [1] [2] [3]
❍ sélection [1] [2]
● rapide [1] [2]
● shell [1] [2]
● triangulation [1] [2]
● typedef [1]
U
● unaire [1]
V
● vecteur [1]
● virgule flottante [1]
W
● while [1]

Le langage C - cours P.TRAU
Langage C
Le Langage C
Aujourd'hui, l'informatique est présente dans tous les domaines de la vie courante, mais à des degrés
différents. Il y a pour cela trois grandes raisons :
- les gains (en temps, argent, qualité) que l'informatique peut apporter,
- le prix abordable des matériels,
- la disponibilité de logiciels dans tous les domaines.
Deux domaines sont pleinement exploités :
- les logiciels généraux, vendus en grande série, et donc relativement bon marché,
- les logiciels spécifiques, d'un coût total important et donc limités à des sujets très pointus, pour de très
grosses industries.
Le domaine intermédiaire, qui peut encore se développer, concerne les programmes spécifiques, pour des
applications de moindre importance. Pour cela, il est nécessaire de disposer de langages de
programmation. Les tableurs et bases de données par exemple disposent désormais de véritables langages
de programmation (souvent orientés objets) qui vont plus loin que les précédents langages de
macro-commandes. Pour les autres cas, le C est souvent le meilleur choix. En effet, c'est un langage
structuré, avec toutes les possibilités des autres langages structurés. Mais il permet également (avec son
extension C++) de gérer des objets. A l'inverse, il permet également une programmation proche du
langage machine, ce qui est nécessaire pour accéder aux interfaces entre l'ordinateur et son extérieur.
Mais son principal avantage est que ces trois types de programmation peuvent être combinés dans un
même programme, tout en restant portable sur tous les ordinateurs existants. Le langage C a néanmoins
deux inconvénients majeurs, c'est d'être un peu plus complexe d'utilisation (mais uniquement du fait de
ses nombreuses possibilités), et d'être séquentiel, ce qui ne lui permettra pas d'être le langage optimal
pour les machines massivement parallèles (mais aujourd'hui il n'existe pas encore de langage universel
pour ce type de machines qui puisse combiner efficacement des calculs procéduraux et du déclaratif).
Ceci est la première partie du livre "Programmation en C, langage et algorithmes", qui est composé de
trois parties.
* La première définit le langage C, avec de nombreux exemples directement dans le texte, et certains
supplémentaires en annexe.
* La seconde partie traite des structures de données et des algorithmes. Elle n'est pas spécifique, seuls les
exemples sont en C, le texte et les algorithmes restent utilisables dans tout langage séquentiel. Les
fonctionnalités du C non disponibles dans d'autres langages sont analysées, le méthodes utilisées pour
http://www-ipst.u-strasbg.fr/pat/program/tpc_t.htm (1 of 2) [21-11-2001 17:40:49]

Le langage C - cours P.TRAU
parvenir au même résultat sont précisées (par exemple, gestion d'un liste dynamique à l'aide d'un
tableau).
* La troisième partie quand à elle traite des algorithmes d'infographie. Elle est importante du fait de la
nécessité du graphisme dans les programmes. Mais elle détaille également, pour ces cas pratiques, les
méthodes et moyens utilisés pour optimiser des algorithmes. Une bibliothèque graphique est fournie en
annexe.
* Les parties que j'ai prévues, mais pas encore rédigées : utilisation des objets C++, programmation
graphique évennementielle (Microsoft Windows, X-Windows)
● Introduction (première partie)

● Connaissances de base
● Fonctions d'entrées/sorties les plus utilisées
● La syntaxe du C
● Les fichiers de données
● Directives du pré-compilateur
● Utiliser Turbo C (3.5 par exemple)
● Correction des exercices
● Autres sites sur le C
● Sommaire
http://www-ipst.u-strasbg.fr/pat/program/tpc_t.htm (2 of 2) [21-11-2001 17:40:49]

Langage C - Index
Langage C - Index
A,B,C,D,E,F,G,H,I,K,L,M,N,O,P,Q,R,S
,T,U,V,W
A
● accès direct [1] [2]
● accès séquentiel [1]
● addition [1]
● adresse [1]
● affectation [1] [2]
● alloc.h [1]
● ANSI [1] [2] [3] [4]
● antislash [1]
● arbre [1]
● argc [1]
● argument [1] [2] [3] [4] [5] [6]
❍ formel [1] [2]
❍ réel [1] [2]
● argv [1]
● associativité [1]
● atof [1]
● atoi [1]
● atol [1]
● auto [1]
http://www-ipst.u-strasbg.fr/pat/program/tpc_i.htm (1 of 9) [21-11-2001 17:40:58]

Langage C - Index
B
● bibliothèque [1]
● bibliothèques standard [1]
● bit [1]
● blanc [1]
● bloc [1] [2] [3] [4]
● boucle [1]
● break [1] [2]
● buffer [1]
C
● calloc [1]
● caractère [1] [2]
● case [1]
● cast [1] [2]
● chaîne [1] [2]
● champ [1]
● char [1] [2]
● classe [1] [2]
● close [1]
● commentaire [1]
● conio.h [1]
● continue [1]
● contrôle [1]
● conversion [1]
● corps [1]
● ctype.h [1]
D
● déclaration [1] [2] [3]
❍ de type [1]

Langage C - Index
❍ globale [1]
❍ locale [1]
● décrémentation [1]
● default [1]
● define [1] [2] [3]
● deuxaire [1]
● directive [1]
● division [1]
● do while [1]
● double [1]
● durée de vie [1]
E
● else [1]
● entête [1]
● de fonction [1]
● entier [1] [2]
● entrées/sorties [1]
● enum [1]
● énumération [1]
● EOF [1] [2]
● errno.h [1]
● exit [1]
● expression [1] [2]
● extern [1]
F
● faire tant que [1]
● fclose [1]
● fcntl.h [1]
● feof [1]
● fflush [1]

Langage C - Index
● fgetc [1]
● fgets [1]
● fichier [1] [2]
● filelength [1]
● float [1]
● fonction [1] [2] [3]
● fopen [1]
● for [1]
● format printf [1]
● formaté [1] [2]
● fprintf [1]
● fputc [1]
● fputs [1]
● fread [1]
● free [1]
● fscanf [1]
● fseek [1]
● fwrite [1]
G
● getch [1]
● getchar [1]
● getche [1]
● gets [1]
● goto [1]
● goto calculé [1]
H
● handle [1]
● heap [1]

Langage C - Index
I
● identificateur [1]
● if [1] [2]
❍ imbriqué [1]
● ifdef [1]
● ifndef [1]
● include [1] [2]
● incrémentation [1]
● instruction [1]
● int [1]
● isalnum [1]
● isalpha [1]
● isdigit [1]
● islower [1]
● isspace [1]
● isupper [1]
K
● Kernigham [1]
L
● label [1]
● liste [1]
● long [1] [2] [3]
● longueur d'identificateur [1]
● lseek [1]
● Lvalue [1]
M
● macro [1]
● main [1]

Langage C - Index
● malloc [1] [2]

● matrice [1]
● mem.h [1]
● memcmp [1]
● memcpy [1]
N
● NULL [1] [2]
O
● opérande [1]
● opérateur [1] [2]
● open [1]
P
● paramètre [1]
● passage d'argument [1]
● pile [1] [2] [3]
● pointeur [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11]
● pour [1]
● pré-compilateur [1]
● printf [1] [2]
● priorité [1]
● produit [1]
● prototype [1]
● putch [1]
● puts [1] [2]
Q
● quote [1]

Langage C - Index
R
● récursivité [1]
● réel [1] [2]
● rand [1]
● read [1]
● realloc [1]
● register [1]
● return [1] [2]
● Ritchie [1]
● Rvalue [1]
S
● séquentiel [1]
● scalaire [1]
● scanf [1] [2]
● short [1] [2]
● si - Sinon [1]
● soustraction [1]
● sprintf [1]
● sscanf [1]
● static [1] [2] [3]
● stdio.h [1] [2]
● stdlib.h [1] [2]
● strcat [1]
● strcmp [1]
● strcpy [1]
● string.h [1]
● strlen [1]
● strncat [1]
● strncpy [1]
● struct [1] [2]
● structuré [1]

Langage C - Index
● structure [1] [2]

● switch [1]
T
● tableau [1] [2] [3]
● tailles [1]
● tant que [1]
● tas [1]
● ternaire [1]
● tolower [1]
● toupper [1]
● typedef [1] [2] [3] [4]
U
● unaire [1]
● undef [1]
● ungetc [1]
● union [1]
● unsigned [1] [2] [3]
V
● variable [1] [2]
● variables locales [1]
● visibilité [1]
● visible [1]
● void [1]
W
● while [1]
● write [1]

Langage C - Index

Données et Algorithmique - LES VARIABLES SCALAIRES
LES VARIABLES SCALAIRES

● codage binaire
● boucles
● récursivité
codage binaire
Les seules valeurs que peut traiter l'ordinateur (et d'ailleurs tout système numérique) est le 0 et le 1 (en
fait, c'est nous qui représentons par 0 ou 1 le fait que le système numérique ait vu du courant ou non). Un
problème important est que différents types d'informations doivent être codés : instructions machine
(lignes de programmes), valeurs numériques, caractères, adresses,... et que rien ne permet de distinguer
dans un groupe de 0 et de 1 le type d'information qu'il est censé représenter (10010110 est sur un PC le
code machine permettant d'échanger les contenus des registres SI et AX, mais également le code du
caractère 'û', de l'octet signé décimal -106, du signé 150, l'exposant du flottant 1,23x10-32, etc...). Il est
donc capital d'associer à chaque mémoire que l'on utilise le type de donnée que l'on y mettra. C'est ce que
permet la déclaration des variables dans les langages évolués (explicite en Pascal et en C, implicite en
Basic et Fortran). Néanmoins cette erreur reste possible (en C, lors d'une erreur sur des pointeurs, par
l'utilisation des unions, ou simplement par erreur de format dans un printf).
Une autre erreur est due à la représentation des nombres négatifs. En effet, le signe ne peut être, lui aussi,
représenté que par 0 ou 1. Le codage choisi (pour les entiers 16 bits) fait que l'ajout de 1 à 32767 (le plus
grand entier signé) donne -32768 (cela devait de toute façon donner un nombre car soit il y a du courant,
soit il n'y en a pas, il n'est pas prévu de combinaison de 0 et 1 représentant une erreur). La plupart des
compilateurs ne signalent pas d'erreur en cas de dépassement de capacité de nombres entiers.
Autre problème, la codification des réels. Représenter la présence ou non d'une virgule par un 0 ou un 1
est évidement impossible (comment la reconnaître ?), la première solution envisagée était donc la virgule
fixe (un mot pour la partie entière, un autre pour la partie fractionnaire). On utilise désormais la "virgule
flottante" (d'où le nom de flottants ou float), représentée par un mot pour la mantisse (qui est un réel en
virgule fixe puisque pas de partie entière), un autre (souvent de taille différente) pour l'exposant (entier
signé). Ceci implique deux limitations : le nombre de chiffres significatifs (dû à la taille de la mantisse),
et le plus grand réel codifiable (dû à la taille de l'exposant, par exemple 2127=1,7.1038). On cherchera
donc à ne combiner que des réels du même ordre de grandeur. Par exemple en mécanique, ajouter à une
dimension d'un mètre une dilatation thermique d'un micron n'a de sens que si les flottants possèdent plus
de 6 chiffres significatifs, donc par exemple un algorithme cumulatif ne donnera pas de résultat si le pas
en température est trop faible.
Dans les deux cas (virgule fixe ou flottante), un problème se pose : en fait, nous ne pouvons représenter
http://www-ipst.u-strasbg.fr/pat/program/algo02.htm (1 of 4) [21-11-2001 17:41:05]

qu'un sous ensemble des réels (je ne pense pas que les mathématiciens lui aient donné un nom) qui
correspond à la différence, en base 10, entre D et R. En fait on ne peut représenter que les nombres
pouvant s'écrire sous forme d'une partie fractionnaire comportant un nombre fini de chiffres (en binaire).
Or, comme c'est impossible en base 10 pour 1/3 (qui pourtant s'écrit 0,1 en base 3) la représentation en
binaire de 1/10 donne une suite infinie, qui est donc toujours tronquée (0,1d =
0,000100100100100100100...b). donc sur tout ordinateur calculant en binaire, (1/10)*10 donne
0,999999999... Cette erreur devient gênante dans le cas où le résultat du calcul précédent est utilisé dans
le calcul suivant, pour de grandes suites de calculs.
exemple (flottant):
#include <stdio.h>
void main(void)
{
float x=1000;
int i;
for (i=0;i<10000;i++)x+=0.1;
printf("On obtient %12.4f au lieu de 2000.0000\n",x);
}
Ce problème est moins flagrant en C que dans les autres langages, le C effectuant toujours les calculs sur
des réels en double précision. Il en résulte néanmoins que, par exemple, il ne faut pas tester dans un
programme si le résultat d'un calcul flottant est nul mais si sa valeur absolue est inférieure à un petit
nombre. On cherchera aussi, autant que possible, à choisir des algorithmes utilisant des entiers plutôt que
des réels, d'autant plus que les calculs sur des flottants sont plus lents que sur des réels.
boucles
Tous les langages possèdent des structures permettant de répéter des instructions, les boucles. En général,
certaines sont réservées aux cas où l'on connaît à l'entrée le nombre de boucles à effectuer (for en C), et
celles dont on connaît la condition d'arrêt (while et do-while en C). (voir exemples dans la première
partie).
Lorsqu'une valeur à calculer C dépend de n calculs intermédiaires Ci (que l'on ne désire pas mémoriser),
la méthode la plus simple consiste à initialiser C à la première valeur C1, puis pour i variant de 2 à n,
calculer chaque Ci et le cumuler à C. C'est en général la méthode utilisée pour les calculs de sommes,
produits, suites...
exemple (boucle_A) : calculer xn :
#include <stdio.h>
void main(void)
{
int n,i,x,result;
printf("entrez x et n : ");

scanf("%d %d",&x,&n);
result=x;
for(i=1;i<n;i++)result*=x;
printf("résultat : %d\n",result);
}
La fonction puissance est souvent disponible dans les langages (pow en C), mais correspond à un calcul
assez long et souvent moins précis (xn=exp(n*ln(x)) qui donne toujours un résultat avec une erreur de
précision même si x est entier). La méthode ci-dessus sera plus rapide soit pour n petit (quelques
multiplications d'entiers sont plus rapides qu'une exponentielle de logarithme), soit quand toutes les
puissances intermédiaires doivent être connues.
Exercice (boucle) : faire le programme calculant 2x4-3x3+x2-5x+2 pour x réel.
exemple (boucle_B) : calcul de moyenne :
#include <stdio.h>
void main(void)
{
int n=0;
float note,moy=0;
do
{
printf("entrez la note (négative pour terminer) : ");
scanf("%f",&note);
if(note>=0)
{
moy+=note;
n++;
}
}
while(note>=0);
moy/=n;
printf("moyenne : %f\n",moy);
}
Les valeurs des notes ayant servi au calcul ne sont pas mémorisées, car toutes stockées successivement
dans la même mémoire.
récursivité
On appelle fonction récursive une fonction qui s'appelle elle-même. La récursivité n'est possible que dans
un langage acceptant des variables locales. En effet, l'emploi de la récursivité n'est réellement utile que
lorsqu'une fonction doit retrouver, après un appel récursif, toutes ses variables locales dans leur état
initial. Dans le cas contraire, une méthode itérative (boucle) sera en général plus efficace (il est inutile de
mémoriser les variables locales et les restaurer pour ne plus les réutiliser), comme par exemple pour le
calcul d'une factorielle (voir mon document sur le C, paragraphes 4.6 et 4.7, pour l'explication de la

récursivité, l'empilement des variables locales et l'exemple de la factorielle).

Néanmoins dans un certain nombre de cas, l'emploi de la récursivité facilite la programmation. Si le
temps de calcul ou la mémoire utilisée sont prohibitifs pour de grands nombres de données, il est
toujours possible de traduire un algorithme récursif en itératif, et souvent de manière plus efficace que le
compilateur, qui est obligé de le faire (le langage machine n'est pas récursif) sans connaître aussi bien
que vous les conditions d'utilisation de l'algorithme.

Données et Algorithmique - LES TABLEAUX STATIQUES
LES TABLEAUX STATIQUES

● tableaux unidimensionnels
❍ généralités
❍ fonctions de base (fichier inclus base_tus)
❍ manipulations dans les tableaux (mani_tus)
❍ tris
■ le tri bulle
■ le tri shell
■ d'autres tris
❍ recherches
■ la dichotomie
❍ calculs mathématiques
■ polynômes
● tableaux multidimensionnels
● conclusions
tableaux unidimensionnels
généralités
Un tableau permet de regrouper dans une structure plusieurs valeurs scalaires de même type. Pour permettre une
maintenance aisée du programme, la dimension doit être définie par une constante. C'est cette dernière qui sera
utilisée pour les tests de dépassement (peu de compilateurs le font automatiquement, ils le feraient par exemple à
l'intérieur d'une boucle alors que le test sur la valeur finale serait suffisant). La taille réellement utilisée peut être
inférieure ou égale à la dimension du tableau, les composantes au delà de la taille utilisée peuvent être mises à 0
mais cela n'a aucun intérêt, sauf si on interdit le 0 dans le tableau (cas des caractères, en C).

Nous allons travailler dans un premier temps sur des tableaux de flottants. Nous utiliserons des tableaux dont le
premier indice est 0 puisque c'est la seule possibilité en C, et la solution optimale dans les autres langages
puisque nécessitant moins de calculs dans le code compilé. Si tous les tableaux utilisés ont la même dimension,
on peut définir de manière globale :
#define composante float

#define dim_tus 100
typedef composante type_tus[dim_tus];
Ces déclarations sont nécessaires dans les langages effectuant un contrôle très strict des types de données
(comme le Pascal) et refusant de combiner des tableaux de tailles différentes. En C, nous pouvons préparer des
fonctions sur tous tableaux de réels, quelle que soit leur dimension :

typedef composante type_tus[]; /* ou typedef composante *type_tus */
C'est cette seconde déclaration que nous utiliserons dans les exemples suivants.
Remarque : dans notre cas il peut être intéressant de définir un tableau comme une structure regroupant le
tableau, sa dimension et sa taille effective.
fonctions de base (fichier inclus base_tus)

Les fonctions de base sur les tableaux unidimensionnels sont l'initialisation du tableau, l'ajout d'une valeur en fin
du tableau, et l'affichage de tout le tableau :
void init_tus(type_tus tab,int *taille,int dim)

{
int i;
for(i=0;i<dim;i++) tab[i]=0;
*taille=0;
}
L'initialisation à 0 n'est pas nécessaire dans la plupart des cas. La taille est passée par adresse puisque modifiée
par la fonction init_tus.
int ajoute_val_tus(type_tus tab,int *taille,int dim,composante val)

/* retourne 0 si tout s'est bien passé, 1 si erreur */
{
if (*taille>=dim)
{
puts("dépassement de capacité du tableau");
return(1);
}
/* le else n'est pas nécessaire du fait du return précédent */
tab[(*taille)++]=val;
return(0);
}
void affiche_tus(type_tus tab,int taille)

{

int i;
for(i=0;i<taille;i++) printf("%dième valeur :
%f\n",i+1,tab[i]);
}
Les déclarations globales et fonctions ci-dessus étant recopiées dans le fichier "base_tus", nous pouvons écrire le
programme suivant (ex_tus) :
#include <stdio.h>
#include "base_tus.inc"
#define dim 100
void main(void)
{
int nb;
composante v,t[dim];
init_tus(t,&nb,dim);
do
{
printf("entrez la %dième note (fin si <0 ou >20) :",nb+1);
scanf("%f",&v);
if(v<0||v>20) break; /* on aurait pu le mettre
dans la condition du while */
}
while (!ajoute_val_tus(t,&nb,dim,v));
affiche_tus(t,nb);
}
Exercice (tusexo_a) : modifier ce programme pour qu'il calcule la moyenne et affiche, pour chaque note, l'écart
avec la moyenne (ce qui nécessite l'utilisation d'un tableau car il faut d'abord calculer la moyenne puis utiliser les
notes mémorisées auparavant).
manipulations dans les tableaux (mani_tus)

L'insertion et la suppression de composantes d'un tableau nécessitent des décalages des autres composantes du
tableau:
void suppr_tus(type_tus tab,int *taille,int position)

{
int i;
if(position>=*taille||position<0)return;
(*taille)--;
for(i=position;i<*taille;i++)tab[i]=tab[i+1];
}
On peut remarquer que la suppression de la dernière composante n'entraîne aucun décalage.
int insert_tus(type_tus tab,int *taille,int dim,int position,composante val)

/* retourne 0 si pas d'erreur */
{
int i;
if(position<0)return(1);

if(position>*taille)position=*taille;
if (*taille>=dim)
{
puts("dépassement de capacité du tableau");
return(2);
}
for(i=*taille;i>position;i--)tab[i]=tab[i-1];
tab[position]=val;
(*taille)++;
return(0);
}
Le décalage doit se faire par indice décroissant (par indice croissant, on recopierait progressivement la
composante à l'indice position dans tout le reste du tableau).
Les rotations sont également des manipulations fréquentes sur les tableaux :
void rot_gauche_tus(type_tus tab,int taille)

{
composante tampon;
int i;
tampon=tab[0];
for(i=1;i<taille;i++)tab[i-1]=tab[i];
tab[taille-1]=tampon;
}
void rot_droite_tus(type_tus tab,int taille)
{
composante tampon;
int i;
tampon=tab[taille-1];
for(i=taille-1;i>0;i--)tab[i]=tab[i-1];
tab[0]=tampon;
}
Exercice (tusexo_b) : faire un programme permettant de tester ces fonctions, à l'aide d'un menu permettant
d'essayer dans n'importe quel ordre ces fonctions.
tris
généralités (valables également pour d'autres types de données)
Les exemples qui suivent traitent des tableaux de flottants, les méthodes étant identiques pour tout type de
composante à condition d'y définir une relation d'ordre (par exemple, pour des chaînes de caractères on utilisera
strcmp au lieu de <, > et =). Mais il ne faut pas oublier que l'efficacité de l'algorithme dépend également des
types de données traitées : une comparaison de chaînes de caractères étant relativement longue, les algorithmes
effectuant beaucoup de tests seront moins efficaces qu'avec des flottants. De même, les tableaux trop gros pour
entrer en mémoire devront être traités sur support externe, rendant l'accès aux données (plusieurs millisecondes)
bien plus lent que les tests ou calculs (micro voire nanosecondes). Dans les cas plus complexes, comme par
exemple les tableaux de structures, on appelle clef le champ servant pour le tri (par exemple le nom pour un
tableau contenant nom, prénom, adresse,...). Dans ce cas, les calculs sur les clefs seront souvent plus rapides que
les déplacements des structures entières. Les méthodes de tris présentées ici sont souvent utilisables également

avec les autres types de données, mais les conclusions sur leur efficacité varieront. On qualifiera de stable un tri
laissant dans le l'ordre initial les éléments de clef identique (par exemple, un stock saisi au fur et à mesure des
arrivées de matériel, le classement par ordre alphabétique gardant les matériels de même nom dans leur ordre
d'arrivée sera stable). Tous les algorithmes décrits ici sont stables, à condition d'y prendre garde (scruter le
tableau du début vers la fin et non l'inverse par exemple). Dans ce chapitre, nous noterons N le nombre de
composantes du tableau (appelé taille auparavant).
le tri bulle
Cet algorithme est relativement connu, bien qu'il soit rarement efficace (en termes de temps de calcul, le tri est
néanmoins correct, bien évidement). Il consiste à balayer tout le tableau, en comparant les éléments adjacents et
les échangeant s'ils ne sont pas dans le bon ordre. Un seul passage ne déplacera un élément donné que d'une
position, mais en répétant le processus jusqu'à ce plus aucun échange ne soit nécessaire, le tableau sera trié.
(bull_tus)
void tri_bulle_tus(type_tus tab, int N)

{
int ok,i;
composante tampon;
do
{
ok=1; /* vrai */
for(i=1;i<N;i++) if(tab[i-1]>tab[i])
{
ok=0;
tampon=tab[i-1];
tab[i-1]=tab[i];
tab[i]=tampon;
}
}
while(!ok);
}
Ce tri va nécessiter un grand nombre de déplacements d'éléments, il est donc inutilisable dans les cas où ces
déplacements sont coûteux en temps. Il va nécessiter N-1 boucles principales dans le cas où le dernier élément
doit être placé en premier. Le nombre de boucles internes maximal est donc de l'ordre de (N-1)2. Il peut par
contre être intéressant quand le tableau initial est déjà pré-trié, les éléments n'étant pas disposés trop loin de leur
position finale (par exemple classement alphabétique où les éléments sont déjà triés par leur première lettre).
Plutôt que de déplacer un élément dans une position meilleure que la précédente mais néanmoins mauvaise, les
deux algorithmes qui suivent tentent de déplacer les éléments directement en bonne position.
le tri par insertion
Plutôt que de déplacer les éléments d'une position, on peut prendre un élément après l'autre dans l'ordre initial, et
le placer correctement dans les éléments précédents déjà triés, comme on le fait lorsque l'on classe ses cartes à
jouer après la donne (inse_tus) :
void tri_insertion_tus(type_tus tab, int N)

{

int pt,ppg; /* position testée, premier plus grand */

composante tampon;
for(pt=1;pt<N;pt++)
{
ppg=0;
while(tab[ppg]<=tab[pt]&&ppg<pt)ppg++;
if(ppg<pt)
{
tampon=tab[pt];
suppr_tus(tab,&N,pt);
insert_tus(tab,&N,32767,ppg,tampon); /* je suis sur de ne pas
dépasser la dimension puisque je viens de supprimer un
élément */
}
}
}
Le nombre maximal de boucles internes est descendu à N(N-1)/2, on a au maximum N-1 couples de
suppression/insertion mais qui eux effectuent en moyenne environ N/2 échanges d'éléments, ce qui amène un
maximum d'échanges de l'ordre de N2, ce qui n'est pas satisfaisant. On peut néanmoins améliorer l'implantation
de cet algorithme en optimisant la recherche de la position d'un élément dans la partie déjà triée, par dichotomie
par exemple (voir chapitre sur les recherches), ainsi qu'en améliorant le couple suppression/insertion (ne décaler
que les éléments entre la position finale et la position initiale, par une rotation à droite). On remplace la boucle
principale par :
for(pt=1;pt<N;pt++)
{
dpg=pt-1;
tampon=tab[pt];
while(tab[dpg]>tampon&&dpg>=0)
{tab[dpg+1]=tab[dpg];dpg--;}
tab[dpg+1]=tampon;
}
Le tri par insertion peut être intéressant pour des tableaux ayant déjà été triés, mais où l'on a rajouté quelques
nouveaux éléments en fin de tableau (dans ce cas il faut améliorer l'implantation pour découvrir rapidement le
premier élément mal placé, puis utiliser l'algorithme complet pour les éléments restants). Dans les autres cas, il
sera plutôt réservé aux types de données permettant une insertion rapide (listes chaînées par exemple).
le tri par sélection
Le but est désormais de déplacer chaque élément à sa position définitive. On recherche l'élément le plus petit. Il
faut donc le placer en premier. Or cette position est déjà occupée, on se propose donc d'échanger les deux
éléments. Il ne reste plus qu'à répéter l'opération N fois (sele_tus):
void tri_selection_tus(type_tus tab, int N)

{
int pd,pp,i; /* place définitive, plus petit */
composante tampon;
for(pd=0;pd<N-1;pd++)

{
pp=pd;
for(i=pp+1;i<N;i++) if(tab[i]<tab[pp])pp=i;
tampon=tab[pp];
tab[pp]=tab[pd];
tab[pd]=tampon;
}
}
Chaque échange met un élément en position définitive, l'autre par contre est mal placé. Mais aucun échange n'est
inutile. Un élément qui a été bien placé ne sera plus testé par la suite. Le nombre de boucles internes est environ
N(N-1)/2, ce qui est meilleur que le tri bulle, mais toujours de l'ordre de N2. Par contre le nombre de
déplacements d'éléments est au maximum de 2(N-1), la moitié étant des déplacements nécessaires, ce qui est
faible pour un fichier en désordre total, mais n'est pas optimal pour les fichiers dont la première partie est déjà
classée (et grande par rapport à la taille totale). Une amélioration possible serait d'essayer de placer le second
élément de l'échange dans une position pas trop mauvaise, à condition que cette recherche ne soit pas elle même
plus gourmande en temps.
le tri shell
C'est une amélioration du tri par insertion : au lieu d'effectuer une rotation de tous les éléments entre la position
initiale et finale (ou du moins meilleure) d'un élément, on peut faire des rotations par pas de P, ce qui rendra le
fichier presque trié (chaque élément sera à moins de P positions de sa position exacte). On répète ce tri pour P
diminuant jusqu'à 1. Une suite possible pour P est de finir par 1, les pas précédents étant de 4, 13, 40, 121, 364,
1093... (Pi=3*Pi-1 +1). D'autres suites sont évidement possibles, à condition de prendre des valeurs qui ne soient
pas multiples entre elles (pour ne pas toujours traiter les mêmes éléments et laisser de côté les autres, par exemple
les puissances successives de 2 ne traiteraient que les positions paires, sauf au dernier passage. Exemple
d'implantation (shel_tus) :
void tri_shell_tus(type_tus tab, int N)

{
int pt,dpg,P; /* position testée,dernier plus grand */
composante tampon;
for(P=1;P<=N/9;P=3*P+1); /* calcul de P initial (<=N/9) */
for(;P>0;P/=3) /* inutile de soustraire 1 car division entière */
{
for(pt=P;pt<N;pt++)
{
dpg=pt-P;
tampon=tab[pt];
while(tab[dpg]>tampon&&dpg>=P-1)
{tab[dpg+P]=tab[dpg];dpg-=P;}
tab[dpg+P]=tampon;
}
}
}
L'intérêt de ce tri, bien qu'il ait une boucle autour du tri par insertion, est qu'il crée rapidement un fichier presque
trié, le dernier tri par insertion sera donc beaucoup plus rapide. Il est en général plus rapide que le tri par insertion
pour les fichiers complètement mélangés, mais pour certains tableaux et pour certaines suites de P, il peut être

bien plus mauvais que les autres tris.
le tri rapide (Quick Sort)
Ce tri est récursif. On cherche à trier une partie du tableau, délimitée par les indices gauche et droite. On choisit
une valeur de ce sous-tableau (une valeur médiane serait idéale, mais sa recherche ralentit plus le tri que de
prendre aléatoirement une valeur, par exemple la dernière), que l'on appelle pivot. Puis on cherche la position
définitive de ce pivot, c'est à dire qu'on effectue des déplacements de valeurs de telle sorte que tous les éléments
avant le pivot soient plus petits que lui, et que toutes celles après lui soient supérieures, mais sans chercher à les
classer pour accélérer le processus. Puis on rappelle récursivement le tri de la partie avant le pivot, et de celle
après le pivot. On arrête la récursivité sur les parties à un seul élément, qui est donc nécessairement triée.
(Quick_tus)
void tri_rapide_tus(type_tus tab,int gauche,int droite)

{
int g,d;
composante tampon,val;
if(droite<=gauche)return; /* fin de récursivité
si tableau d'une seule case à trier */
/* choix du pivot : on prend par exemple la valeur de droite */
val=tab[droite];
g=gauche-1;
d=droite;
do
{
while(tab[++g]<val); /* g pointe le premier élément
(à gauche) plus grand (ou égal) que le pivot */
while(tab[--d]>val); /* d pointe le premier élément
(par la droite) plus petit (ou égal) que le pivot */
if(g<d) /* si g et d ne se sont pas rencontrés, on
échange les contenus de g et d et on recommence */
{tampon=tab[g];tab[g]=tab[d];tab[d]=tampon;}
}
while(g<d); /* on sort quand g a rencontré d, alors tous les
éléments à gauche de g sont <= au pivot, tous ceux
à droite de d sont >= */
/* on place le pivot en position g (d serait aussi possible), donc dans sa
bonne position (tous ceux à gauche sont <=, à droite sont >=) */
tampon=tab[g];tab[g]=tab[droite];tab[droite]=tampon;
/* il ne reste plus qu'à trier les deux parties, à droite
et à gauche du pivot */
tri_rapide_tus(tab,gauche,g-1);
tri_rapide_tus(tab,g+1,droite);
}
On appelle le tri d'un tableau complet par : tri_rapide_tus(tableau, 0, N-1). On peut remarquer
que cette implantation du tri n'est pas stable, mais peut l'être en gérant les égalités avec le pivot, mais en
ralentissant le tri. On effectue dans la boucle deux tests (g<d), on peut supprimer le second par une boucle infinie
et un break dans le if. Ce tri fait en moyenne 2Nlog(N) boucles, sur des fichiers bien mélangés, mais N2 sur un
fichier déjà trié (et dans ce cas la profondeur de récursivité est N, ce qui est prohibitif). Mais ces boucles sont

longues et gourmandes en mémoire du fait de la récursivité: chaque appel de fonction est assez long, il faut
mémoriser l'état actuel. On peut optimiser le tri en remplaçant la récursivité par des boucles (obligatoire si le
langage utilisé n'est pas récursif), ce qui évite d'empiler des adresses, mais la gestion des variables locales doit
être remplacée par gestion par pile (voir plus loin) pour mémoriser les sous-tris en attente, ce qui permettra
d'accélérer le tri mais nécessite une programmation complexe (rappel : la récursivité sera automatiquement
supprimée par le compilateur, cette transformation par le programmateur peut être plus efficace).
Plutôt que d'arrêter la récursivité sur des sous-tableaux de taille 1, on peut s'arrêter avant (entre 5 et 25 en
général) pour éviter une profondeur de récursivité trop importante. Le fichier est alors presque trié, on peut alors
effectuer un tri par insertion qui dans ce cas sera très rapide. Une autre amélioration possible est de mieux choisir
le pivot. la solution idéale est de trouver à chaque fois la valeur médiane du sous-tableau à trier, mais sa
recherche précise rend le tri plus lent que sans elle. Une solution quelquefois utilisée est de prendre par exemple
trois valeurs, pour en prendre la valeur médiane, par exemple tab[droite], tab[gauche] et tab[(droite+gauche)/2]
(dans le cas d'un fichier parfaitement mélangé, le choix de trois positions n'a pas d'importance, mais dans des
fichiers presque triés le choix ci-dessus est plus judicieux). La totalité de ces améliorations peut apporter un gain
de l'ordre de 20% par rapport à la version de base.
le tri par création
Lorsqu'il est nécessaire de disposer simultanément du tableau initial et du tableau trié, on peut recopier le tableau
initial puis effectuer un tri sur la copie, ou adapter un des algorithmes précédents. Par exemple, à partir du tri par
sélection, l'algorithme consiste à rechercher l'élément le plus petit, le copier en première position du tableau final,
rechercher le suivant, le placer en seconde position, etc... En cas d'éléments identiques, il y a lieu de marquer les
éléments déjà choisis, par exemple à l'aide d'un troisième tableau d'indicateurs (le tri est alors stable), ou suivant
l'exemple (crea_tus) ci-dessous (ceci n'est qu'un exemple, d'autres possibilités existent) :
int le_suivant(type_tus ti, int taille, int precedent)

{
int pos,i;
/* 1) recherche du premier égal au précédent */
pos=precedent+1;
while(pos<taille&&ti[pos]!=ti[precedent])pos++;
if(pos<taille)return(pos);
/* 2) sinon, recherche du suivant mais différent dans tout le tableau */
pos=0;
while(ti[pos]<=ti[precedent])pos++; /* le 1er > precedent */
for(i=pos+1;i<taille;i++) /*le plus petit dans la suite */
if(ti[i]>ti[precedent]&&ti[i]<ti[pos])pos=i;
return(pos);
}
void tri_creation_tus(type_tus ti, type_tus tf, int taille)

/* ti tableau initial, tf tableau final (trié) */
{
int i,imin=0;
for(i=1;i<taille;i++)if(ti[i]<ti[imin])imin=i;
tf[0]=ti[imin];
for(i=1;i<taille;i++)
{

imin=le_suivant(ti,taille,imin);
tf[i]=ti[imin];
}
}
On peut remarquer que ce tri minimise le nombre de copies des éléments, mais nécessite beaucoup de
comparaisons de clefs (en particulier un élément déjà sélectionné sera encore comparé par la suite). Ceci peut être
acceptable pour un fichier séquentiel à grands champs, sur bande par exemple, mais dont les clefs peuvent être
stockées complètement en mémoire. On verra d'autres propositions dans le cas des fichiers.
d'autres tris
Suivant les données à trier, il peut être plus efficace de construire un algorithme de tri spécifique. Par exemple, si
le tableau contient un grand nombre de valeurs similaires (exemple : gestion annuelle d'un stock où la plupart des
articles entrent et sortent plusieurs fois par jour), on peut utiliser l'algorithme simple (par création) consistant à
rechercher l'élément le plus petit, compter le nombre de ces éléments, les mettre dans le tableau destination, et
répéter l'opération jusqu'à la fin du fichier destination. C'est le tri par comptage. Dans le cas où le nombre de clefs
différentes est suffisamment faible, on peut utiliser un tableau de compteurs, ce qui permet d'effectuer le
comptage en un seul balayage du fichier.
Dans la cas où les clefs sont bornées (c'est à dire comprises entre un minimum et un maximum connus à l'avance)
et en nombre fini, on peut utiliser le tri basique : par exemple si toutes les clefs sont des entiers entre 000 et 999,
on peut séparer le tableau en 10 parties en fonction des centaines, puis récursivement traiter les dizaines puis les
unités (tri en base 10). Evidement, un tri en base 2 sera plus efficace sur ordinateur : on part à gauche ,on avance
jusqu'à trouver un nombre commençant par 1, puis par la droite jusqu'à trouver un nombre commençant par 0, les
échanger et continuer jusqu'à croisement des deux côtés. Puis on recommence (récursivement par exemple) sur le
bit suivant, jusqu'à tri complet. Pour trier des clefs alphabétiques, on peut effectuer un tri en base 26, sur les N
premiers caractères (N pouvant valoir 2 ou 3 par exemple), le fichier est alors presque trié. Il est alors plus
efficace d'effectuer un tri par insertion (passe de finition) plutôt que de répéter le tri basique jusqu'à tri complet.
Le tri par fusion utilise un algorithme de fusion de deux tableaux triés en un seul plus grand, appelé
récursivement sur les deux moitiés du tableau, jusqu'à une taille de tableau de 1 (ou plus, avec un tri spécifique
pour petits tableaux, par exemple par échange sur des sous-tableaux de 3 éléments)
recherches
On a souvent besoin de rechercher, dans un grand tableau, la position d'un élément donné. Un point particulier à
ne pas oublier pour tous les algorithmes est le traitement du cas où l'élément cherché n'est pas dans le tableau.
Une autre caractéristique importante d'un algorithme de recherche est son comportement désiré en cas d'éléments
identiques (doit-il donner le premier, le dernier, tous ?).
la recherche séquentielle
Il suffit de lire le tableau progressivement du début vers la fin. Si le tableau n'est pas trié, arriver en fin du tableau
signifie que l'élément n'existe pas, dans un tableau trié le premier élément trouvé supérieur à l'élément recherché
permet d'arrêter la recherche, de plus cette position correspond à celle où il faudrait insérer l'élément cherché
pour garder un tableau trié. Une recherche sur un tableau trié nécessitera en moyenne N/2 lectures, mais on se
rapprochera de N pour un fichier non trié avec beaucoup de recherches d'éléments inexistants.
int rech_sequentielle_tus(type_tus tab, int N, composante val)

/* rend -1 si val non trouvée, première occurence trouvée sinon */

{
int i;
for(i=0;i<N;i++)if(tab[i]==val)return(i);
return(-1);
}
la dichotomie
Dans le cas d'un tableau trié, on peut limiter le nombre de lectures à log(N)+1, en cherchant à limiter l'espace de
recherche. On compare la valeur cherchée à l'élément central du tableau, si ce n'est pas la bonne, un test permet
de trouver dans quelle moitié du tableau on trouvera la valeur. On continue récursivement jusqu'à un sous-tableau
de taille 1. Il vaut bien mieux implanter cet algorithme de manière itérative, car la fonction se rappelle jusqu'à
trouver la position désirée, puis seulement on effectue les dépilages, alors que l'on n'a plus besoin des états
intermédiaires qui ont été mémorisés par la récursivité puisque le problème est résolu.
int rech_dichotomie_tus(type-tus tab, int N, composante val)

{
int g,m,d; /* gauche, milieu, droite */
g=0;d=N;
while (g<=d)
{
m=(g+d)/2; /* division entière */
if(val<tab[m])d=m-1;
else if(val>tab[m])g=m+1;
else return(m)
}
return(-1);
}
L'utilisation de la variable m permet d'éviter plusieurs calculs de (g+d)/2. Dans certains cas il peut être intéressant
de prévoir également une mémorisation de tab[m], mais pas pour les tableaux puisqu'ils permettent d'accès direct.
L'ordre des tests est important, l'égalité ayant statistiquement moins de chances, elle doit être traitée en dernier
(donc faire le maximum de tests dans le cas le moins probable). Si on avait traité l'égalité en premier, tous les
autres cas auraient nécessité deux tests, l'égalité puis la sélection de la partie droite ou gauche. En cas de
multiples éléments correspondants à la valeur cherchée, on retourne la position de l'un d'eux, mais pas
nécessairement le premier ou le dernier. Pour retourner le premier par exemple, il suffit de rajouter une boucle
testant l'égalité vers la gauche, à n'effectuer qu'une seule fois bien évidement, lorsque une valeur adéquate a été
localisée. On peut améliorer l'algorithme en comparant val à tab[g] et tab[d], pour estimer la position recherchée
plutôt que de la supposer au milieu, comme on effectue une recherche dans un dictionnaire :
m=g+(int)((val-tab[g])*(d-g)/(tab[d]-tab[g])). Attention, ce calcul se fait sur des
composantes (par exemple des flottants), ce qui est toujours plus long que de simples calculs sur des entiers.
calculs mathématiques
Les tableaux unidimensionnels permettent de résoudre simplement divers problèmes mathématiques. Nous allons
en traiter certains.
calcul vectoriel
L'utilisation des tableaux statiques est bien indiquée pour le calcul vectoriel. En effet, toutes les variables seront

de même dimension. Il est aisé de prévoir une bibliothèque de fonctions vectorielles comportant toutes les
opérations de base (multiplication par un réel, produit scalaire, produit vectoriel, produit mixte, norme...). Un
grand nombre de problèmes géométriques se résoudront bien plus facilement par calcul vectoriel que de manière
paramétrique.
polynômes
Une manière (mais il y en a d'autres) de représenter un polynôme est le tableau de ses coefficients. Par exemple
f(x)=4x3+x+2 sera représenté par le tableau 2,1,0,4 (en mettant le coefficient de xi en position i). L'évaluation
d'un polynôme (c'est à dire le calcul de sa valeur pour un x donné) ne doit pas utiliser de fonction puissances mais
uniquement des multiplications successives, puisque toutes les puissances intermédiaires sont nécessaires. La
somme de polynômes est triviale (somme des coefficients), le produit à peine plus compliqué (à moins que l'on
ait besoin d'une optimisation poussée, dans ce cas on peut réduire d'1/4 le nombre de multiplications mais avec
une complexité accrue). La résolution de l'équation f(x)=0 (recherche de racines) peut se faire par dichotomie par
exemple (il faut alors donner le premier intervalle de recherche), en cas de racines multiples on en trouve une au
hasard. Une recherche de racines plus efficace nécessite des algorithmes complexes, rarement universels (c'est à
dire que dans certains cas ils ont un résultat déplorable, voire faux ou plantage de l'ordinateur en cas de
divergence) qui ne seront pas traités ici, mais une littérature abondante existe sur ce sujet.
L'interpolation polynomiale correspond elle à la recherche d'une courbe polynomiale passant par N+1 points
donnés : P(xi)=yi pour i entre 0 et N. La solution la plus simple consiste à choisir le polynôme de Lagrange
(d'ordre N):
N N
P(x)= ( yj (x-xi)/(xj-xi) )
i=0
j=0
i!=j
qui est le plus rapide à déterminer mais donne des résultats décevants pour N assez grand (100 par exemple),
puisque les seules conditions imposées sont des points de passage, on obtient (souvent près des points extrêmes)
une courbe assez "folklorique" entre certains points. Une méthode souvent plus satisfaisante est l'utilisation des
"splines", qui cherche parmi les multiples polynômes d'ordre N passant par N+1 points celui qui minimise une
quadratique (en fait, correspond à la minimisation de l'énergie de déformation d'une poutre passant par ces points,
d'où le nom de spline, "latte" en anglais) (voir mon support de cours sur l'infographie). Ou alors on peut utiliser
une approximation (polynôme d'ordre M<N) passant au voisinage des points (par exemple moindres carrés).
tableaux multidimensionnels
Un tableau à N dimensions est en fait un tableau unidimensionnel de tableaux de N-1 dimensions. Tout ce qui a
été présenté auparavant reste donc valable. La décision d'utiliser des tableaux multidimensionnels doit être bien
réfléchie : ces tableaux nécessitant beaucoup de mémoire, il faut évaluer le ratio de composantes utiles par
rapport aux places mémoire utilisées. Par exemple un tableau 10x10x10 utilisant dans chacune des 3 directions
une seule fois les 10 mémoires prévues, les autres fois on s'arrête en moyenne à 7 (si ce n'est pas moins), réserve
1000 mémoires, dont seulement 352 utiles (7x7x7+3+3+3).
Outre les tableaux de chaînes de caractères, les tableaux multidimensionnels les plus utilisés sont les matrices Les
algorithmes de base du calcul matriciel (base_mat) sont la mise à 0, la recopie, l'addition et le produit de
matrices, qui sont simples à mettre en place (le produit entraîne néanmoins N3 multiplications, des algorithmes
plus performants existent mais ne commencent à être rentables que pour N très grand, entre 10000 et un million

!).
Par contre, le problème de l'inversion d'une matrice est plus complexe. Elle est utilisée principalement pour la
résolution de N équations à N inconnues, représentées par une matrice NxN. La méthode de Gauss est
certainement la plus simple à mettre en oeuvre, bien que pouvant poser problème dans certains cas particuliers.
On utilise en fait la méthode de résolution d'un système d'équations A.X=B par substitution. Nous allons le
préciser sur un exemple :
1 1 -2 x1 2
1 3 -4 * x2 = 6
-1 -2 6 x3 -1
A X B
On utilise le fait que de remplacer une ligne du système d'équations par une combinaison linéaire entre elle et
d'autres lignes ne modifie pas le résultat, pour éliminer le premier élément de la seconde ligne. En soustrayant la
première ligne à la seconde on obtient :
1 1 -2 x1 2
0 2 -2 * x2 = 4
-1 -2 6 x3 -1
Puis on élimine les deux premiers éléments de la troisième ligne (on ajoute la première puis on ajoute 1/2 fois la
seconde) :
1 1 -2 x1 2
0 2 -2 * x2 = 4
00 1 x3 1
On peut désormais résoudre le système (en commençant par le bas) : x3=1, donc (seconde ligne) 2x2-2.1=4, donc
x2=3, donc (première ligne) x1+3-2.1=2 donc x1=1.
void gauss_triangulation_simpliste(type_mat A,type_mat B, int N)

/* A de taille (N,N), B (N,1). On aurait pu gagner de la place en prenant B
tableau unidimensionnel, ou même le rajouter en colonne N de A */
{
int ce,l,c;
composante coef;
for(ce=0;ce<N-1;ce++) /* ce=col à effacer (dans les lignes SUIVANTES) */
for(l=ce+1;l<N;l++) /* pour chaque ligne au dessous */
{
coef=A[l][ce]/A[ce][ce];
A[l][ce]=0; /* normalement pas besoin de le calculer */
for(c=ce+1;c<N;c++) A[l][c]-=coef*A[ce][c];
B[l][0]-=coef*B[ce][0];
}
}
Si ces substitutions font apparaître une ligne de 0, soit le système admet une infinité de solutions (0=0, une ligne

est une combinaison linéaire des autres), soit aucune (0=N). Mais cette méthode n'est pas directement applicable
pour des coefficients réels (ou du moins flottants). En effet, si les substitutions précédentes ont amené un
coefficient nul, on obtient une division par zéro. S'il est proche de 0, l'utilisation de ce coefficient pour en annuler
d'autres nécessitera un multiplicateur très grand, ce qui entraînera une multiplication importante de l'erreur
inhérente à l'utilisation de réels et donc un résultat faux (en fait on se trouvera en présence de coefficients d'ordre
de grandeur très différent, et donc les petits deviendront négligeables devant l'erreur sur les très grands). La
solution est de ne pas traiter les lignes dans l'ordre mais pour une colonne donnée, choisir pour celle qui aura son
premier terme non nul celle dont ce terme est le plus grand (on l'appelle le pivot). Il suffit alors d'échanger la
ligne que l'on veut traiter avec la ligne contenant le pivot (échanger des lignes d'un système d'équations ne
modifie pas la solution) (gauss):
void gauss_triangulation(type_mat A,type_mat B, int N)

{
int ce,l,c,lpivot;
composante coef;
for(ce=0;ce<N-1;ce++) /* ce=colonne à effacer */
{
/*Recherche du pivot le + grand possible (dans les lignes qui restent)*/
lpivot=ce;
for(l=ce+1;l<N;l++)if(fabs(A[l][ce])>fabs(A[lpivot][ce]))lpivot=l;
/*Echange de la ligne du pivot et de la ligne ce (ne pas oublier B)*/
for(c=ce;c<N;c++) /*tous les termes devant ce sont nuls*/
{coef=A[ce][c];A[ce][c]=A[lpivot][c];A[lpivot][c]=coef;}
coef=B[ce][0];B[ce][0]=B[lpivot][0];B[lpivot][0]=coef;
/*Suite de l'algorithme, comme le cas simpliste */
{
coef=A[l][ce]/A[ce][ce];
A[l][ce]=0;
for(c=ce+1;c<N;c++)
A[l][c]-=coef*A[ce][c];
B[l][0]-=coef*B[ce][0];
}
}
}
Une fois la matrice A triangulée, il ne reste plus qu'à déterminer la matrice colonne solution X:
void gauss_resolution(type_mat A,type_mat B,type_mat X,int N)

{
int l,c;
composante tampon;
for(l=N-1;l>=0;l--)
{
tampon=B[l][0];
for(c=l+1;c<N;c++)tampon-=A[l][c]*X[c][0];
X[l][0]=tampon/A[l][l];
}
}

Remarque : on pourrait retourner le résultat dans B (si l'utilisateur désire le garder, il lui suffirait de le copier
avant). Ceci économise le tableau X et le tampon.
D'autres algorithmes existent, mais ils ne sont plus efficaces que Gauss que pour de très grosses matrices. Mais
souvent les grosses matrices possèdent des propriétés particulières nécessitant d'utiliser d'autres structures de
données que les tableaux à 2 dimensions (en cas de matrices triangulaires, symétriques, bandes, en "ligne de
ciel", creuses..., voir paragraphe 11.3.2), pour lesquelles Gauss n'est pas la meilleure solution, car la triangulation
supprime ces propriétés.
conclusions
Les tableaux unidimensionnels statiques sont d'une utilisation simple. Ils permettent un accès direct (donc quasi
immédiat) à une donnée dont on connaît la position. Les seules manipulations de base rapides sont l'insertion et la
suppression en fin du tableau. La dimension du tableau doit être connue (ou du moins maximisée) dès la phase
d'écriture du programme, ces tableaux sont donc intéressants dans le cas de dimensions petites ou presque
constantes.

Données et Algorithmique - LES TABLEAUX DYNAMIQUES
LES TABLEAUX DYNAMIQUES

● tableaux unidimensionnels en C
● la méthode du super-tableau
● les tableaux multidimensionnels
❍ matrices pleines (matrices rectangulaires dynamiques : mrd)
❍ tableaux de tableaux dynamiques
● conclusions
tableaux unidimensionnels en C
Les tableaux statiques nécessitent de maximiser lors de l'écriture du programme la dimension des
tableaux. En cas de tableaux nombreux, il serait plus utile de ne réserver, pour chaque exécution, que la
taille nécessaire à l'application en cours. En C, cette transformation est triviale grâce à la fonction malloc
et à l'équivalence d'écriture entre les tableaux unidimensionnel et les pointeurs. Il suffira donc, pour
utiliser les fonctions décrites pour les tableaux unidimensionnels statiques, de ne remplacer que la
déclaration des tableaux :

typedef composante *type_tus; /* ou typedef composante type_tus[] */
reste identique, mais la déclaration composante tab[dim] sera remplacée par :
tab=(type_tus)malloc(taille*sizeof(composante));
à partir du moment où l'on a besoin du tableau, puis free(tab); quand il redevient inutile. Le
problème des tableaux dynamiques en C est que l'on doit connaître la dimension d'un tableau avant sa
première utilisation, ce qui empêchera par exemple une introduction de données du type "entrez vos
données, tapez FIN pour terminer" mais nécessitera de demander en premier le nombre de données.
L'autre problème provient du fait de la gestion de la mémoire inaccessible au programmeur : des
créations et suppressions successives de tableaux vont créer une mémoire morcelée, et donc
l'impossibilité de réserver un gros tableau, alors que la mémoire était disponible mais non continue. On
est alors obligé de passer par la méthode du super-tableau pour pouvoir effectuer des retassages de
mémoire.

la méthode du super-tableau
Dans les langages ne disposant pas de fonctions spécifiques à l'allocation dynamique de mémoire, on
crée un grand tableau, appelé super-tableau, dimensionné au maximum de mémoire disponible. On crée
ensuite les fonctions utilitaires nécessaires : réservation de mémoire (bloc) d'une taille donnée en
argument (la fonction rend l'indice dans le super-tableau du début du sous-tableau alloué), libération d'un
bloc préalablement alloué,... L'utilisation d'un bloc alloué est alors très simple : on remplace l'écriture
bloc[i] par super_tableau[indice_debut_bloc+i]. Les parties du super-tableau utilisées
n'ont pas absolument besoin d'une gestion poussée, mais on préfère en général prévoir un tableau annexe
contenant les adresses et tailles des blocs actuellement réservés. Par contre il faut gérer les parties libres.
Une solution est d'utiliser une pile (voir plus loin), mais la libération d'un bloc autre que le dernier soit
nécessite un décalage des blocs suivants (attention, les indices de début de blocs sont modifiés), soit un
marquage spécifique de cette zone (la place ne sera effectivement libérée que lorsque tous les blocs
suivants seront libérés). Cette méthode est utilisable dans beaucoup de cas, il suffit de réserver en
premier les blocs qui seront utilisés tout au long du programme, les blocs à durée de vie plus faible par la
suite. L'autre solution consiste à gérer les blocs libres sous forme d'une liste chaînée (voir plus loin),
chaque bloc libéré contenant l'indication de sa taille et l'adresse du bloc libre suivant (la place utilisée par
ces informations est "masquée" puisque n'utilisant que des zones libres). L'allocation d'un bloc consiste
alors en la recherche du premier bloc libre de taille suffisante. Un retassage (et donc modification des
indices de débuts de blocs) n'est nécessaire qu'en cas de mémoire trop morcelée.
Cette méthode du super-tableau permet de manière très simple d'accéder à toutes les possibilités des
pointeurs, dans tout langage. C'est la raison pour laquelle des programmes très efficaces continuent à être
développés dans ces langages (pratiquement tous les gros programmes scientifiques (C.A.O., éléments
finis,...) de plusieurs centaines de milliers de lignes sont écrits en FORTRAN, et utilisent cette méthode).
De plus la gestion par le programmeur de l'allocation de mémoire peut permettre d'être plus efficace que
la gestion par le compilateur, puisque pouvant être spécifique au problème traité.
les tableaux multidimensionnels

Il n'y a pas en C d'équivalence d'écriture permettant une utilisation directe de l'allocation dynamique pour
les tableaux multidimensionnels. On utilise donc la même méthode pour l'allocation dynamique en C (la
mémoire est en fait un tableau unidimensionnel d'octets) qu'avec un super-tableau. Nous n'allons traiter
que les tableaux à deux dimensions, l'extension à N dimensions ne posant aucun problème.
matrices pleines (matrices rectangulaires dynamiques : mrd)

Pour allouer dynamiquement une matrice de taille (nbl,nbc), on réserve un tableau unidimensionnel de
taille nbl*nbc :
typedef composante * mat_dyn;

mat_dyn alloc_mrd(int nbl;int nbc)
{return((mat_dyn)malloc(nbl*nbc*sizeof(composante)));}
On accède à l'élément en ligne l et colonne c par m[l*nbc+c] (pour l et c commençant à 0, comme en C).

On peut prévoir une fonction (ou même une macro, plus rapide) pour effectuer ce calcul :
#define adr_mrd(l,c,nbc) ((l)*(nbc)+(c))

Les algorithmes pour les matrices statiques doivent être réécrits, en remplaçant chaque mat[l][c] par
mat[adr_mrd(l,c,nbc)]. Souvent, on choisira un nom plus court pour adr_mrd. Dans les cas simples
uniquement, on peut choisir nbc comme variable globale pour éviter sa transmission en argument (par
exemple si l'on utilise des matrices carrées toutes de même taille), mais ce n'est pas conseillé (dans le cas
d'une macro, ce ne sont pas de vrais passages d'arguments et donc ne prend pas de temps
supplémentaire).
Exercice (gauss_mrd) : écrire une version de la méthode de Gauss pour des matrices dynamiques. La
solution donnée en annexe 2 (du document papier) est un exemple de matrices dynamiques.
tableaux de tableaux dynamiques

Dans le cas de matrices non pleines, la gestion sera plus complexe mais le résultat très efficace. On gère
en fait un ensemble de lignes de longueur différente (donc des tableaux dynamiques). Dans quelques cas,
la longueur et la position de chaque ligne se trouve par calcul : matrices triangulées, matrices bandes
(réorganisées pour que tous les éléments non nuls soient au maximum à la distance B (largeur de bande)
de la diagonale),... Un utilise alors la même méthode que pour les matrices pleines, en changeant
simplement le calcul pour accéder à une composante (adr_mrd). Dans tous les autres cas, chaque ligne
est allouée dynamiquement, l'adresse et la longueur de chaque ligne étant stockée dans un tableau
statique ou dynamique, voire liste chaînée... La longueur peut être omise si la ligne est terminée par un
signe particulier (chaînes de caractères en particulier). Les manipulations deviennent alors plus efficaces
: les manipulations de composantes (dans les lignes) restent des manipulations de type tableaux, donc
efficaces tant que les lignes ne sont pas de taille exagérée, alors que les manipulations de lignes (plus
volumineuses) se font par manipulation d'adresses (par exemple pour échanger deux lignes, il suffit
d'échanger les deux adresses de lignes, les lignes elles-mêmes n'étant physiquement pas déplacées). Ce
type de données est certainement le plus efficace pour du traitement de textes. Mais il permet aussi de
traiter les matrices en "ligne de ciel:" dans le cas (fréquent en mécanique) de matrices symétriques
contenant beaucoup de 0, on peut avoir du mal à réorganiser la matrice efficacement pour qu'elle soit
sous forme de bande, par contre il est plus facile de la réorganiser pour qu'un maximum de lignes soient
regroupées près de la diagonale, quelques lignes restant à grande largeur. On stocke alors uniquement,
pour chaque ligne, les éléments de la diagonale au dernier non nul. Ce type de stockage est également
appelé quelquefois "à largeur de bande variable".
Ces tableaux de tableaux dynamiques permettent toujours un accès presque direct à un élément l,c :
tab[adresse_ligne[l]][c]. Mais ils gardent les problèmes des tableaux dynamiques, en particulier de ne pas
être totalement dynamiques puisqu'une fois une ligne créée, on ne peut pas directement l'agrandir (en fait
il suffit de réserver une nouvelle ligne plus grande, y recopier la précédente, changer l'adresse de la ligne
dans le tableau d'adresses de lignes puis supprimer l'ancienne ligne). Souvent dans ce cas on préfère
directement créer un ligne un peu plus longue que nécessaire, pour ne pas répéter l'opération trop
souvent.
Exercice (inse_ttd) : écrire un programme pour trier des lignes de texte, utilisant les tableaux de
tableaux dynamiques. On choisira un tri par insertion, puisque les échanges de lignes ne sont que des

échanges d'adresses, le texte en lui-même ne sera jamais déplacé.
conclusions
Les tableaux dynamiques ne sont pas totalement dynamiques, c'est à dire que leur taille, bien que définie
en cours d'exécution du programme, ne peut pas facilement être modifiée (c'est néanmoins presque
toujours possible mais relativement coûteux en temps et mémoire). Mais ils gardent la principale qualité
des tableaux statiques : l'accès immédiat à une composante dont on connaît la position. Ils en gardent
également la faible efficacité en cas d'insertions et suppressions. Les tableaux dynamiques sont
néanmoins la solution minimisant la place occupée en mémoire pour de gros ensembles de données :
Seule la place nécessaire est réservée (excepté une mémoire pour l'adresse du début du tableau), aucune
mémoire n'est utilisée pour indiquer où se trouve la composante suivante, puisqu'elle est placée
directement après la précédente (contrairement aux listes par exemple).

Données et Algorithmique - LES LISTES
LES LISTES
● fonctions de base et manipulations (base_lst)
● les tris
❍ le tri bulle
❍ le tri par insertion
❍ le tri par sélection
❍ le tri par création
❍ les autres tris
● problèmes mathématiques
● conclusions
fonctions de base et manipulations (base_lst)

Les listes sont un regroupement ordonné de données effectué de manière à ce que chaque composante sache où se
trouve la suivante. En C, une composante sera une structure contenant la valeur mémorisée, mais également un
pointeur sur la composante suivante. Sur fichier ou dans les langages ne possédant pas de pointeurs, on utilisera
la méthode du super-tableau, le pointeur étant remplacé par l'indice, dans le super-tableau, de la composante
suivante. Une liste est accessible par l'adresse de sa première composante. On supposera dans la suite que les
valeurs à mémoriser sont de type flottant, mais évidement tout autre type de données est possible (même
tableaux, structures, listes...). La déclaration en C sera donc :
typedef float type_val;

typedef struct scomp {type_val val; struct scomp *suiv;} type_comp;
typedef type_comp *adr_comp;
Nous représenterons les composantes des listes (de type type_comp) ainsi :
Supposons disposer de la liste ci-dessous en mémoire (nous verrons plus loin comment la créer en mémoire). La
variable prem, de type adr_comp (donc pointeur sur une composante) contient l'adresse de la première
composante. Le champ suiv de la dernière composante contient la valeur NULL, donc ne pointe sur rien.

Pour simplifier les algorithmes, on peut mettre d'office une composante particulière en début et fin de liste
(appelée sentinelle). Ceci évite de devoir traiter de manière particulière le premier et dernier élément de la liste,
puisque chaque composante utile possède toujours un précédent et un suivant. Cette méthode prend un peu plus
de mémoire (négligeable en % pour de longues listes) et évite des tests systématiques dans le boucles, alors qu'ils
ne servent que pour les extrémités (d'où gain de temps appréciable, toujours en cas de longues listes). Une autre
méthode pour repérer le dernier élément est de le faire pointer sur lui-même. Nous utiliserons dans la suite des
listes sans sentinelle, le dernier élément pointant sur NULL.
L'appel de : affiche_lst(prem) affichera à l'écran le contenu de la liste :
void affiche_lst(adr_comp l)
{
while(l!=NULL)
{
printf("%6.1f ",l->val);
l=l->suiv;
}
printf("\n");
}
l pointe sur la première composante. On affiche la valeur pointée par l puis on fait pointer l sur son suivant. On
répète le processus jusqu'en fin de liste (lorsque l'on pointe sur NULL). La variable l doit être locale (donc passée
par valeur) pour ne pas modifier le contenu de prem, et donc perdre l'adresse du début de la liste, ce qui
empêcherait tout accès ultérieur à la liste.
Comme pour les chaînes de caractères, plutôt que de gérer un variable entière indiquant toujours la longueur
actuelle de la liste, c'est la spécificité du dernier élément (ici, le champ suiv contient NULL) qui permet de
préciser que l'on est en fin de liste. Pour connaître la longueur d'une liste, on utilisera :
int longueur_lst(adr_comp l)
{
int n=0;
while(l!=NULL)
{
l=l->suiv;
n++;
}
return(n);
}
Les listes ont l'avantage d'être réellement dynamiques, c'est à dire que l'on peut à loisir les rallonger ou les
raccourcir, avec pour seule limite la mémoire disponible (ou la taille du super-tableau). Par exemple pour insérer
une nouvelle composante en début de liste, on utilisera :

void insert_premier(adr_comp *prem,type_val val)

{
adr_comp nouv;
nouv=(adr_comp)malloc(sizeof(type_comp));
nouv->val=val;
nouv->suiv=*prem;
*prem=nouv;
}
En insérant la valeur 5 à notre exemple précédent, on obtient la liste :
La variable prem a dû être passée par adresse, pour que l'on récupère bien l'adresse de la nouvelle première
composante (appel : insert_premier(&prem,5)). En fait le schéma ci-dessus n'est qu'une représentation
abstraite de la liste (chaque composante pointe sur la suivante), alors que les composantes sont physiquement
placées différemment en mémoire. Dans le meilleur des cas, la nouvelle composante créée a été placée juste
derrière celles déjà existantes (premier emplacement libre). Un schéma plus proche de la réalité serait donc :
Ces deux schémas sont équivalents (les liens partent des mêmes cases, et pointent sur les mêmes cases), seule la
disposition des cases diffère. En fait ceci nous montre bien que la disposition réelle en mémoire ne nous intéresse
pas (jamais la valeur effective de l'adresse contenue dans un pointeur ne nous intéressera). Dans nos schémas,
nous choisirons donc une disposition des composantes correspondant plus au problème traité qu'à la disposition
réelle en mémoire (par exemple dans le schéma suivant, on utilise une représentation bidimensionnelle, alors que
la mémoire n'est qu'unidimensionnelle).
Le second avantage des listes est que l'insertion d'une composante au milieu d'une liste ne nécessite que la
modification des liens avec l'élément précédent et le suivant, le temps nécessaire sera donc indépendant de la
longueur de la liste. Supposons disposer d'une variable X de type adr_comp, pointant sur la composante de
valeur 10. L'appel de insert_après(X,15) donnera le résultat suivant :

void insert_après(adr_comp prec,type_val val)

{
adr_comp nouv;
nouv=(adr_comp)malloc(sizeof(type_comp));
nouv->val=val;
nouv->suiv=prec->suiv;
prec->suiv=nouv;
}
Cette fonction permet l'insertion en tout endroit de la liste, sauf en première position (qui n'a pas de précédent
dans notre cas puisque sans sentinelle), il faut traiter spécifiquement le premier de la liste (voir plus haut).
L'insertion nécessite la connaissance de l'adresse du précédent et du suivant. Les composantes ne comportant que
des liens vers l'élément suivant, il faut nécessairement donner à la fonction insert_après l'adresse du précédent,
alors que d'habitude on préfère donner l'élément devant lequel on veut faire l'insertion (tableaux par exemple).
Ceci nous montre le principal problème des listes : l'accès est séquentiel. On devra, pour chercher la composante
précédente, parcourir toute la liste depuis son début (on donne l'adresse du début de la liste et de l'élément dont
on cherche le précédent):
adr_comp rech_prec(adr_comp prem, adr_comp suiv)

/* rend l'adresse, NULL si non trouvé */
{
while(prem->suiv!=suiv && prem!=NULL)
prem=prem->suiv;
return(prem);
}
Une autre solution, si l'on a fréquemment besoin de parcourir la liste vers l'avant et vers l'arrière, est de stocker
dans chaque composante l'adresse du suivant et celle du précédent. Ceci nécessite plus de place en mémoire et
ralentit un peu les manipulations de base (il y a plus de liens à mettre à jour). Mais même dans ce cas, l'accès
reste séquentiel. Ceci empêche d'utiliser un certain nombre d'algorithmes utilisant l'accès direct (la dichotomie
par exemple). Pour trouver l'adresse du Nième élément d'une liste il faudra utiliser (on suppose numéroter 0 le
premier) :
adr_comp rech_ind(adr_comp l, int i)

/* rend l'adresse du (i+1)ième, NULL si liste trop courte */
{
int j;
for(j=0;j<i && l!=NULL;j++) l=l->suiv;
return(l);
}
La recherche d'un élément, même si la liste est triée, se fera donc toujours séquentiellement :
adr_comp rech_val(adr_comp l, type_val v)

/* rend l'adresse, NULL si non trouvé */
{
while(l!=NULL && l->val!=v) l=l->suiv;
return(l);
}
Pour créer une liste, la solution la plus simple consiste à boucler sur un appel de la fonction insert_premier,

mais les éléments seront stockés dans l'ordre inverse de leur introduction (le dernier saisi sera placé en premier).
Pour une création de liste dans l'ordre, on fera :
adr_comp saisie_lst(void)
{
adr_comp prem=NULL,prec,actu; /* premier, précédent, actuel*/
type_val v;
int err;
do
{
printf("entrez votre prochaine valeur, un caractère pour finir :");
err=scanf("%f",&v);
if(err<=0)break; /*scanf rend le nombre de variables lues sans erreur*/
actu=(adr_comp)malloc(sizeof(type_comp));
actu->val=v;
if(prem==NULL)prem=actu; else prec->suiv=actu;
prec=actu;
}
while(1);
actu->suiv=NULL;
return(prem);
}
Cette fonction crée la liste en mémoire, effectue la saisie et retourne l'adresse du début de la liste.
Il nous reste à traiter les suppressions dans une liste. Il faut ici encore préciser l'élément précédent celui à
supprimer, et traiter de manière particulière le début de la liste :
void suppr_suivant(adr_comp prec)

{
adr_comp a_virer;
if(prec==NULL || prec->suiv==NULL)
{puts("rien à supprimer");return;}
a_virer=prec->suiv;
prec->suiv=a_virer->suiv;
free(a_virer);
}
void suppr_premier(adr_comp *prem)

{
adr_comp a_virer;
if(*prem==NULL) {puts("rien à supprimer");return;}
a_virer=*prem;
*prem=(*prem)->suiv;
free(a_virer);
}
La suppression complète d'une liste permet de récupérer la place en mémoire. Cette opération n'est pas nécessaire
en fin de programme, le fait de quitter un programme remet la mémoire dans son état initial et libère donc
automatiquement toutes les mémoires allouées dynamiquement :

void suppr_tout(adr_comp prem)

/* attention : ne met pas NULL dans prem qui pointe donc toujours sur la
liste, qui n'est plus allouée mais dont le contenu n'a peut-être pas changé
*/
{
adr_comp deuxieme;
while(prem!=NULL)
{
deuxieme=prem->suiv;
free(prem);
prem=deuxieme;
}
}
Il n'était à priori pas obligatoire d'utiliser la variable deuxième car la libération par free n'efface pas les
mémoires, le suivant est donc encore disponible après free et avant tout nouveau malloc. Néanmoins cette
écriture est plus sure, ne gérant pas la mémoire nous même (sauf si méthode du super-tableau), en particulier en
cas de multitâche, d'interruption matérielle...
On trouvera un exemple utilisant ces fonctions dans test_lst.c (disquette d'accompagnement)
les tris
Seuls les tris n'utilisant pas l'accès direct pourront être efficaces pour les listes. Au lieu de déplacer les valeurs
dans la liste, on changera uniquement les liens. Dans la plupart des configurations, le tri par insertion sera le plus
efficace.
le tri bulle
Le tri bulle est donc assez efficace (n'ayant pas de lien sur la composante précédente, on mémorisera toujours
l'adresse du précédent dans une variable auxiliaire). Mais il reste peu efficace lorsque des éléments sont loin de
leur position finale, puisque chaque passage ne peut déplacer un élément que d'une position (de l'ordre de N2/2
échanges, autant de boucles internes), on le réservera donc aux listes presque triées. Les autres tris, comme le tri
par insertion déplaceront chaque élément directement en bonne position, mais le temps nécessaire à la recherche
peut être assez long, alors qu'ici la position destination est directement connue (mais pas nécessairement juste)
(bull_lst) :
void tri_bulle_lst(adr_comp *prem)

/* le premier ne sera peut-être plus le même donc passage par adresse */
{
int ok;
adr_comp prec,actu,suiv;
do
{
ok=1; /* vrai */
prec=NULL;
actu=*prem;
suiv=actu->suiv;

while(suiv!=NULL)
{
if(actu->val > suiv->val)
{
ok=0;
if(prec!=NULL) prec->suiv=suiv; else *prem=suiv;
actu->suiv=suiv->suiv;
suiv->suiv=actu;
}
prec=actu;
actu=suiv;
suiv=actu->suiv;
}
}
while(!ok);
}
En utilisant prec->suiv et prec->suiv->suiv, on pouvait éviter d'utiliser les variables actu et suiv.
Le temps d'accès aux variables aurait été un peu plus long mais on supprimait deux des trois affectations situées
en fin de boucle.
le tri par insertion

Le tri par insertion sera bien plus intéressant, dans la majorité des cas : il nécessite une boucle principale
(séquentielle), dans laquelle on appelle une seule recherche pour placer l'élément, les déplacements se faisant très
rapidement et sans s'occuper du reste de la liste (inse_lst) :
void tri_insertion_lst(adr_comp *prem)

{
/*position testée, précédent,dernier plus petit*/
adr_comp pt,prec,dpp;
for(prec=*prem,pt=(*prem)->suiv;pt!=NULL;prec=pt,pt=pt->suiv)
if(prec->val>pt->val) /*inutile de chercher si en bonne
position */
{
prec->suiv=pt->suiv;
if((*prem)->val > pt->val) /*cas particulier du premier*/
{
pt->suiv=*prem;
*prem=pt;
}
else
{
dpp=*prem;
while(dpp->suiv->val <= pt->val)dpp=dpp->suiv;
/* on est sur d'en trouver un, vu les tests effectués plus haut */
pt->suiv=dpp->suiv;
dpp->suiv=pt;
}

}
}
Ici également, on aurait pu tenter d'éviter l'utilisation des deux variables prec et pt puisque pt est le suivant de
prec, mais les échanges auraient alors nécessité une variable tampon. Cette version du tri est stable (le nouveau
est inséré derrière les valeurs égales), mais ceci ralentit un peu la recherche de la position définitive d'une valeur
en cas de nombreuses valeurs égales (si la stabilité n'est pas nécessaire, il suffit d'arrêter la recherche au premier
élément supérieur ou égal). Dans tous les cas, on fera au maximum N échanges (aucun en bonne position), en
moyenne N/2 pour les fichiers mélangés. Dans la cas d'un fichier mélangé, le nombre de boucles internes est de
N(N-1)/2 en moyenne. Dans le cas d'un fichier presque trié, dans le cas de quelques éléments (en nombre P) pas
du tout à leur place, ce tri est très efficace : P échanges, (P+2)*N/2 boucles internes, donc on devient linéaire en
N. Par contre dans le cas de nombreux éléments pas tout à fait à leur place (à la distance D), il l'est moins que le
tri bulle, la recherche de la position exacte se faisant à partir du début de la liste (proche de N2 : (N-D)(N-1)
boucles internes). Dans ce cas, si l'on peut également disposer d'un chaînage arrière, on fera la recherche à partir
de la position actuelle, ce qui rendra le tri très efficace également dans ce cas : D(N-1) boucles internes donc
linéaire en N. Sinon, on peut mémoriser la position du Dième précédent, le comparer à la valeur à insérer et donc
dans la majorité des cas (si D bien choisi) rechercher derrière lui, dans les quelques cas où il faut l'insérer devant
lui, on effectue une recherche depuis le début.
le tri par sélection

Le tri par sélection prendra environ N2/2 boucles internes, et ceci quel que soit l'ordre initial du fichier. Le
nombre maximal d'échanges sera de N, N/2 en moyenne pour un fichier mélangé, P pour uniquement P éléments
mal placés (sele_lst) :
void tri_selection_lst(adr_comp *prem)

{
type_comp faux_debut;
adr_comp pdpd,pdpp,i;
faux_debut.suiv=*prem;
for(pdpd=&faux_debut;pdpd->suiv!=NULL;pdpd=pdpd->suiv)
{
/*recherche du plus petit (du moins son précédent)*/
pdpp=pdpd; /*le plus petit est pour l'instant l'actuel, on va tester les
suivants*/
for(i=pdpd->suiv;i->suiv!=NULL;i=i->suiv)
if(i->suiv->val < pdpp->suiv->val)pdpp=i;
/* échange (si beaucoup d'éléments
déjà en place, rajouter un test pour ne pas échanger
inutilement) */
i=pdpp->suiv;
pdpp->suiv=i->suiv;
i->suiv=pdpd->suiv;
pdpd->suiv=i;
}
*prem=faux_debut.suiv; /* retourner le bon premier */
}
pdpd représente le Précédent De la Place Définitive (boucle principale : de place définitive valant *prem jusqu'à
fin de la liste), pdpp représente le Précédent Du Plus Petit (de la suite de la liste, pas encore traitée). On a dans

cette implantation évité les variables pour la place définitive et le plus petit, ceux-ci étant les suivants des
variables précisées ci-dessus. Ceci nuit à la clarté mais améliore l'efficacité. On pouvait améliorer la clarté
(définir les "variables" pd et pp) sans nuire à l'efficacité (ne pas devoir les remplacer par leur suivant en fin de
boucle) par des #define :
#define pd pdpd->suiv
#define pp pdpp->suiv
Pour limiter la portée de ces substitutions à cette fonction, il suffit de déclarer juste derrière la fin de la fonction :
#undef pd
#undef pp
De plus, afin d'éviter de tester partout le cas particulier du premier de la liste, on a choisi d'ajouter un élément en
début de liste (faux_début), pointant sur le premier de la liste. Dans ce cas, tous les éléments y compris le premier
ont un précédent. Le gain est donc appréciable (en temps car moins de tests et en taille du code source), pour un
coût limité à une variable locale supplémentaire.
le tri par création

Ce tri nécessite de recréer tous les liens. En fait on utilisera un algorithme par insertion (ou par sélection) un peu
modifié, puisque ces deux tris créent progressivement la liste triée. en cas de valeurs de grande taille, on préférera
ne créer qu'une nouvelle liste de liens, pour éviter de doubler la place mémoire utilisée par les valeurs (la
composante de base contiendra donc deux pointeurs : l'adresse de la valeur et l'adresse de la composante
suivante).
les autres tris

Le tri shell, quand à lui, n'améliore pas le tri par sélection puisqu'il traite les composantes séparées d'une distance
P.
Pour le tri rapide, le nombre de boucles internes est de l'ordre de Nlog(N) (N sur toute la liste, puis deux fois N/2
sur les deux moitiés.... donc N*P, P étant la profondeur de récursivité, qui est de log(N)). Par contre les échanges
sont plus nombreux que les autres tris (en moyenne une boucle interne sur deux pour un fichier mélangé). Pour
transposer l'implantation détaillée pour les tableaux, il faut disposer d'une liste à chaînage avant et arrière, mais il
est facile de n'utiliser que le chaînage avant : l'algorithme devient donc :
● choix d'un pivot (le premier par exemple, puisqu'on y accède directement),
● scruter la liste pour créer deux sous-listes (celle des valeurs plus petites et celle des plus grandes),
● appel récursif sur les deux sous-listes.
● mise à jour des liens (fin de la première liste, pivot, début de la deuxième)
Cette gestion des liens ralentit beaucoup l'algorithme, son implantation doit donc être soigneusement optimisée
pour espérer un gain, du moins pour les très longues listes.
problèmes mathématiques
On utilisera les listes pour les cas nécessitant de nombreuses manipulations (en particulier dans les problèmes
graphiques). On les utilise également pour les polynômes ou matrices creuses (c'est à dire avec de nombreux
coefficients nuls, on ne stocke que les coefficients non nuls (ainsi que leur indice ou le nombre de 0 qui les
séparent du suivant). Les algorithmes restent similaires à ceux s'appliquant aux tableaux, mais sont souvent moins

efficaces (une triangulation de Gauss rend non nuls une grande partie des coefficients nuls, nécessitant de
nombreuses insertions de nouveaux éléments).
conclusions
Les listes sont parfaitement dynamiques. Toutes les modifications peuvent se faire en cours d'utilisation. Par
contre l'accès est séquentiel, ce qui peut être très pénalisant dans certains cas. Il est néanmoins possible d'utiliser
un double chaînage avant et arrière, mais au détriment de la place mémoire. L'encombrement des listes en
mémoire est important : chaque élément doit contenir l'adresse du suivant (alors que pour les tableaux elle était
facile à calculer donc non stockée). Pour de très grandes listes, on peut remédier à ce problème en utilisant des
listes de tableaux, mais l'utilisation devient complexe. Un autre avantage des listes est que l'on utilise toujours un
adressage indirect, et donc que les manipulations dans les listes ne font que des modifications du chaînage, sans
réellement déplacer les valeurs stockées, ce qui est capital en cas de champs de grande taille.

Données et Algorithmique - LES PILES ET FILES
LES PILES ET FILES

● définition
● fonctions de base
● utilisations
définition
Ce sont des structures de données ordonnées, mais qui ne permettent l'accès qu'à une seule donnée. On utilise
souvent le nom générique de pile pour les piles et les files, un seul nom existant en anglais (stack). Les piles
(stack LIFO : Last In First Out) correspondent à une pile d'assiettes : on prend toujours l'élément supérieur, le
dernier empilé. Les files (on dit aussi queues) (stack FIFO: First In First Out) correspondent aux files d'attente :
on prend toujours le premier élément, donc le plus ancien (on ne tolère pas ici les resquilleurs). Les piles et files
sont très souvent utiles : elles servent à mémoriser des choses en attente de traitement. Elles permettront une
clarification des algorithmes quand effectivement on n'a pas besoin d'accéder directement à tous les éléments.
Elles sont souvent associées à des algorithmes récursifs. Il n'y a pas de structures spécifiques prévues dans les
langages (sauf FORTH), il faut donc les créer de toutes pièces. Pour les piles, on utilisera un tableau
unidimensionnel (statique ou dynamique) en cas de piles de hauteur maximale prévisible (la hauteur de la pile
est mémorisée par une variable entière), ou une liste en cas de longueur très variable (ne pas oublier que dans ce
cas on a un surcoût en mémoire d'autant de liens (pointeurs) que d'éléments empilés). Pour les files, l'utilisation
d'un tableau nécessite deux variables : la position du premier et celle du dernier. La suppression du premier
élément ne se fait pas par décalage des suivants mais en incrémentant la variable indiquant le premier. La
gestion est alors un peu plus complexe que pour les piles, puisque le suivant de la fin du tableau est le début du
tableau (en fait, l'indice du suivant est l'indice plus 1, modulo la taille du tableau. La fonction modulo est en fait
très rapide pour les nombres correspondants à une puissance de 2, à condition de l'implanter à l'aide d'un
masquage. L'utilisation d'une liste pour une file par contre est aussi simple que pour une pile.
fonctions de base
Les fonctions de base pour les piles sont l'empilage et le dépilage, pour les files l'enfilage et le défilage. Dans
les deux cas on prévoira également un fonction d'initialisation, et une fonction indiquant si la pile est vide.
Seules ces fonctions de base dépendent de la méthode réelle de mise en oeuvre (tableau, liste,...). Tous les
algorithmes n'utiliseront que ces fonctions. C'est le grand avantage des piles et files, puisque l'on va pouvoir
modifier facilement le type d'implantation en mémoire sans réécrire les programme. Ceci permet de tester
d'abord la faisabilité du programme sur des petites quantités de données puis seulement on l'optimise pour
l'utilisation réelle. Pour une implantation par tableaux, on écrira par exemple, pour une pile de flottants
(base_p_t) :
#define dim_pile 100


/* static pour empêcher l'accès direct extérieur*/

static composante pile[dim_pile];
static int sommet;
void init_pile(void)
{sommet=0;}
int pile_vide(void)
{return(sommet=0);}
int empiler(composante x)
/* retourne 0 si pas d'erreur (donc il restait de la place dans la pile) */
{
if(sommet<dim_pile)
{pile[sommet++]=x;return(0);}
else
{puts("pile saturée");return(1);}
}
composante depiler(void)
{
if (sommet>0) return(pile[--sommet]);
else puts("pile vide");return(0);
}
Si l'on désire un dimensionnement totalement dynamique de la pile, on utilisera une liste (base_p_l) :
#include <alloc.h>
#include <stdio.h>
typedef struct s_comp
{composante val;struct s_comp *prec;}type_comp;
static type_comp *sommet=NULL;
int empiler(composante x)
/* retourne 0 si pas d'erreur (donc il restait de la place dans la pile)*/
{
type_comp *nouv;
if((nouv=(type_comp*)malloc(sizeof(type_comp)))!=NULL)
{
nouv->val=x;
nouv->prec=sommet;
sommet=nouv;
return(0);}
else
{puts("pile saturée");return(1);}
}

{
composante x;
if (sommet!=NULL)
{
x=sommet->val;
free(sommet); /*pour plus de sûreté, on peut passer par
une variable*/
sommet=sommet->prec;
return(x);
}
else puts("pile vide");return(0);
}
void init_pile(void)
{while(sommet!=NULL)depiler();}
int pile_vide(void)
{return(sommet==NULL);}
Pour certaines applications, on pourra préférer ne pas libérer la mémoire au dépilage pour gagner du temps : au
dépilage, mais aussi à l'empilage, on ne prend du temps que s'il faut agrandir la pile. On peut également utiliser
une pile de tableaux dynamiques, ce qui permet d'économiser de la place mémoire, sans être limité en taille.
Pour les files, l'implantation des fonctions de base est similaire, par exemple par tableaux (base_f_t) :
#define dim_file 100

static composante file[dim_file];
static int bas,sommet,taille;
#define suiv(i) ((i)<dim_file-1 ? ((i)+1) : 0)
void init_file(void)
{bas=sommet=taille=0;}
int file_vide(void)
{return(taille=0);}
int enfiler(composante x)
/* retourne 0 si pas d'erreur (donc il restait de la place dans la pile)
*/
{
if(taille<dim_file)
{file[sommet]=x;sommet=suiv(sommet);taille++;return(0);}
else
{puts("file saturée");return(1);}
}

{
composante x;
if (taille>0) {x=file[bas];bas=suiv(bas);taille--;return(x);}
else {puts("file vide");return(0);}
}
Il faut prévoir un indice pour chaque extrémité de la file. Il en serait de même pour une implantation par liste
chaînée (un pointeur pour chaque extrémité).
utilisations
Les piles sont souvent nécessaires pour rendre itératif un algorithme récursif. Une application courante des piles
est pour les calculs arithmétiques: l'ordre dans la pile permet d'éviter l'usage des parenthèses. Il existe trois
possibilités pour représenter une équation (du moins de manière unidimensionnelle, les arbres en sont une
généralisation bidimensionnelle), suivant la position relative des opérateurs et de leurs opérandes. Il faut avant
tout définir l'arité d'une opération : une opération unaire nécessite un opérateur (- unaire, cosinus, log,
factorielle...), une opération deuxaire (dénomination P. Trau, pour différencier d'une opération binaire qui pour
moi traite des nombres en base 2) nécessite deux arguments (+, -, *, /, produit vectoriel,...), une opération
ternaire nécessite trois opérandes (produit mixte,...). La notation préfixée (dite polonaise) consiste à placer
l'opérateur, suivi de ses arguments. La notation postfixée (polonaise inverse) consiste à placer les opérandes
devant l'opérateur. La notation infixée (parenthèsée) consiste à entourer les opérateurs deuxaires par leurs
opérandes, pour les autres arités on place l'opérateur en premier, suivi de ses opérandes (entre parenthèses,
séparés par des virgules pour les opérateurs ternaires). Les parenthèses sont nécessaires uniquement en notation
infixée, certaines règles permettent d'en réduire le nombre (priorité de la multiplication par rapport à l'addition,
en cas d'opérations unaires représentées par un caractère spécial (-, !,...). Les notations préfixée et postfixée sont
d'un emploi plus facile puisqu'on sait immédiatement combien d'opérandes il faut rechercher. Détaillons ici la
saisie et l'évaluation d'une expression postfixée (polonais) : on modifie le type de composantes de la pile (et
donc les fonctions de base) :
#define operande 1
#define operateur 0
typedef struct
{int type;
union {float op_r;char op_c;}val;
}composante;
void saisie(void)
/* marche pour toute notation puisque ne vérifie rien */
{
composante x;
char txt[100],*deb;
char rep;
init_pile();
printf("entrez opérandes (nombres) et opérateurs (+,-,*,/,C (cos),S)\n");
printf("séparés par des blancs ou virgules\n");
fflush(stdin);
gets(txt); /* on lit un texte qui sera traité par après */
deb=txt; /* deb pointe le début du texte non encore traité */

do
{
while(*deb==' '||*deb==',') deb++;
if(*deb==0)break;
if(isdigit(*deb)||*deb=='.'||(*deb=='-'&&isdigit(*(deb+1))))
{
x.type=operande;
sscanf(deb,"%f",&(x.val.op_r));
empiler(&x);
while(isdigit(*deb)||*deb=='.') deb++; /*pointer la suite*/
}
else /*cas d'un opérateur */
{
x.val.op_c=toupper(*(deb++));
x.type=operateur;
empiler(&x);
}
}
while(1);
}
float eval_post(void)
{
float r1,r2;
composante x;
if(depiler(&x)!=0) {puts("expression non postfixée");return(0);}
if(x.type==operande) return(x.val.op_r);
/* else inutile car les autres cas se finissent par return */
/* on traite d'abord les opérateurs unaires */
if (x.val.op_c=='C') return(cos(eval_post()));
if (x.val.op_c=='S') return(sin(eval_post()));
/* les deuxaires maintenant */
r2=eval_post();
r1=eval_post();
switch (x.val.op_c)
{
case '+':return(r1+r2);
case '-':return(r1-r2);
case '*':return(r1*r2);
case '/':return(r1/r2);
}
puts("erreur (code opératoire inconnu par exemple)");
return(0);
}
void main(void)
{
saisie();

printf("l'expression postfixée vaut %6.1f\n",eval_post());

}
Les piles permettent très souvent de clarifier l'implantation d'un algorithme, bien qu'évidemment on puisse
utiliser le principe tout en n'utilisant que des tableaux ou listes.

Données et Algorithmique - LES ARBRES
LES ARBRES
● introduction
● expressions arithmétiques (arb_expr)
● listes triées
● les arbres généraux
introduction
Les listes et piles sont des structures dynamiques unidimensionnelles. Les arbres sont leur généralisation
multidimensionnelle (une liste est un arbre dont chaque élément a un et un seul fils). On utilise un
vocabulaire inspiré des arbres généalogiques (sexiste il est vrai, bien qu'on utilise quelquefois les termes
fille et mère). Chaque composante d'un arbre contient une valeur, et des liens vers ses fils. On peut
distinguer un noeud, qui est une composante ayant des fils, et une feuille, qui n'en possède pas (mais est
fils d'un noeud) mais souvent on préfère utiliser un type noeud y compris pour les feuilles (tous les fils
sont mis à NULL), surtout si l'arbre est évolutif (une feuille peut devenir un noeud, et inversement). Une
branche rassemble un lien vers un fils mais aussi ce fils et toute sa descendance. Le noeud racine est le
seul qui n'est le fils d'aucun noeud (tous les autres noeuds sont donc sa descendance). Comme pour le
premier d'une liste, l'adresse de la racine est nécessaire et suffisante pour accéder à l'intégralité d'un
arbre. Un arbre N-aire ne contient que des noeuds à N fils (et des feuilles). Une liste est donc un arbre
unaire. De nombreux algorithmes ont été développés pour les arbres binaires (nous verrons que tout arbre
peut être représenté par un arbre binaire). Comme les listes, les arbres sont complètement dynamiques,
mais les liens sont également gourmands en mémoire. L'accès aux données est encore séquentiel, mais on
verra qu'il reste néanmoins rapide.
expressions arithmétiques (arb_expr)

Nous allons détailler les fonctionnalités de base des arbres à l'aide d'un exemple : la représentation et
l'évaluation d'expressions arithmétiques. Nous supposerons (voir chapitre sur les piles) utiliser
uniquement des opérandes flottants, les opérateurs deuxaires +,-,*,/ et les opérateurs unaires C (pour
cosinus) et S (sinus). L'expression 2*5 + 2*{cos[(5*3.14)/180]} se représentera :

Les composantes de l'arbre seront donc soit des opérateurs (noeuds), soit des opérandes (feuilles). Nous
allons choisir les déclarations suivantes :
typedef float type_feuille;

typedef struct s_noeud_2
{char op_c;
struct s_comp*fils1;
struct s_comp*fils2;
}type_noeud_2;
typedef struct s_noeud_1
{char op_c;
struct s_comp*fils;
}type_noeud_1;
typedef struct s_comp
{int arite;
union
{type_noeud_2 n2;
type_noeud_1 n1;
type_feuille f;
}val;
}composante;
typedef composante *lien;
Nous prévoyons donc deux types de noeuds : à arité 1 (avec un fils) ou à arité 2 (deux fils). On aurait pu
utiliser un seul type (à arité 2) en mettant NULL dans le second fils en cas d'arité 1. Une feuille par
contre ne contient aucun lien. Une composante de l'arbre contiendra donc un indicateur de son type (ici
l'arité) et, suivant ce type, soit une feuille, soit un noeud (d'arité 1 ou 2). Nous allons écrire une fonction
créant un tel arbre (à partir d'une chaîne de caractères préalablement saisie, contenant l'expression en
notation polonaise préfixée par exemple) :
lien saisie_prefixe(char **deb)

/* on donne une chaîne de char contenant l'expression en notation préfixée. les opérateurs possibles sont
+,-,*,/(deuxaires), C,S(cos,sin,unaires). Les nombres sont séparés par des blancs (optionnels pour les
opérateurs) Les nombres commencent par un chiffre (exemple 0.5 au lieu de .5).*/
/* deb pointe sur le début de chaîne, il pointera ensuite sur le reste de la chaîne (pas encore traitée) donc
passage par adresse d'un pointeur */
{
lien x;
char c;
while(**deb==' '||**deb==',') (*deb)++;
if(**deb==0) /* on est arrivé en fin de chaîne */
{puts("erreur : il doit manquer des opérandes");
return(NULL);}
x=(composante*)malloc(sizeof(composante));
if(isdigit(**deb))
{
x->arite=0;
sscanf(*deb,"%f",&(x->val.f));
while(isdigit(**deb)||**deb=='.') (*deb)++;
}
else
{
c=toupper(*((*deb)++));
if(c=='*'||c=='/'||c=='+'||c=='-')
{
x->arite=2;
x->val.n2.op_c=c;
x->val.n2.fils1=saisie_prefixe(deb);
x->val.n2.fils2=saisie_prefixe(deb);
}
else if(c=='C'||c=='S')
{
x->arite=1;
x->val.n1.op_c=c;
x->val.n1.fils=saisie_prefixe(deb);
}
else printf("erreur, '%c'n'est pas un opérateur prévu\n",c);
}
return(x);
}
On peut remarquer que cette fonction est récursive. La création de l'arbre à partir d'une expression
postfixée est similaire (scruter la chaîne dans l'autre sens par exemple), à partir d'une expression infixée
c'est un peu plus dur, surtout si l'on ne veut pas imposer d'entrer toutes les parenthèses, par exemple
1+2+3 au lieu de (1+(2+3)).

L'utilisation d'un tel arbre devient maintenant très simple. On utilisera la récursivité. Pour évaluer
l'expression, si c'est une feuille unique la valeur est celle de la feuille, si c'est un noeud, la valeur est
obtenue en effectuant l'opération correspondante, après évaluation (récurrente, donc soit directement la
valeur si feuille soit nouveau calcul) de ses fils :
float eval(lien x)
{
float r1,r2;
if(x->arite==0) return(x->val.f);
else if (x->arite==1)
{
if (x->val.n1.op_c=='C')
return(cos(eval(x->val.n1.fils)));
else if (x->val.n1.op_c=='S')
return(sin(eval(x->val.n1.fils)));
}
else
{
r1=eval(x->val.n2.fils1);
r2=eval(x->val.n2.fils2);
switch (x->val.n2.op_c)
{
case '+':return(r1+r2);
case '-':return(r1-r2);
case '*':return(r1*r2);
case '/':return(r1/r2);
}
}
/* si aucun return n'a été effectué jusqu'ici*/
puts("erreur (code opératoire inconnu par exemple)");
return(0);
}
Le parcours des arbres (c'est à dire le passage par tous les noeuds et feuilles) se fait d'habitude de manière
récursive. On doit évidement parcourir l'arbre pour afficher son contenu. On peut utiliser dans le cas des
arbres binaires trois possibilités de parcours : afficher la valeur du noeud puis récursivement de ses deux
fils, afficher le premier fils, la valeur du noeud, puis le second fils, ou afficher les deux fils avant la
valeur du noeud. On obtient dans notre cas directement les notations préfixé, infixée et postfixée (avec un
petit travail supplémentaire pour la gestion des parenthèses en notation infixée, qu'on aurait pu simplifier
si l'on avait accepté des parenthèses surabondantes) :
void affiche_prefixe(lien x)
{
switch(x->arite)
{
case 0:printf("%6.1f ",x->val.f);break;

case 1:printf(" %C ",x->val.n1.op_c);

affiche_prefixe(x->val.n1.fils);
break;
case 2:printf(" %c ",x->val.n2.op_c);
affiche_prefixe(x->val.n2.fils1);
affiche_prefixe(x->val.n2.fils2);
}
}
void affiche_postfixe(lien x)
{
switch(x->arite)
{
case 1:affiche_postfixe(x->val.n1.fils);
printf(" %C ",x->val.n1.op_c);
break;
case 2:affiche_postfixe(x->val.n2.fils1);
affiche_postfixe(x->val.n2.fils2);
printf(" %c ",x->val.n2.op_c);
}
}
void affiche_infixe(lien x)
{
switch(x->arite)
{
case 1:printf(" %C( ",x->val.n1.op_c);
affiche_infixe(x->val.n1.fils);
putch(')');
break;
case 2:if(x->val.n2.fils1->arite!=0)putch('(');
affiche_infixe(x->val.n2.fils1);
if(x->val.n2.fils1->arite!=0)putch(')');
printf(" %c ",x->val.n2.op_c);
if(x->val.n2.fils2->arite!=0)putch('(');
affiche_infixe(x->val.n2.fils2);
if(x->val.n2.fils2->arite!=0)putch(')');
}
}
Notre exemple est un peu plus complexe que dans véritable arbre binaire, puisque nous acceptions
également des noeuds à un seul fils.

listes triées
Il est possible de mémoriser une liste ordonnée à l'aide d'un arbre binaire. Chaque noeud de l'arbre
contient une valeur et deux liens : l'un vers un sous-arbre ne contenant que des valeurs inférieures, l'autre
vers des valeurs supérieures. Nous allons traiter cette fois des chaînes de caractères plutôt que des réels.
Nous définirons donc les types suivants :
typedef struct s_noeud *lien;

typedef struct s_noeud
{char *nom;
lien fils1;
lien fils2;
}type_noeud;
Il vaut mieux ne pas prévoir de type spécifique pour les feuilles, l'arbre étant géré de manière évolutive
(une feuille sera donc un noeud avec ses deux fils valant le pointeur NULL). Le nom contenu dans
chaque noeud aurait pu être un tableau statique de caractères, mais pour optimiser le coût mémoire, nous
utiliserons un tableau dynamique. Donc, pour allouer la mémoire d'un nouveau noeud, deux malloc
seront nécessaires : un pour le noeud lui-même, et un pour le nom qui lui est associé. Ecrivons une
fonction de création d'un noeud (on lui transmet le nom associé, elle retourne l'adresse allouée):
lien cree_feuille(char *nouv_nom)

{
lien x;
int taille;
x=(lien)malloc(sizeof(type_noeud));
taille=strlen(nouv_nom)+1; /* compter le \0 */
x->nom=(char*)malloc(taille);
strcpy(x->nom,nouv_nom);
x->fils1=NULL;
x->fils2=NULL;
return(x);
}
Supposons entrer dans l'ordre : Jean, Bernard, Lucie, Anne, Jacques, Laurent, Maud, Luc, Julie, Elsa. Si
vous créez progressivement l'arbre, vous pourrez voir que toute nouvelle valeur trouve toujours sa place,
les feuilles se transformant petit à petit en noeuds, au fur et à mesure de l'augmentation de la taille de
l'arbre.

La fonction effectuant la saisie et la création de cet arbre devra donc, après la saisie du nouveau nom à
insérer, rechercher sa position définitive. Cette recherche sera récursive: sur un noeud donné, si le
nouveau nom est plus petit, rechercher dans la descendance du fils1, sinon rechercher dans la
descendance du fils2. La recherche s'arrête quand on arrive à un pointeur NULL (qui sera remplacé par
l'adresse du nouveau noeud). En cas d'égalité, si l'on désire une création stable, un nouveau nom sera
placé derrière ceux déjà existants. :
void insert_feuille(lien racine, lien x)

{
while(racine!=NULL) /* ou boucle infinie */
{
if(strcmp(x->nom,racine->nom)<0)
if(racine->fils1==NULL){racine->fils1=x;return;}
else racine=racine->fils1;
else
if(racine->fils2==NULL){racine->fils2=x;return;}
else racine=racine->fils2;
}
}
lien saisie(void)
{
lien racine=NULL;
char txt[100];
do
{
printf("entrez un nouveau nom, @@@ pour finir : ");
gets(txt);
if(strcmp(txt,"@@@"))
if(racine==NULL)racine=cree_feuille(txt);
else insert_feuille(racine,cree_feuille(txt));
}
while(strcmp(txt,"@@@"));
return(racine);
}

On remarque l'efficacité de cette méthode : aucun déplacement d'élément, le tri se fait par insertion, mais
avec recherche optimisée (du type dichotomie : l'espace de recherche est réduit à chaque test). Pour N
insertions, on fait donc N recherches donc N*P lectures de composantes (P profondeur de l'arbre).
Une fois l'arbre créé, on peut afficher la liste triée par ordre alphabétique par un simple parcours infixé
(arbr_nom):
void affiche(lien x)
{
if(x!=NULL)
{
affiche(x->fils1);
printf("%s, ",x->nom);
affiche(x->fils2);
}
}
L'utilisation d'un arbre binaire pour une liste triée permet donc une programmation relativement aisée,
des algorithmes rapides, mais moyennant un peu de place mémoire supplémentaire. L'arbre va posséder
simultanément tous les avantages des autres structures de données:
● totalement dynamique: l'insertion d'un élément se fait sans aucun déplacement d'élément (ni même
d'échange de liens comme c'était le cas pour les listes)
● rapide : la recherche d'un élément se fait en P tests maximum, P étant la profondeur de l'arbre (ce
qui donne la même efficacité qu'une recherche dichotomique dans un tableau, dans le cas d'un
arbre équilibré).
● parcours facile des données sans coût trop important en mémoire (avec deux liens on obtient une
structure bidimensionnelle, alors qu'avec une liste à chaînage avant et arrière on garde une
structure unidimensionnelle, bien que bidirectionnelle).
Par contre l'arbre binaire nécessite d'être équilibré pour profiter pleinement de ces avantages. Un arbre
équilibré est un arbre organisé de telle manière à ce que sa profondeur soit minimale. A l'extrême, en cas
d'introduction d'une liste de noms déjà triée, tous les fils1 pointeront sur NULL alors que les fils2
pointeront sur le suivant, on se retrouve dans le cas d'une liste chaînée simple. Différents algorithmes
d'équilibrage d'arbres binaires existent, mais en général un algorithme simple permet un résultat
satisfaisant (sauf en cas d'un très grand nombre de données), l'équilibre parfait n'étant pas nécessaire.
les arbres généraux

Quand le nombre de fils de chaque élément est variable, on peut soit prévoir un tableau statique des
adresses des fils, soit prévoir un tableau dynamique, ce qui optimise l'occupation mémoire mais
complique l'ajout de fils supplémentaires. Pour avoir une gestion parfaitement dynamique, on peut créer
une liste des adresses des fils :

En fait, plutôt que de créer cette liste hors des noeuds, le plus simple (et qui utilise autant de mémoire)
est d'associer à chaque noeud l'adresse de son fils aîné, et de son frère cadet. Accéder à tous les fils
revient donc à accéder au fils aîné puis à tous ses frères:
On peut remarquer qu'un tel arbre est un arbre binaire: chaque noeud possède deux liens. On peut donc
traiter tout arbre sous forme d'un arbre binaire.
Une autre amélioration possible d'un arbre est de permettre un accès toujours séquentiel mais
bidirectionnel : pour un arbre binaire, chaque noeud possède en plus l'adresse de son père, pour un arbre
généralisé ceci revient à ce que chaque frère connaît son aîné, l'aîné connaissant leur père commun. Cet
accès bidirectionnel est coûteux en mémoire, mais complique également les modifications (plus de liens
à gérer), pour par contre accélérer les parcours dans l'arbre. On ne prévoira cette amélioration que lorsque
l'on utilise de fréquentes remontées (l'utilisation d'algorithmes récursifs ne nécessite en général pas ces
liens, le fait de quitter une fonction appelée pour gérer un fils fait automatiquement retrouver le père).

Données et Algorithmique - LES GRAPHES
LES GRAPHES
Un graphe est en ensemble de noeuds reliés par des liens. Ce n'est plus un arbre dès qu'il existe deux
parcours différents pour aller d'au moins un noeud à un autre. Un graphe est connexe lorsqu'il est
possible de trouver au moins un parcours permettant de relier les noeuds deux à deux (un arbre est un
graphe connexe, deux arbres forment un graphe non connexe). Un graphe est dit pondéré lorsqu'à chaque
lien est associée une valeur (appelée poids). On utilisera un graphe pondéré par exemple pour gérer des
itinéraires routiers (quelle est la route la plus courte pour aller d'un noeud à un autre), pour gérer des
fluides (noeud reliés par des tuyauteries de diamètre différent) ou pour des simulations de trafic routier,
pour simuler un circuit électrique, pour prévoir un ordonnancement dans le temps de tâches... Un graphe
est dit orienté lorsque les liens sont unidirectionnels. Nous ne traiterons pas ici en détail les algorithmes
associés aux graphes, mais nous aborderons quelques problèmes rencontrés.
On peut représenter un graphe de manière dynamique, comme les arbres (le nombre de liens par noeud
est souvent variable). Une autre solution est de numéroter les N sommets, et d'utiliser une matrice carrée
NxN, avec en ligne i et colonne j un 0 si les noeuds i et j ne sont pas reliés, ou le poids de la liaison sinon
(1 pour les graphes non pondérés). Pour des graphes non orientés, la matrice est symétrique (par rapport
à la diagonale), ce qui permet d'économiser de la mémoire mais peut compliquer les programmes (c'est la
technique employée pour les éléments finis). Une représentation par matrice est surtout intéressante
lorsqu'il y a beaucoup de liens (graphe presque complet), la représentation à l'aide de pointeurs étant
moins gourmande en mémoire pour les graphes comportant peu de liens par noeud.
Un problème important est le parcours d'un graphe : il faut éviter les boucles infinies, c'est à dire
retourner sur un noeud déjà visité et repartir dans la même direction. On utilise par exemple des
indicateurs de passage (booléens), ou une méthode à jetons (on place des "jetons" dans différents noeuds
bien choisis et on les fait suivre les liens). Une méthode souvent utilisée est de rechercher avant tout (et
une seule fois) l'arbre recouvrant : c'est un arbre permettant de visiter tous les noeuds, n'utilisant que des
liens existants dans le graphe (mais pas tous). Cet arbre recouvrant n'est évidement pas unique. En cas de
graphe non connexe, il faut rechercher plusieurs arbres recouvrants.
On peut remarquer qu'un arbre recouvrant d'un graphe connexe à N sommets aura nécessairement N-1
liens. Pour les graphes pondérés, on peut rechercher l'arbre recouvrant de poids minimum (somme des
poids des liens minimale). Différents algorithmes existent pour traiter ce problème.
http://www-ipst.u-strasbg.fr/pat/program/algo08.htm [21-11-2001 17:42:43]

Données et Algorithmique - LES FICHIERS
LES FICHIERS
● les fichiers séquentiels
● les fichiers à accès direct
● l'indexation
Les fichiers ont pour avantage d'être dynamiques (la taille peut varier ou du moins augmenter au cours de
l'utilisation, du moins tant qu'il reste de la place sur le support), et de ne pas être volatiles comme l'est la
mémoire (c'est à dire que les informations restent présentes en l'absence d'alimentation électrique). Leur
principal inconvénient est le temps d'accès à une donnée (de l'ordre de 106 fois plus lent que la mémoire,
en général plus de 10 ms pour un disque dur, mais jusqu'à plusieurs secondes pour une bande
magnétique). L'insertion et la suppression d'éléments autre part qu'en fin d'un fichier est quasiment
impossible, en général on devra passer par la création d'un nouveau fichier, y recopier le début du fichier
initial jusqu'à la modification prévue, puis écrire les données modifiées puis recopier le reste du fichier.
Les fichiers peuvent être séquentiels ou à accès direct.
les fichiers séquentiels

Un fichier séquentiel permet uniquement d'accéder aux données dans l'ordre de leur écriture. L'exemple
le plus courant est la bande magnétique (ou streamer ou DAT). On n'utilise plus que rarement les fichiers
stockés sur bande directement dans les programmes : du fait des possibilités des disques durs (jusqu'à
plusieurs Giga-octets), on préfère utiliser des fichiers à accès direct, et les sauvegarder sur bande
(séquentiellement) une fois le traitement terminé. Certaines grosses applications nécessitent néanmoins
des traitements directement sur bandes magnétiques, il faut alors choisir les algorithmes en conséquence
(en général dans ces cas on utilisera au moins deux lecteurs de bandes, un pour le fichier initial, un pour
le fichier traité), en choisissant plus particulièrement des algorithmes divisant le fichier en sous-fichiers
qui eux tiendront en mémoire centrale et pourront être traités plus rapidement (par exemple pour les tris,
on utilisera par exemple un tri par fusion, surtout si l'on dispose de trois lecteurs : deux pour les sous
fichiers à fusionner, le troisième pour le fichier final). Le grand avantage du fichier séquentiel est qu'il
peut contenir des données de tout type, de taille différente (c'est désormais la seule raison de son
utilisation). Pour stocker un graphique, on pourra enregistrer le nombre de segments, puis les
caractéristiques de chacun des segments, puis le nombre d'arcs de cercles, puis leurs caractéristiques,...
On classe souvent sous la dénomination de fichiers séquentiels les fichiers de texte : se sont en fait
souvent des fichiers à accès direct aux caractères (on peut accéder directement au Nième caractère), mais
en fait l'accès est séquentiel au niveau des lignes : pour accéder à la Nième ligne, il faut lire le fichier
depuis le début, jusqu'à compter N-1 signes de fin de ligne. Les fichiers de texte peuvent également être
utilisés pour stocker des valeurs numériques : les nombres sont alors formatés pour être écrits en décimal
à l'aide de caractères ASCII, et peuvent donc directement être imprimés ou réutilisés par un autre

programme ou sur une autre machine, alors que la sauvegarde directe d'une valeur numérique est faite en
binaire (recopie des 0 et 1 en mémoire), ce qui prend moins de place mais n'est plus lisible que par un
programme qui utilise le même format.
Les fichiers séquentiels ne peuvent en général pas être modifiés, la seule possibilité étant l'ajout derrière
les données déjà stockées (pour un fichier texte, sur disque, on peut remplacer des caractères mais pas en
ajouter ni en supprimer sauf en fin de fichier).
les fichiers à accès direct

Un fichier à accès direct correspond à un tableau en mémoire : toutes ses composantes ont la même taille,
on peut donc accéder directement à la Nième. Comme pour un tableau, les insertions et suppressions
nécessitent des décalages des composantes suivantes, ce qui est en général trop long pour être
envisageable. Ceci exclut donc l'utilisation de tout algorithme utilisant l'insertion (le tri par insertion par
exemple), mais aussi ceux qui déplacent des éléments sans les positionner à leur place définitive (le tri
bulle par exemple). Une méthode de tri sera par exemple un tri par sélection et création d'un nouveau
fichier. L'accès au données devra être optimisé : on préférera bien évidement la dichotomie à la recherche
séquentielle, et même on préférera une dichotomie pondérée (avec estimation par calcul de la position
probable), puisque tout calcul sera beaucoup plus rapide qu'une lecture dans le fichier.
Un fichier à accès direct peut également être utilisé pour stocker et traiter des listes, arbres ou graphes :
on utilise la méthode du super-tableau : chaque élément est numéroté, en fonction de sa position dans le
fichier, les liens étant ces numéros. Il faut bien garder à l'esprit qu'il ne faut jamais stocker sur fichier un
pointeur : l'adresse où a été mise la valeur pointée a peu de chances d'être la même à la prochaine
utilisation du programme. Ils est alors toujours nécessaire de numéroter les composantes et remplacer les
pointeurs par le numéro de la valeur pointée avant de faire une sauvegarde sur fichier.
l'indexation
La méthode souvent la plus efficace pour l'utilisation de fichiers séquentiels est l'indexation (elle est
également utilisable pour les autres types de données, stockées en mémoire). Les composantes sont
stockées dans le fichier dans l'ordre de leur création. On utilise alors un tableau d'index, donnant en
première position le numéro de la première composante, puis de la seconde,... L'avantage de cette
méthode est que l'ajout de composantes est optimal : on rajoute la valeur en fin de fichier, on met à jour
le tableau d'index. Tout déplacement d'une composante sera donc remplacé par une modification du
tableau d'index, sans déplacement réel de la valeur dans le fichier. En général, ce tableau peut tenir en
mémoire, ce qui permet une modification rapide, en général on préfère le sauver également sur support
magnétique avant de quitter le programme, ce qui évitera de le recréer (par exemple refaire un tri) à la
prochaine utilisation. On peut également utiliser une liste d'index si les déplacements sont fréquents
(mais alors l'accès devient séquentiel). Le second avantage de cette méthode est que l'on peut utiliser
simultanément plusieurs index : par exemple pour une liste de personnes, on peut créer un index pour le
classement alphabétique des noms, un autre sur les villes, on accédera donc plus rapidement à tous les
champs indexés, alors que les champs non indexés devront se satisfaire d'une recherche séquentielle, et
ce sans modification dans le fichier (un tri par nom puis par ville auraient été nécessaires sans
indexation). Par contre toute modification nécessitera la mise à jour de tous les tableaux d'index.

Exemple:
La suppression, par contre, pose problème. En général, toujours pour éviter les décalages dans les
fichiers, on préfère marquer d'un signe distinctif les champs supprimés (par exemple un nom non
alphabétique ou vide), puis remettre à jour les index qui ne pointeront plus sur ce champ. Le retassage,
assez long, n'est effectuée que sur ordre de l'utilisateur ou lorsqu'il quitte le programme. On peut aussi
(comme dans la méthode du super-tableau) créer une liste des champs vides, ce qui permettra d'y
accéder, plus rapidement que par une recherche séquentielle, lors de la prochaine insertion.
Sur un fichier indexé, on peut à nouveau se permettre des algorithmes utilisant l'insertion, puisque
celle-ci n'affecte que l'index (à accès rapide). Pour un tri par exemple, on pourra utiliser le tri par
insertion, à condition d'optimiser la recherche de la position d'insertion (par dichotomie pondérée par
exemple), puisque celle-ci nécessite des lectures de champs dans le fichier alors que l'insertion n'entraîne
que des décalages dans un tableau, d'une durée généralement négligeable devant le temps pris par la
recherche. On peut également utiliser une liste d'index plutôt qu'un tableau si nécessaire.

Données et Algorithmique - CORRECTION DES EXERCICES
CORRECTION DES EXERCICES

● BOUCLE
● TUSEXO_A
● TUSEXO_B
● GAUSS_MRD
● INSE_TTD
BOUCLE
#include <stdio.h>;
void main(void)
{
float puiss,x,result;
printf("entrez x ");
scanf("%f",&x);
result=2 -5*x +(puiss=x*x) -3*(puiss*=x) +2*puiss*x;
printf("résultat : %f\n",result);
}
TUSEXO_A
#include <stdio.h>
#define dim 10
void main(void)
{
int i,nb;
composante v,t[dim],moy=0;
do
{
printf("entrez la %dième note (fin si <0 ou >20) :",nb+1);
scanf("%f",&v);
if(v<0||v>20) break; /* on aurait pu le mettre dans la condition du while */
moy+=v;
}
while (!ajoute_val_tus(t,&nb,dim,v));
if(nb) moy/=nb;
printf("moyenne des %d notes : %5.2f\n",nb,moy);
for(i=0;i<nb;i++) printf("%2dième valeur : %5.2f (écart/moyenne
%+5.2f)\n",i+1,t[i],t[i]-moy);
}

TUSEXO_B
#include <stdio.h>
#include <conio.h>
#include "mani_tus.inc"
#define dim 10
void lecture(type_tus t,int *nb)
{
composante v;
do
{
printf("entrez la %dième note (fin si <0 ou >20) :",(*nb)+1);
scanf("%f",&v);
if(v<0||v>20) break; /* on aurait pu le mettre dans la condition du while */
}
while (!ajoute_val_tus(t,nb,dim,v));
}
void main(void)
{
int nb;
composante t[dim];
char rep;
lecture(t,&nb);
do
{
printf("0 fin, 1 affiche, 2 rot gauche, 3 rot droite, 4 suppr, 5 ins :");
rep=getche()-'0';
printf("\n");
switch (rep)
{
case 0:puts("au revoir");break;
case 1:affiche_tus(t,nb);break;
case 2:rot_gauche_tus(t,nb);break;
case 3:rot_droite_tus(t,nb);break;
case 4:{int pos;
printf("position de l'élément à supprimer ? ");
scanf("%d",&pos);
suppr_tus(t,&nb,pos);
break;}
case 5:{int pos;composante v;
printf("position de l'élément à insérer ? ");
scanf("%d",&pos);
printf("valeur à insérer ? ");
scanf("%f",&v);
insert_tus(t,&nb,dim,pos,v);
break;}
default:puts("code erroné !");
}
}
while (rep);
}

GAUSS_MRD
#include <stdio.h>
#include <alloc.h>
#include <math.h> /* pour fabs */

typedef composante *mat_dyn;
#define adr_mrd(l,c,nbc) ((l)*(nbc)+(c))
mat_dyn alloc_mrd(int nbl,int nbc)

{return((mat_dyn)malloc(nbl*nbc*sizeof(composante)));}
void affiche_mrd(mat_dyn tab,int nblig, int nbcol)

{
int l,c;
printf("\n");
for(l=0;l<nblig;l++)
{
printf("|");
for(c=0;c<nbcol;c++)printf("%5.1f ",tab[adr_mrd(l,c,nbcol)]);
printf(" |\n");
}
}
void autom_3_3(mat_dyn *t,int*nblig, int *nbcol)

{
composante ex[][3]={{1,1,-2},{1,3,-4},{-1,-2,6}};
int l,c;
*nblig=*nbcol=3;
*t=alloc_mrd(*nblig,*nbcol);
for(l=0;l<*nblig;l++) for(c=0;c<*nbcol;c++)
(*t)[adr_mrd(l,c,*nbcol)]=ex[l][c];
}
void autom_3_1(mat_dyn *t,int*nblig, int *nbcol)
{
composante ex[]={2,6,-1};
int l,c;
*nblig=3;*nbcol=1;
*t=alloc_mrd(*nblig,*nbcol);
for(l=0;l<*nblig;l++) for(c=0;c<*nbcol;c++)
(*t)[adr_mrd(l,c,*nbcol)]=ex[l];
}
void gauss_triangulation(mat_dyn A,mat_dyn B, int N)

{
int ce,l,c,lpivot;
composante coef;
for(ce=0;ce<N-1;ce++) /* ce=colonne à effacer */
{
/* recherche du pivot le plus grand possible (dans les lignes qui restent)
*/

lpivot=ce;
for(l=ce+1;l<N;l++)
if(fabs(A[adr_mrd(l,ce,N)])>fabs(A[adr_mrd(lpivot,ce,N)])) lpivot=l;
/* echange de la ligne du pivot et de la ligne ce (ne pas oublier B)*/
for(c=ce;c<N;c++) /* tous les termes devant ce sont nuls */
{
coef=A[adr_mrd(ce,c,N)];
A[adr_mrd(ce,c,N)]=A[adr_mrd(lpivot,c,N)];
A[adr_mrd(lpivot,c,N)]=coef;
}
coef=B[ce];B[ce]=B[lpivot];B[lpivot]=coef;
{
coef=A[adr_mrd(l,ce,N)]/A[adr_mrd(ce,ce,N)];
A[adr_mrd(l,ce,N)]=0; /* normalement pas besoin de le calculer*/
for(c=ce+1;c<N;c++)
A[adr_mrd(l,c,N)]-=coef*A[adr_mrd(ce,c,N)];
B[l]-=coef*B[ce];
}
}
}
void gauss_resolution(mat_dyn A,mat_dyn B,mat_dyn X,int N)

/* on pourait rendre le résultat dans B (si l'utilisateur
désirait le garder, il lui suffit de le copier avant). Ceci
économise le tableau X et le tampon */
{
int l,c;
composante tampon;
for(l=N-1;l>=0;l--)
{
tampon=B[l];
for(c=l+1;c<N;c++) tampon-=A[adr_mrd(l,c,N)]*X[c];
X[l]=tampon/A[adr_mrd(l,l,N)];
}
}
void main(void)
{
int nblA,nblB,nbcA,nbcB;
mat_dyn A,B,X;
autom_3_3(&A,&nblA,&nbcA);
affiche_mrd(A,nblA,nbcA);
autom_3_1(&B,&nblB,&nbcB);
affiche_mrd(B,nblB,nbcB);
if(nblA!=nbcA){puts("erreur fatale : matrice A non carrée");return;}

if(nblB!=nblB){puts("erreur fatale : nb lignes du second membre incompatibles");
return;}
if(nbcB!=1){puts("erreur fatale : le second membre doit avoir une seule colonne");
return;}
gauss_triangulation(A,B,nblA); /*nblA=nbcA=nblB*/
puts("résultat après triangulation : ");

affiche_mrd(A,nblA,nbcA);
affiche_mrd(B,nblB,nbcB);
X=alloc_mrd(nblB,nbcB);
gauss_resolution(A,B,X,nblA);
puts("solution :");
affiche_mrd(X,nblB,1);
}
INSE_TTD
#include <stdio.h>
#include <alloc.h>
#include <string.h>
typedef char composante;
typedef composante *ligne;
/* ou composante ligne []*/
typedef ligne *mat_ttd;
/* ou ligne mat_ttd[] */
void affiche(mat_ttd tab,int nblig)

{
int l;
for(l=0;l<nblig;l++)printf("%s\n",tab[l]);
}
void lecture(mat_ttd *tdl,int *nblig)

{
/* on se limite à 100 lignes de 1000 caractères, mais une
fois sorti de la fonction, seule la place nécessaire est
réservée (variables locales). On supprime ces limites par
utilisation (toujours temporaire) de listes chaînées */
composante txt[1000];
ligne tab_de_lignes[100];
int longueur;
*nblig=0;
printf("entrez vos lignes (fin du texte par '@@@' en déb de ligne):\n");
do
{
gets(txt);
longueur=strlen(txt); /* \0 non compris */
if(!strcmp(txt,"@@@"))break;
tab_de_lignes[*nblig]=(ligne)malloc(longueur+1);
strcpy(tab_de_lignes[*nblig],txt);
(*nblig)++;
}
while (1);
*tdl=(mat_ttd)malloc((*nblig)*sizeof(ligne));
memcpy(*tdl,tab_de_lignes,(*nblig)*sizeof(ligne));
}
void tri_insertion(mat_ttd tab, int N)

{
int pt,dpg; /* position testée,dernier plus grand */

ligne tampon;
for(pt=1;pt<N;pt++)
{
dpg=pt-1;
tampon=tab[pt];
while(strcmp(tab[dpg],tampon)>0 && dpg>=0)
{tab[dpg+1]=tab[dpg];dpg--;}
tab[dpg+1]=tampon;
}
}
void main(void)
{
int nbl;
mat_ttd txt;
lecture(&txt,&nbl);
puts("avant tri :");
affiche(txt,nbl);
tri_insertion(txt,nbl);
puts("après tri :");
affiche(txt,nbl);
}


A,B,C,D,E,F,G,I,L,M,N,O,P,Q,R,S,
T,U,V,W
A
● accès
● direct [1]
[2]
❍ séquentiel [1] [2]
● arbre [1]
● binaire [1]
[2]
● argument [1]
B
● bande [1] [2]
● binaire [1]
● bit [1]
● boucles [1]
C
● index du langage C
● chiffres significatifs [1]
● clef [1] [2]
http://www-ipst.u-strasbg.fr/pat/program/algofi.htm (1 of 6) [21-11-2001 17:43:08]

D
● débogage [1]
● décalage [1]
● décalages [1]
● défiler [1]
● dépiler [1]
● define [1]
● deuxaire [1]
● dichotomie [1] [2]
[3]
● dimension [1] [2]
● do-while [1]
● dynamique [1] [2]
[3] [4]
E
● effet de bord [1]
● empiler [1]
● encombrement [1]
● enfiler [1]
F
● feuille [1]
● fichier [1]
● FIFO [1]
● file [1]
● fils [1]
● float [1]
● for [1]
● free [1]

G
● Gauss [1] [2]
● graphe [1]
I
● index [1]
● indexation [1]
● infixé [1] [2]
● insertion [1] [2]
[3] [4] [5]
● interpolation [1]
L
● Lagrange [1]
● largeur de bande [1]
● LIFO [1]
● ligne de ciel [1] [2]
● liste [1] [2]
[3]
M
● malloc [1]
● mathématiques [1] [2]
[3] [4]
● matrice [1] [2]
[3]
❍ triangulée [1]
● modèle [1]

N
● noeud [1]
● notation polonaise [1]
● NULL [1] [2]
[3]
O
● objets [1]
● optimisation [1]
P
● parcours [1] [2]
[3]
● pile [1] [2]
[3]
● pivot [1]
● de Gauss [1]
● pointeur [1] [2]
[3]
● polynôme [1] [2]
● postfixé [1] [2]
● préfixé [1] [2]
Q
● queue [1]
● Quick Sort [1]
R
● récursif [1]
● récursivité [1] [2]

[3]
● racine [1]
● recherche [1] [2]
● retassage [1]
S
● séquentiel [1] [2]
● sentinelle [1]
● spline [1]
● stable [1]
● (tri) [1]
● stack [1]
● strcmp [1]
● structuré [1]
● suites [1]
● super-tableau [1] [2]
● suppression [1] [2]
[3]
T
● tableau [1] [2]
[3] [4] [5] [6] [7]
❍ dynamique [1]
❍ multidimensionnel [1]
❍ statique [1]
● ternaire [1]
● tri [1]
❍ bulle [1] [2]
● tri par
● arbre [1]
❍ comptage [1]
❍ création [1] [2] [3]

❍ fusion [1] [2]

❍ insertion [1] [2] [3]
❍ sélection [1] [2]
● rapide [1] [2]
● shell [1] [2]
● triangulation [1] [2]
● typedef [1]
U
● unaire [1]
V
● vecteur [1]
● virgule flottante [1]
W
● while [1]


● INTRODUCTION
❍ codage binaire
❍ boucles
❍ récursivité
❍ tableaux unidimensionnels
■ généralités
■ fonctions de base (fichier inclus base_tus)
■ manipulations dans les tableaux (mani_tus)
■ tris
■ le tri bulle
■ le tri shell
■ d'autres tris
■ recherches
■ la dichotomie
■ calculs mathématiques
■ polynômes
❍ tableaux multidimensionnels
❍ conclusions
http://www-ipst.u-strasbg.fr/pat/program/algofc.htm (1 of 3) [21-11-2001 17:43:13]

❍ tableaux unidimensionnels en C
❍ la méthode du super-tableau
❍ les tableaux multidimensionnels
■ matrices pleines (matrices rectangulaires dynamiques : mrd)
■ tableaux de tableaux dynamiques
❍ conclusions
● LES LISTES
❍ fonctions de base et manipulations (base_lst)
❍ les tris
■ le tri bulle
■ les autres tris
❍ problèmes mathématiques
❍ conclusions
❍ définition
❍ utilisations
● LES ARBRES
❍ introduction
❍ expressions arithmétiques (arb_expr)
❍ listes triées
● LES GRAPHES
● LES FICHIERS
❍ les fichiers à accès direct
❍ l'indexation
❍ BOUCLE
❍ TUSEXO_A

❍ TUSEXO_B
❍ GAUSS_MRD
❍ INSE_TTD
● recherche dans l'index de mon document sur le langage C

Langage C - Sommaire
❍ Organisation de l'ordinateur
❍ Langages de programmation
● La syntaxe du C
❍ Second exemple, définitions
❍ Variables / identificateurs / adresse / pointeurs
❍ Expressions / opérateurs
■ Arithmétiques
■ unaires
■ deuxaires
■ Relationnels
■ comparaisons
■ logique booléenne
■ binaires
■ Affectation
■ affectation simple =
■ incrémentation / décrémentation
■ affectation élargie
■ Opérateurs d'adresses
■ Autres
■ conditionnel ? :
■ séquentiel ,
■ Ordre de priorité et associativité
❍ Instructions
❍ Structures de contrôle
■ Boucles
http://www-ipst.u-strasbg.fr/pat/program/tpcfc.htm (1 of 3) [21-11-2001 17:43:18]

■ While (tant que)

■ Do While (faire tant que)
■ For (pour)
■ Branchements conditionnels
■ If - Else (Si - Sinon)
■ Switch - Case (brancher - dans le cas)
■ Branchements inconditionnels
■ Break (interrompre)
■ Continue (continuer)
■ Goto (aller à)
■ Return (retourner)
■ Exit (sortir)
❍ Déclaration et stockage des variables
■ Déclarations locales
■ Déclarations globales
■ Déclaration de type
❍ Fonctions
■ Définitions générales
■ Récursivité, gestion de la pile
■ Arguments passés par adresse
■ La fonction main
■ Fonction retournant un pointeur et pointeur de fonction
❍ Les types de données du C
■ Variables scalaires
■ char : caractère (8 bits)
■ int : entier
■ float : réel
■ Tailles et plages
■ Conversions de type / cast
■ Enumérations
❍ Tableaux
■ Tableaux unidimensionnels
■ Tableaux et pointeurs / arithmétique des pointeurs

■ Chaînes de caractères
■ Bibliothèques de fonctions pour tableaux et chaînes
■ Allocation dynamique de mémoire
■ Tableaux multidimensionnels
❍ Structures et unions
■ Déclaration
■ Utilisation
■ Champs de bits
■ Unions
■ Structures chaînées
❍ Fichiers bruts
❍ Fichiers bufférisés

Langage C
Langage C - Langage C
Sommaire Le Langage C
Aujourd'hui, l'informatique est présente dans tous les
domaines de la vie courante, mais à des degrés différents. Il
❍ Organisation de l'ordinateur y a pour cela trois grandes raisons :
❍ Langages de - les gains (en temps, argent, qualité) que l'informatique peut
programmation apporter,
- le prix abordable des matériels,
● Fonctions d'entrées/sorties les plus
utilisées - la disponibilité de logiciels dans tous les domaines.
● La syntaxe du C Deux domaines sont pleinement exploités :

❍ Second exemple, - les logiciels généraux, vendus en grande série, et donc
définitions relativement bon marché,
❍ Variables / identificateurs / - les logiciels spécifiques, d'un coût total important et donc
adresse / pointeurs limités à des sujets très pointus, pour de très grosses
❍ Expressions / opérateurs industries.
■ Arithmétiques Le domaine intermédiaire, qui peut encore se développer,
■ unaires concerne les programmes spécifiques, pour des applications
de moindre importance. Pour cela, il est nécessaire de
■ deuxaires disposer de langages de programmation. Les tableurs et
■ Relationnels bases de données par exemple disposent désormais de
véritables langages de programmation (souvent orientés
■ comparaisons
objets) qui vont plus loin que les précédents langages de
■ logique macro-commandes. Pour les autres cas, le C est souvent le
booléenne meilleur choix. En effet, c'est un langage structuré, avec
■ binaires toutes les possibilités des autres langages structurés. Mais il
permet également (avec son extension C++) de gérer des
■ Affectation objets. A l'inverse, il permet également une programmation
■ affectation proche du langage machine, ce qui est nécessaire pour
simple = accéder aux interfaces entre l'ordinateur et son extérieur.
Mais son principal avantage est que ces trois types de
■ incrémentation programmation peuvent être combinés dans un même
/ programme, tout en restant portable sur tous les ordinateurs
décrémentation existants. Le langage C a néanmoins deux inconvénients
■ affectation majeurs, c'est d'être un peu plus complexe d'utilisation (mais
uniquement du fait de ses nombreuses possibilités), et d'être
http://www-ipst.u-strasbg.fr/pat/program/tpc.htm (1 of 4) [21-11-2001 17:43:29]

Langage C
élargie séquentiel, ce qui ne lui permettra pas d'être le langage

■ Opérateurs d'adresses optimal pour les machines massivement parallèles (mais
aujourd'hui il n'existe pas encore de langage universel pour
■ Autres ce type de machines qui puisse combiner efficacement des
■ conditionnel ? calculs procéduraux et du déclaratif).
: Ceci est la première partie du livre "Programmation en C,
■ séquentiel , langage et algorithmes", qui est composé de trois parties.
■ Ordre de priorité et * La première définit le langage C, avec de nombreux
associativité exemples directement dans le texte, et certains
❍ Instructions supplémentaires en annexe.
❍ Structures de contrôle * La seconde partie traite des structures de données et des
■ Boucles algorithmes. Elle n'est pas spécifique, seuls les exemples
sont en C, le texte et les algorithmes restent utilisables dans
■ While (tant tout langage séquentiel. Les fonctionnalités du C non
que) disponibles dans d'autres langages sont analysées, le
■ Do While méthodes utilisées pour parvenir au même résultat sont
(faire tant que) précisées (par exemple, gestion d'un liste dynamique à l'aide
d'un tableau).
■ For (pour)
* La troisième partie quand à elle traite des algorithmes
■ Branchements
d'infographie. Elle est importante du fait de la nécessité du
conditionnels graphisme dans les programmes. Mais elle détaille
■ If - Else (Si - également, pour ces cas pratiques, les méthodes et moyens
Sinon) utilisés pour optimiser des algorithmes. Une bibliothèque
graphique est fournie en annexe.
■ Switch - Case
(brancher - * Les parties que j'ai prévues, mais pas encore rédigées :
dans le cas) utilisation des objets C++, programmation graphique
évennementielle (Microsoft Windows, X-Windows)
■ Branchements
inconditionnels
■ Break ● Introduction (première partie)
(interrompre) ● Connaissances de base
■ Continue ● Fonctions d'entrées/sorties les plus utilisées
(continuer) ● La syntaxe du C
■ Goto (aller à) ● Les fichiers de données
■ Return ● Directives du pré-compilateur
(retourner) ● Utiliser Turbo C (3.5 par exemple)
■ Exit (sortir) ● Correction des exercices
❍ Déclaration et stockage des ● Autres sites sur le C
variables
● Sommaire

Langage C
❍ Fonctions
■ Récursivité, gestion
de la pile
■ Arguments passés
par adresse
■ Fonction retournant
un pointeur et
pointeur de fonction
■ char : caractère
(8 bits)
■ int : entier
■ float : réel
■ Tailles et
plages
■ Conversions
de type / cast
■ Enumérations
❍ Tableaux
■ Tableaux
unidimensionnels
■ Tableaux et pointeurs
/ arithmétique des
pointeurs
■ Bibliothèques de
fonctions pour
tableaux et chaînes
■ Allocation
dynamique de
mémoire

Langage C
■ Tableaux
multidimensionnels
■ Déclaration
■ Utilisation
■ Champs de bits
■ Unions
❍ Fichiers bruts
● Utiliser Turbo C (3.5 par
exemple)

Infographie
Sommaire Infographie
Infographie
● JUSTIFICATION
● JUSTIFICATION ● BIBLIOTHEQUE GRAPHIQUE DE BASE
● BIBLIOTHEQUE ● TRANSFORMATIONS MATRICIELLES
GRAPHIQUE DE BASE
● PROJECTIONS 3D
❍ tracés simples
● ELIMINATION LIGNES / SURFACES CACHEES
■ matériel existant
● COURBES ET SURFACES
■ fonctions
● ANNEXE : DOCUMENTATION DE LA BIBLIOTHEQUE
élémentaires
GRAPHIQUE
❍ représentation d'une droite
● télécharger la disquette d'accompagnement
(en mode point ou sur
table traçante) ● Sommaire détaillé
❍ autres courbes Vous trouverez ici un cours sur l'infographie (c'est à dire, ici, les
■ par tâtonnements algorithmes pour faire du graphique). On débute par les tracés les
plus simples (le pixel, la ligne) pour les matériels de base, on passe
■ approximation par
aux cas plus complesxes, progressivement pour aborder le 3D, les
la tangente surfaces complexes... Les algorithmes sont expliqués en clair, les
■ formulation exemples pratiques sont en C. Une bibliothèque graphique (en C) est
paramétrique accessible en téléchargement (gratuit).
❍ remplissages / hachurages Autres liens : Paul Bourke (en anglais)
■ remplissage d'une
frontière déjà tracée
■ frontière totalement
définie
❍ les échelles
■ fenêtre objet et
fenêtre papier
■ clipping
❍ intersections
■ droite - droite
■ droite - cercle /
cercle - cercle
❍ contraintes
❍ Conclusion
http://www-ipst.u-strasbg.fr/pat/program/infogr.htm (1 of 5) [21-11-2001 17:43:40]

Infographie
● TRANSFORMATIONS
MATRICIELLES
❍ représentation de
fonctions planes par
matrices 2x2
❍ matrices 3x3
(coordonnées homogènes
2D)
❍ transformations 3D
● PROJECTIONS 3D
❍ parallèle
❍ perspective
■ méthodes
■ méthode
vectorielle :
■ méthode
matricielle :
■ clipping
■ points particuliers
● ELIMINATION LIGNES /
SURFACES CACHEES
❍ lignes cachées
❍ faces cachées
■ surfaces orientées
■ algorithme du
peintre
■ calculs de facettes
■ élimination des
arrêtes cachées
■ tubes de projection
■ plans de balayage
■ rayons de
projection
■ éclairage de
surfaces
❍ problème des surfaces
gauches
● COURBES ET SURFACES

Infographie
❍ introduction
❍ courbes
■ représentation des
points
■ polynômes de
Lagrange
■ splines
■ courbes de Bezier
■ conditions
■ détermination
des
polynômes
de Bezier
■ forme
polynomiale
■ intérêt
■ exemples
❍ surfaces
■ Coons
■ surfaces de Bezier
● ANNEXE :
DOCUMENTATION DE LA
BIBLIOTHEQUE
GRAPHIQUE
❍ G2D Librairie graphique
de base en C
■ Préliminaire
■ Passage en mode
graphique
■ Les fenêtres
■ Les échelles
■ Attributs de tracé
■ Tracés de base
■ Table traçante
■ Autres
bibliothèques
■ Exemple :
❍ bibliothèque GECR

Infographie
❍ remplissage - hachurage
de polygones (GPOLY)
❍ remplissage suivant
l'écran (GREMPL)
❍ bibliothèque GPLUS
❍ bibliothèque
tridimensionnelle
■ G3D
■ précisions sur le
mode G34VUES
■ G3ECR
■ G3POLY
■ Vecteurs
■ OBJets à lier à
votre EXEcutable
■ EXEMPLE G3D
❍ SOURIS : utilisation de la
souris sous G2D
■ types utilisés
■ fonctions d'usage
courant
■ forme du curseur
■ fonctions de bas
niveau
■ exemple
❍ Bibliothèque MENUG
■ Descriptif général
■ Description
détaillée
■ Détails
pratiques
■ Menus
■ lectures
(clavier ou
souris)
■ référence
■ Constante
prédéfinie

Infographie
■ Variable
globale
prédéfinie
■ Types
prédéfinis
■ Gestion du
mode MENU
■ Fonctions
principales
■ Ecritures
dans la
fenêtre menu
■ Lectures
(clavier ou
souris)
■ Ecrire dans la
fenetre de
gauche (58
caractères, 25
lignes)
■ Exemple complet
■ télécharger la
disquette
d'accompagement

Disquette d'accompagnement - P. TRAU
télécharger la Disquette
d'accompagnement - P. TRAU
● CONTENU DE LA DISQUETTE D'ACCOMPAGNEMENT
❍ correction des exercices de la première partie
❍ exemples pour la première partie
❍ correction des exercices de la seconde partie
❍ exemples pour la seconde partie
❍ exemples pour la troisième partie
❍ Bibliothèque graphique
● TELECHARGER CES DOCUMENTS
sommaire documents programmation
CONTENU DE LA DISQUETTE
D'ACCOMPAGNEMENT
Cedocument contient la liste des fichiers disponibles sur la disquette d'accompagnement.
Ils sont regroupés par répertoires
correction des exercices de la première partie

noms des fichiers (répertoire exercices.c). Le listing complet est donné en annexe 1.
1 while_puiss WH_PUISS.C
2 while_err WH_ERR.C
3 do_while DO_WHILE.C
4 for FOR.C
5 jeu JEU.C
6 calcul CALCUL.C
7 moyenne MOYENNE.C
8 rotation ROTATION.C
9 classer CLASSER.C
http://www-ipst.u-strasbg.fr/pat/program/disk-acc.htm (1 of 6) [21-11-2001 17:43:49]

10 chaîne CHAINES.C
11 matrices MATRICES.C
12 determinant DETERMIN.C
13 tel TEL.C
14 liste & insertion LISTE_CH.C
15 agenda AGENDA.C
exemples pour la première partie

L'intérêt de ces fichiers est qu'il contiennent la fonction décrite en exemple mais aussi une fonction main
qui l'utilise, ainsi que quelques exemples supplémentaires. (répertoire exemples.c)
PREM_EX.C premier petit programme du chapitre 2
SECONDEX.C programme du chapitre 4.1
WHILE.C exemple de boucle while
WH_ERR.C source du programme "while_err" dont on doit expliquer la fonction
FACTORIE.C calcul de factorielle par boucle for et par récursivité
FONCT_PT.C exemple de fonction retournant un pointeur
ENUM.C utilisation des énumérations
TABLO_PT équivalence d'écriture entre tableau et pointeur
quatre méthodes différentes pour stocker un tableau multidimensionnel en mémoire
MULTIDIM.C
(matrice statique, tableau unidimensionnel, tableau de lignes, pointeurs de pointeurs)
arguments de la fonction main (un programme à mettre dans AUTOEXEC.BAT pour
ARG_MAIN.C
initialiser les couleurs de l'écran)
FIC_BRUT.C utilisation de fichiers bruts (accès par blocs de taille constante)
correction des exercices de la seconde partie

Le listing est donné en annexe 2 (répertoire exercices.a)
BOUCLE.C exercice du paragraphe 9.2
TUSEXO_A.C exercice du paragraphe 10.1.2
TUSEXO_B.C exercice du paragraphe 10.1.3
exercice du paragraphe 11.3.1. Il montre une application des matrices rectangulaires
GAUS_MRD.C
dynamiques.
exercice du paragraphe 11.3.2. C'est également un exemple d'utilisation d'un stockage
INSE_TTD.C
dynamique pour une grande matrice.

exemples pour la seconde partie

exemples donnés dans le document. En particulier les fichiers inclus contenant les manipulations de base
sur les types de données sont regroupés (.INC). Les différentes fonctions données dans le document (tris
par exemple) sont accompagnés d'une fonction main permettant de les utiliser directement. Certains
exemples supplémentaires présents sur la disquette ne sont pas listés dans le document par manque de
place (répertoire exemples.a)
FLOTTANT.C exemple du paragraphe 9.1
BOUCLE_A.C, BOUCLE_B.C exemples du paragraphe 9.2
fonctions de base pour les tableaux unidimensionnels statiques
BASE_TUS.INC
(paragraphe 10.1.2)
EX_TUS.C exemple du paragraphe 10.1.2
fonctions de manipulation des tableaux unidimensionnels statiques
MANI_TUS.INC
(paragraphe 10.1.3)
implantation d'un tri bulle pour les tableaux unidimensionnels statiques
BULL_TUS.C
(paragraphe 10.1.4.2)
implantation d'un tri par insertion pour les tableaux unidimensionnels
INSE_TUS.C statiques (paragraphe 10.1.4.3). Les deux implantations (simple et
optimisée) sont prévues.
implantation d'un tri par sélection pour les tableaux unidimensionnels
SELE_TUS.C
statiques (paragraphe 10.1.4.4)
implantation d'un tri shell pour les tableaux unidimensionnels statiques
SHEL_TUS.C
(paragraphe 10.1.4.5)
implantation d'un tri rapide (Quick Sort) pour les tableaux
QUIC_TUS.C
unidimensionnels statiques (paragraphe 10.1.4.6)
implantation d'un tri par création pour les tableaux unidimensionnels
CREA_TUS.C
statiques (paragraphe 10.1.4.7)
fonctions de base pour la gestion des matrices statiques (paragraphe
BASE_MAT.INC
10.2)
résolution matricielle de AX=B avec triangulation simpliste ou
GAUSS.C
améliorée (paragraphe 10.2)
BASE_LST.INC fonctions de base sur les listes chaînées (paragraphe 12.1)
TEST_LST.C test des fonctions de listes chaînées (paragraphe 12.1)
BULL_LST.C implantation d'un tri bulle dans une liste chaînée (paragraphe 12.2.1)
INSE_LST.C implantation d'un tri insertion dans une liste chaînée (paragraphe 12.2.2)
implantation d'un tri par sélection dans une liste chaînée (paragraphe
SELE_LST.C
12.2.3)
fonctions de base pour l'implantation de piles par tableaux statiques
BASE_P_T.INC
(paragraphe 13.2).
fonctions de base pour l'implantation de piles par listes chaînées
BASE_P_L.INC
(paragraphe 13.2).

fonctions de base pour l'implantation de files par tableaux statiques

BASE_F_T.INC
(paragraphe 13.2).
exemple de mise en oeuvre d'une pile pour évaluer une expression en
POLONAIS.C
notation polonaise (paragraphe 13.3)
représentation d'une expression mathématique sous forme d'un arbre
ARB_EXPR.C
(paragraphe 14.2)
ARB_NOMS.C gestion d'une liste de noms à l'aide d'un arbre binaire (paragraphe 14.3)
exemples pour la troisième partie

répertoire exemples.g :
BIB_BASE.INC une bibliothèque de base sous TURBO C++ (initialisation, allumer un point)
G_LIGNE.INC mise en oeuvre d'un tracé de droite quelconque en n'utilisant que BIB_BASE
test du tracé d'arc de cercle par la méthode de la dérivée, comparaison avec la méthode
CERCLES.C
paramétrique (sinus, cosinus)
remplissage d'une courbe fermée par un algorithme récursif. On voit (car c'est lent)
REMPLIR.C
l'ordre des appels récursifs par un remplissage qui semble désordonné
exemple de tracé de surface avec élimination de lignes cachées par la méthode de la
CRETE.C
ligne de crête (nécessite la bibliothèque graphique G2D)
PARALLEL.C projection parallèle : vue d'un cube dans toutes les positions
programme permettant de tester l'interpolation de Lagrange (nécessite G2D et une
LAGRANGE.C
souris compatible).
BEZIER.C programme de tracé de courbes de Bezier
Bibliothèque graphique
répertoire bib_graph :
Fichiers inclus :
Vous devez inclure les fichiers dont vous avez besoin dans votre fichier source. Il est inutile d'inclure les
fichiers qui ne vous servent pas directement.
G2D.H Bibliothèque graphique de base
Définition du type CARACT qui définit un caractère. Ceci est nécessaire car en TURBO
CHAR.H C les caractères sont définis autrement que par un char (unsigned char). Si vous utilisez
un autre compilateur il suffit de modifier ce fichier.
CHAINES.H Fonctions de base traitement de caractères
VECTEURS.H onctions de base de traitement de vecteurs (produit scalaire, vectoriel...) utilisé par G3D.
GECR.H Fonctions d'écriture
GPOLY.H Tracé, remplissage et hachurage de polygones fermés
GREMPL.H Remplissage d'une courbe déjà tracée à l'écran

GPLUS.H Quelques fonctions supplémentaires à G2D

G3D.H Bibliothèque de base 3D
G3ECR.H Ecritures (2D) mais débutant en un point défini en 3D
Tracé, remplissage et hachurage de polygones définis en 3D. Attention, le remplissage
G3POLY.H se fait sur la projection du polygone, donc peut poser des problèmes si la surface est
"trop gauche".
SOURIS.H Utilisation d'une souris pour entrer des coordonnées 2D à votre échelle.
MENUG.H Fonctions de menus
Fichiers sources à compiler et lier à vos programmes objets. Il faut lier les fichiers dont vous vous servez
explicitement mais également indirectement (par exemple si vous avez inclus dans votre programme
G3ECR.H, il faut lier votre programme à G3ECR.C mais aussi à GECR.C puisqu'il utilise ce dernier (par
contre il était inutile d'inclure GECR.H dans votre programme si vous ne vous en servez pas
directement).
G2D.C Bibliothèque graphique de base
CHAINES.C Fonctions de base traitement de caractères
Fonctions de base de traitement de vecteurs (produit scalaire, vectoriel...) utilisé par
VECTEURS.C
G3D.
Fonctions d'écriture. Implantation standard : tous les graphismes des 255 caractères d'un
PC y sont définis, un caractère sera donc dessiné à l'aide d'un ensemble de segments.
GECR_STD.C
Ceci prend pas mal de place en mémoire et est assez lent mais marchera partout (si la
couche 0 de G2D est bien définie).
Fonctions d'écriture. Implantation spécifique au TURBO C : On utilise les fonctions
existantes sur le PC pour écrire. Ceci prend moins de place et va plus vite, mais on ne
GECR_ECR.C peut pas modifier la taille des caractères, ni leur inclinaison, ni faire d'écritures sur une
table traçante. Si vous avez inclus GECR.H dans votre programme, il faudra soit lui lier
GECR_ECR.C, soit GECR_STD.C.
GPOLY.C Tracé, remplissage et hachurage de polygones fermés
GREMPL.C Remplissage d'une courbe déjà tracée à l'écran
GPLUS.C Quelques fonctions supplémentaires à G2D
G3D.C Bibliothèque de base 3D
Ecritures (2D) mais débutant en un point défini en 3D. Utilise les écritures en 2D, donc
G3ECR.C
GECR_ECR ou GECR_STD.
Tracé, remplissage et hachurage de polygones définis en 3D. Attention, le remplissage se
G3POLY.C fait sur la projection du polygone, donc peut poser des problèmes si la surface est "trop
gauche".
SOURIS.C Utilisation d'une souris pour entrer des coordonnées 2D à votre échelle.
Fonctions de menus. Ceci est donné en exemple, cette bibliothèque mérite d'être
MENUG.C
complètement modifiée (en particulier en utilisation Windows)
Exemples de programmes utilisant les différentes bibliothèques :

TST2D.C test de pratiquement toutes les fonctions de G2D

Démonstration des possibilités d'écriture. On pourra comparer les résultats obtenus en

TSTECR.C
liant GECR_STD (plus de possibilités mais lent) ou GECR_ECR (rapide mais limité)
TSTPOLY.C Démonstration de remplissage / hachurage de polygones convexes ou non
TSTREMPL.C Test des fonctions de remplissage (frontière tracée auparavant)
TST3D.C Fonctions 3D : On peut regarder un cube sous toutes ses faces
TST3POLY.C Démonstration de polygones 3D
TSTSOURI.C Utilisation des fonctions de base utilisant la souris
TSTMENU.C Démonstration de quelques possibilités de la bibliothèque de menus
TELECHARGER CES DOCUMENTS

c'est facile, il suffit de cliquer ici (transfert par FTP, le fichier est compressé en .ZIP).
Vous pouvez également télécherger de la même manière la bibliothèque graphique en PASCAL (sources,
documentation et programmes d'exemples). Cette version est un peu plus ancienne que celle en C, mais
reste presque similaire (mêmes noms de procédures et fonctions, mêmes arguments)

Introduction C++ - P. Trau
P. Trau ULP-IPST 24/2/97
Introduction au C++
On trouvera un document complet sur www.mis.enac.fr/~dancel ou www.mygale.org/~dancel
Si la couleur de ce document ne vous plait pas, cliquez ici.
Table des matières

1) INTRODUCTION
❍ a) qu'est-ce qu'un objet ?
❍ b) pourquoi un L.O.O. ?
❍ c) avantages - inconvénients ?
❍ d) Pourquoi C++ ?
2) PREMIÈRES SPÉCIFICITÉS C++

❍ a) commentaires
❍ b) entrées-sorties (flux)
❍ c) mot clef const
❍ d) passage d'arguments par adresse
❍ e) arguments par défaut
❍ f) résolution de portée
3) VOCABULAIRE
❍ a) la classe
❍ b) l'instance
❍ c) l'héritage
❍ d) la surcharge
❍ e) le constructeur
4)APPLICATIONS
❍ a)simple
❍ b) accès aux membres d'une classe
❍ c) héritage
❍ d) new, delete
❍ e) surcharge d'un opérateur
❍ f) classes virtuelles
❍ g) polymorphisme
5) EXEMPLE COMPLET (COMMENTÉ)
http://www-ipst.u-strasbg.fr/pat/program/cpp.htm (1 of 11) [21-11-2001 17:44:08]

le C++
Introduction pour qui connaît le C
Cette page n'est pas destinée au débutant. Je suppose que le lecteur connait bien le C standard (ANSI). Sinon, vous pouvez
d'abord voir mon cours C complet. Pour un problème précis, allez directement à son index.
1) INTRODUCTION
Le C++ est LA solution pour passer aux L.O.O. (langages orientés objet) sans trop de problèmes.
a) qu'est-ce qu'un objet ?

une STRUCTure regroupant des données et les fonctions pour les manipuler.
b) pourquoi un L.O.O. ?
Le passage de l'assembleur aux langages structurés a permis d'obtenir des programmes maintenables : on peut les
comprendre, les modifier, les améliorer : on a une structure de programme claire. Par contre si l'on décide de modifier la
structure des données importantes (par exemple remplacer le tableau des données par une liste chaînée), il fallait réécrire
tout le programme. Les objets structurent les données : en changeant la structure d'un objet, il suffit de modifier ses
"méthodes" pour que la transformation s'applique à tout le programme. La programmation est plus simple, les méthodes
(fonctions en C) sont classées par types de données plutôt que séquentiellement. De plus elles sont organisées
hiérarchiquement (arborescence=bidimensionnel plutôt que séquentiel=linéaire).
c) avantages - inconvénients ?
● Programmes plus faciles à écrire et à maintenir. Modification aisée, y compris des types de données. Modularité
accrue (un objet bien défini reservira dans de nombreux programmes)
● Programme résultant (exécutable) un peu moins efficace (plus gros et moins rapide, mais aujourd'hui le prix de la
vitesse et de la mémoire est inférieur au coût d'une optimisation de programme, on n'écrit plus grand chose en
assembleur).
d) Pourquoi C++ ?
C++ est sûrement un mauvais L.O.O. (du point de vue de l'informaticien puriste), par contre il permet de garder tous les
avantages du C : portable, possibilité d'utiliser différents niveaux d'optimisation au sein d'un même programme (objets -
langage structuré classique - assembleur). Il permet de passer en douceur aux objets, mais surtout de garder et réutiliser
toutes les bibliothèques existantes. Bien que plus strict que C, il acceptera à peu près tout, donc sera avare en messages
d'erreur de compilation. C'est le programmeur qui doit se forcer à programmer "objets", s'il ne le fait pas le compilateur ne
le prévient même pas. Comme vous le verrez ici, le passage aux objets (si l'on connaît déjà C) est très simple.

2) PREMIERES SPECIFICITES C++

a) commentaires
Les commentaires /* ... */ restent possibles, on y a ajouté les commentaires commençant par // et se finissant à la fin de la
ligne.
b) entrées-sorties (flux)
à condition d'inclure <iostream.h> (et donc pas <stdio.h>), on peut utiliser cout (pour afficher à l'écran) et cin (pour lire
sur le clavier). Exemple :
float P; int Nb;
cout << "prix unitaire ? ";
cin >> P;
cout << "Nombre ? ";
cin >> Nb;
cout.precision(2); //manipulateur (fonction membre)de cout : tous les
//flottants QUI SUIVENT seront affichés avec
// 2 chiffres après la virgule
cout << "prix total : " << P*Nb << "F \n";
L'avantage de ces fonctions est qu'elles peuvent être plus facilement surchargées que printf et scanf (par exemple étendues
aux tableaux). Les flux fstream possèdent les mêmes fonctionnalités pour les fichiers (je ne détaille pas).
c) mot clef const

const type var=valeur;
contrairement au #define, permet une analyse syntaxique (on garde les define pour les "réécritures" et compilations
conditionnelles).
d) passage d'arguments par adresse

il suffit d'ajouter le signe & dans l'entête de la fonction (qui doit être prototypée avant toute utilisation). Ceci évite
l'écriture "pointeur" tant pour les arguments réels que formels :
void echange(int &a, int &b) {int z=a;a=b;b=z;}
int X,Y;echange(X,Y);
e) arguments par défaut

On peut déclarer des valeurs par défaut des arguments d'une fonction (uniquement dans le prototype, pas dans l'entête).
Les arguments réels peuvent être omis en commençant par le dernier (impossible d'omettre les premiers si l'on veut
préciser un suivant).
f) résolution de portée
Si vous disposez de deux (ou plus) entités (donnée ou méthode) de même nom, en C standard seule la plus locale est
accessible. ou::nom permet en C++ de préciser de quel nom on parle (en général ou correspond à une classe, ::nom

pour accéder à une variable globale).
3) VOCABULAIRE
a) la classe
Une classe est un regroupement de données et de méthodes. C'est donc une extension des STRUCT du C :
class MaClasse {déclaration données et méthodes } MonInstance;
Ne pas oublier le ; final même quand on ne déclare pas d'instance ici (en général les classes sont globales, les variables
devraient plutôt être locales). En fait les mots clef struct et union permettent également la déclaration de méthodes en plus
de données, simplement elles sont par défaut publiques (public) (accessibles aux autres classes) alors que pour une classe
elles sont par défaut privées (private).
b) l'instance
On utilisera le terme "instanciation" à chaque création d'une instance (ce qu'on appelait avant une variable). L'adresse de
l'instance actuelle est appelée "this" (sans avoir à la déclarer).
c) l'héritage
les classes sont structurées de manière arborescente. Si l'on crée une classe d'objets A (dite classe de base), on peut créer
une classe B qui "dérive" de A : elle en hérite toutes les composantes (données et méthodes). On peut, à partir de C++
version 2, utiliser l'héritage multiple (une classe hérite de plusieurs classes de base), alors que ce n'était pas possible avant.
d) la surcharge
On peut décrire plusieurs méthodes de même nom, à condition que chacune s'applique à des types de données différents.
Par exemple on peut définir int puissance(int,int) et float puissance(float,float), les deux
fonctions ayant une implémentation différente suivant le type de données, c'est le compilateur qui choisira en fonction des
types des arguments. On peut même surcharger les opérateurs classiques du C (redéfinir + pour les vecteurs par exemple).
On ne peut pas surcharger deux fonctions ayant exactement les mêmes types d'arguments mais retournant un type différent
(produits scalaire et vectoriel par exemple)
e) le constructeur
Pour chaque classe, il existe une méthode nécessaire (mais non obligatoire, si on ne la définit pas le compilateur en crée
une par défaut) : le constructeur. Son nom est toujours le même que celui de la classe. Il est appelé implicitement à chaque
nouvelle création d'instance ou explicitement par la fonction new (correspond au malloc, mais c'est le compilateur qui
détermine la taille nécessaire). Le constructeur est une fonction qui ne retourne rien (même pas void). Le destructeur est
appelé implicitement à la destruction d'un objet ou explicitement par delete. Remarque : le constructeur peut affecter une
valeur à un membre constant (mais qui ne pourra pas changer jusqu'à sa destruction).

4)APPLICATIONS
a)simple
class Point
{
int X;intY; //les données
int GetX(void) {return X;} // déclaration "interne" ou "inline"
int GetY(void); // déclaration externe
Point (int NewX=0, int NewY=0) {X=NewX;Y=NewY;} //déclaration
//interne du constructeur, avec initialisation par défaut
};
int Point::GetY(void)
{return Y;} //déclaration "externe", il faut préciser
//à quelle classe elle se rapporte ici POINT.
//dans la réalité j'aurai plutot utilisé une déclaration interne
si je déclare :
Point P(5,10); //appel automatique du constructeur à ladéclaration
int coordX;
je peux par exemple appeler la fonction (attention, pas n'importe où, voir paragraphe suivant) :
coordX=P.GetX();
b) accès aux membres d'une classe

les membres d'une classe peuvent être
● privés (private), c'est à dire accessible uniquement aux autres membres de cette classe;
● protégés (protected), c'est à dire accessibles au membres de la classe et des classes dérivées;
● publics (public), c'est à dire accessibles "classiquement" : même portée qu'une déclaration classique C
Exemple :
class Point
{
int X;intY; //privé par défaut
public : // tout ce qui suit est public
int GetX(void) {return X;} // ceci permet d'accéder aux
//infos sans savoir comment elles ont été stockées
int GetY(void) {return Y;}
Point (int NewX, int NewY) {X=NewX;Y=NewY;}
};
On peut utiliser les 3 accès, autant de fois que l'on veut et dans n'importe que ordre. L'accès qui s'applique est le dernier
spécifié (ou celui par défaut, private pour class et public pour struct).
c) héritage
class Point
{
protected: //accessible uniquement par héritage

int X;intY;
public : // accessible partout
int GetX(void) {return X;}
Point (int NewX=0, intNewY=0) {X=NewX;Y=NewY;}
};
class Pixel : public Point //dérive de point,
{
protected:
int couleur;
public :
Pixel (int nx,int ny,int coul=0);
void allume(void);
void allume(int couleur); //surcharge : on peut allumer avec une autre couleur
void eteind(void);
};
Les accès dérivés sont le plus restrictif entre celui défini dans la classe de base et celui précisé lors de la dérivation (ici
dérivation publique, les accès restent inchangés sauf pour les privés qui sont inaccessibles).
Pixel::Pixel(int nx,int ny,int coul):Point(nx,ny) // je précise la
//liste (séparée par des virgules) des constructeurs
//(sinon val par défaut), je n'ai plus qu'à construire les
//ajouts par rapport à la classe de base
{couleur=coul;}
void Pixel::allume(void)
{g_pixel(X,Y,couleur);} //g_pixel : une fonction qui allume un pixel à l'écran
void Pixel::allume(int coul)
{g_pixel(X,Y,couleur=coul);}
void Pixel::eteind(void)
{allume(0);}
On pourrait maintenant définir une classe segment contenant un pixel et un point (la couleur n'a besoin d'être stockée
qu'une fois). On redéfinirait des méthodes de même nom : Segment::allume...
d) new, delete
Pixel *ptrPixel = new Pixel(100,100,1); // construction explicite
ptrPixel->allume(); //utilisation
delete ptrPixel; //destruction, le destructeur par défaut est souvent suffisant
Si l'on veut définir explicitement le destructeur d'une classe (pour fermer un fichier par exemple), on utilise le nom de la
classe précédé de ~ :
Point::~Point() {...}
e) surcharge d'un opérateur

utilisons le signe + pour additionner deux Points (par adresse pour éviter de recopier en local):
Point operator+ (Point &P1, Point &P2)
{ Point res(P1.GetX()+P2.GetX(),P1.GetY()+P2.GetY(),P1);
return res;}
On peut aussi surcharger << (pour cout) :

ostream& operator << (ostream& flux, Point& P)

{ flux << "[" << P.GetX() << "," << P.GetY() << "]";
return flux;
}
Ces deux surcharges sont globales. Mais on peut également les définir comme fonctions membres :
class Point {
.....
Point operator + (Point &P);
Point operator = (Point &P);
};
Point::Point::operator + (Point & P)
{Point r;r.X=this->X+P.X;r.Y=this->Y+P.Y;return r;}
void main(void) {
Point A,B,C;
A=B; //appelle A.operator=(B)
B+C; //appelle A.operator+(B)
A=B+C; //marchera aussi, mais A=B=C je n'en suis pas sur
}
f) classes virtuelles
Soient : une classe A, deux classes B et C dérivant de A, une classe D dérivant de B et C. Nous aurons dans D deux
instances de A (qui peuvent être différentes). Mais si une seule instance de A suffisait, il suffit de les déclarer :
class A {...};
class B : virtual public A {...};
class C : virtual public A {...};
class D : public C, public D {...};
Le constructeur de D appellera une seule fois celui de A
g) polymorphisme
Si plusieurs classes (point, ligne, segment) possèdent des méthodes de même signature (écriture similaire du prototype),
on peut éviter de réécrire des fonctions dont le contenu serait identique mais d'appliquant à des objets différents
(déplacer=éteindre+ajouter+allumer pout tous mes objets). On peut pour cela utiliser les fonctions virtuelles (dynamiques :
le choix de la fonction a utiliser est déterminée à l'exécution) ou les fonctions templates (statiques : le choix des fonctions
est fait à la compilation). Voyez l'exemple complet.
5) EXEMPLE COMPLET (commenté)

#include <iostream.h>
#include "graphiq0.cpp" // petite biblio graphique. contient g_init,
// g_fin, g_pixel, g_ligne (voir plus loin)
class Point
{
protected: //accessible uniquement par héritage
int X;int Y;
public : // accessible partout
int GetX(void) {return X;} //hors héritage on ne peut que lire,

//pas écrire
Point (int NewX=0, int NewY=0) {X=NewX;Y=NewY;}
};
//On peut surcharger << (pour cout) : marche pour le point et ses héritiers :
ostream& operator << (ostream& flux, Point& P)
{ flux << "[" << P.GetX() << "," << P.GetY() << "]";
return flux;
}
class Pixel : public Point //dérive de point

{
protected:
int couleur;
public :
Pixel (int nx=0,int ny=0,int coul=0);
virtual void allume(void);
virtual void allume(int couleur); //surcharge : on peut allumer avec une autre
couleur
void eteind(void); // héritable dynamiquement
void ajoute(int plusx=1,int plusy=1);
void deplace(int plusx=1,int plusy=1);// héritable dynamiquement
int GetCouleur(void);
};
Pixel::Pixel(int nx,int ny,int coul):Point(nx,ny) //je passe ainsi les

// arguments au constructeur de Point (sinon il prend
// celui par défaut, cad sans arguments
{couleur=coul;}
void Pixel::allume(void)
{g_pixel(X,Y,couleur);}
void Pixel::allume(int coul)
{g_pixel(X,Y,couleur=coul);}
void Pixel::eteind(void)
{allume(0);} //allume est virtuelle, toute classe dérivée
//possédant allume possèdera automatiquement éteint
void Pixel::ajoute(int plusx,int plusy)
{X+=plusx;Y+=plusy;}
void Pixel::deplace(int plusx,int plusy)
{ int OldCol=couleur;eteind();couleur=OldCol;
ajoute(plusx,plusy);allume();}
int Pixel::GetCouleur(void)
{return couleur;}
class Segment : public Pixel

{
protected :
int LX;int LY;
public :
Segment (int x0=0,int y0=0,int lx=0,int ly=0,int coul=1);
void allume(void);
void allume(int couleur);

//le reste est hérité

};
Segment::Segment(int x0,int y0,int lx,int ly,int coul):Pixel(x0,y0,coul)

{LX=lx;LY=ly;}
void Segment::allume(void)
{g_ligne(X,Y,X+LX,Y+LY,couleur);}
void Segment::allume(int coul)
{g_ligne(X,Y,X+LX,Y+LY,couleur=coul);}
class Rectangle : public Pixel

{
protected :
int LX;int LY;
public :
Rectangle (int x0=0,int y0=0,int lx=0,int ly=0,int coul=1);
void allume(void);
void allume(int couleur);
};
Rectangle::Rectangle(int x0,int y0,int lx,int ly,int coul):Pixel(x0,y0,coul)

{LX=lx;LY=ly;}
void Rectangle::allume(void)
{
g_ligne(X,Y,X+LX,Y,couleur);
g_ligne(X+LX,Y,X+LX,Y+LY,couleur);
g_ligne(X+LX,Y+LY,X,Y+LY,couleur);
g_ligne(X,Y+LY,X,Y,couleur);
}
void Rectangle::allume(int coul)
{couleur=coul;this->allume();}
//utilisons le signe + pour additionner deux objets quels qu'ils soient:

template <class T> //T est un type de classe "variable"
T operator+ (T &P1,Point &P2)
{T res(P1.GetX()+P2.GetX(),P1.GetY()+P2.GetY(),P1);return res;}
// ce qui ne marche pas pour les types autres que point : le constructeur
// prend les autres arguments par défaut (longueur, couleur)
void main(void)
{
g_init();
Pixel *ptrPixel = new Pixel(100,100,1);
ptrPixel->allume(); //utilisation
cout << *ptrPixel << ':' << ptrPixel->GetCouleur()<< '\n';
delete ptrPixel; //destruction, le destructeur par défaut est souvent suffisant
Segment s(50,50,100,0,10);
s.allume();
Rectangle r(150,150,100,100,4);
r.allume();
cin.get(); //équivalent du getch
Point decal(-25,25);
cout << (s+decal) << endl;

(r+decal).allume();
s.deplace(0,100);
r.deplace(0,100);
cout << r << endl; //endl envoie un \n
cin.get();
g_fin();
}
----------- La bibliothèque graphique pour Tubo C (DOS) - Graphiq0.cpp -----------
/* fichier inclus pour INTRO.CPP, version Turbo C 3.0 P.Trau 22/2/97 */
/* bibliothèque graphique minimale . Ce fichier contient les fonctions

qu'il faudra réécrire si l'on change de compilateur. Il faut savoir :
- passer en mode graphique : g_init (sauf si vous y êtes déjà)
- quitter le mode graphique : g_fin
- allumer un point : g_pixel
- à la rigueur tracer une ligne : g_ligne (ou le laisser tel quel,
il n'utilise que g_pixel)
*/
#include <graphics.h>
#define abs(X) ((X>0)?(X):(-(X)))
void g_init(void)
{
int gdriver = DETECT, gmode, errorcode;
initgraph(&gdriver, &gmode, "");
errorcode = graphresult();
if (errorcode != grOk)
#ifdef __cplusplus
cout << "g_erreur: " << grapherrormsg(errorcode) <<"\n";
#else
printf("g_erreur: %s\n", grapherrormsg(errorcode));
#endif
setcolor(getmaxcolor());
}
void g_fin(void)
{closegraph();}
void g_pixel(int x,int y,int color)

{putpixel(x,y,color);}
void g_ligne(int xd,int yd,int xf,int yf,int color)

{
int somme,pasx,pasy,deltax,deltay;
deltax=abs(xf-xd);deltay=abs(yf-yd);
pasx=(xd<xf)?1:-1;
pasy=(yd<yf)?1:-1;
g_pixel(xd,yd,color);
if (deltax>deltay) /* ils sont déjà positifs */

{
somme=deltax/2;
while(xd!=xf)
{
xd+=pasx;
somme+=deltay;
if(somme>=deltax) {somme-=deltax;yd+=pasy;}
}
}
else
{
somme=deltay/2;
while(yd!=yf)
{
yd+=pasy;
somme+=deltax;
if(somme>=deltay) {somme-=deltay;xd+=pasx;}
}
}
}
P. Trau ULP-IPST 24/2/97

le Langage PASCAL
le Langage le Langage PASCAL

PASCAL - Patrick TRAU Janvier 92
version HTML mars 97
Sommaire
Ce document présente (de manière claire je crois, d'après ce qu'en
● INTRODUCTION ont dit certains) le langage PASCAL. Il a été publié dans APTEP -
❍ LES LOGICIELS INFO il y a quelques années. Depuis, bien que je maîtrisais bien ce
langage et avais développé de nombreux programmes en Pascal, je
❍ ORGANISATION DE suis passé au C. Le C est d'après moi plus souple et plus efficace à
L'ORDINATEUR condition de bien en comprendre les mécanismes (il faut d'après moi
❍ LANGAGES DE comprendre à la fois l'assembleur et les objets pour bien programmer
PROGRAMMATION en C). De plus le C est plus utilisé dans mon environnement
d'informaticiens. Néanmoins le Pascal reste bien meilleur pour le
● UN PREMIER PETIT débutant et le programmeur moyen : parfaitement structuré et clair,
PROGRAMME il conduit rapidement à un programme de bonne qualité et assez
● CONSTANTES facilement maintenable (ce qui l'est moins en C, qui possède trop
souvent trop de possibilités pour résoudre le même problème).
● INSTRUCTION
D'AFFECTATION De plus, on trouve des compilateurs Pascal très conviviaux (Turbo
Pascal sur PC, avec aide en ligne, déboguage,...).
● LES TYPES DE
VARIABLES STANDARD Ce document reste donc d'actualité : le Pascal est d'après moi une
SIMPLES ET OPERATEURS très bonne manière d'aborder la programmation. C'est pourquoi j'ai
ASSOCIES choisi de mettre à disposition ce document sur Internet, qu'il serve à
qui en a besoin ! Néanmoins, je n'ai pas passé trop de temps à sa
❍ ENTIERS mise en page, les graphiques restent en mode caractère, il n'y a pas
❍ REELS de lien direct entre les sujets d'exercices et leur correction (que l'on
❍ BOOLEENS trouvera en fin du document).
❍ CARACTERES Voici quelques adresses intéressantes :
● LES FONCTIONS ● ABC de la Programmation : Olivier Pecheux vous aide à
STANDARD démarrer (y compris à installer le compilateur freeware

DJGPP)
● INSTRUCTION
● Pascalissime
● STRUCTURES DE
● Point de rencontre des utilisateurs de Borland Pascal
CONTROLE
● Site officiel de Borland France, et en particulier les
❍ BOUCLE WHILE - DO
compilateurs gratuits (sous Dos-Windows évidement, sous
(tant que - faire)
Unix vous saviez déjà que les meilleurs compilateurs sont
❍ BOUCLE REPEAT - chez GNU).
UNTIL (répéter -
● le cours de Sylvain Bellefeuille (Université de Trois Rivières -
jusqu'à ce que)
http://www-ipst.u-strasbg.fr/pat/program/pascal.htm (1 of 3) [21-11-2001 17:44:19]

le Langage PASCAL
❍ BOUCLE FOR - DO Québec)

(pour - faire) Copyright : utilisation de ce document libre pour tout usage
❍ INSTRUCTION IF - personnel. Utilisation autorisée pour tout usage public non
THEN - ELSE (si - commercial, à condition de citer son auteur (Patrick TRAU, IPST,
alors - sinon) Université Louis Pasteur Strasbourg) et de me signaler tout usage
intensif. Utilisation commerciale interdite sans accord écrit de ma
❍ LA STRUCTURE part.
CASE - OF (cas -
parmi)
● INTRODUCTION
● TYPES ENUMERES NON
STANDARDS ● UN PREMIER PETIT PROGRAMME
● LES TYPES INTERVALLES ● CONSTANTES
● TABLEAUX ● INSTRUCTION D'AFFECTATION
❍ TABLEAUX ● LES TYPES DE VARIABLES STANDARD SIMPLES ET

UNIDIMENSIONNELS OPERATEURS ASSOCIES
❍ LES CHAINES DE ● LES FONCTIONS STANDARD

CARACTERES ● INSTRUCTION
❍ TABLEAUX DE ● STRUCTURES DE CONTROLE
TABLEAUX ● TYPES ENUMERES NON STANDARDS
❍ TABLEAUX ● LES TYPES INTERVALLES
COMPACTES ● TABLEAUX
● ENREGISTREMENTS ● ENREGISTREMENTS
❍ DECLARATION ● PROCEDURES ET FONCTIONS
❍ UTILISATION DES ● LES ENTREES / SORTIES
ENREGISTREMENTS
● ENSEMBLES
❍ LA STRUCTURE
● POINTEURS
WITH - DO (avec -
faire) ● CORRECTION DES EXERCICES
❍ ENREGISTREMENTS ● Sommaire détaillé
AVEC VARIANTES
● PROCEDURES ET
FONCTIONS
❍ GENERALITES
❍ PORTEE DES
DECLARATIONS
❍ ARGUMENTS (OU
PARAMETRES)
❍ LES FONCTIONS
❍ RECURSIVITE

le Langage PASCAL
● LES ENTREES / SORTIES

❍ SUR LA CONSOLE
❍ LES FICHIERS DE
TEXTE
❍ EXTENSIONS NON
STANDARD
■ ACCES DIRECT
■ IMPRIMANTE
■ AUTRES
● ENSEMBLES
● POINTEURS
❍ LES LISTES
CHAINEES ET
ARBRES
❍ LES POINTEURS EN
PASCAL
● CORRECTION DES
EXERCICES
❍ -- Ex ex_tva
❍ -- Ex ex_puiss
❍ -- Ex ex_jeu
❍ -- Ex ex_moy
❍ -- Ex ex_jeu_bis
❍ -- Ex ex_calc
❍ -- EX moy.a
❍ -- Ex rot.b
❍ -- Ex clas.c
❍ -- Ex str
❍ --Ex mat
❍ -- Ex tel
❍ -- Ex rec
❍ -- Ex fichier
❍ -- Ex pointeurs

Correction des TP d'informatique IUP2 97/98
Correction des TP d'informatique IUP2

Vous trouverez ici la correction des TP d'informatique en IUP 2, en 97/98. Depuis, si chaque année les
TP sont un peu différents, l'ensemble des points que je désire aborder avec mes étudiants reste le même,
c'est pourquoi je ne les refais pas systématiquement chaque année.
● TP 1 : prise en main de Turbo C, les boucles
● TP 2 : fonctions, aguments, pointeurs, récursivité

● TP 3 : tableaux statiques et dynamiques, comment agrandir un tableau dynamique
● TP 4 : Chaînes de caractères, tableaux de chaînes (et donc tableaux de tableaux)
● TP 5 : pointeurs et arbres
pour l'année 99/2000, je vous propose quelques indications : TP 1, TP 2, TP 3, TP 4, TP 5. Même

remarque pour 2001/2002, ceux-ci sont disponibles (peut-être dès que le quatrième groupe a fini le TP),
en fonction de l'avancement des TP.
retour au sommaire des documents d'informatique.
http://www-ipst.u-strasbg.fr/pat/program/tpinfo/ [21-11-2001 17:44:22]

Langage C - Introduction (première partie)
Introduction (première partie)

● Organisation de l'ordinateur
● Langages de programmation
Organisation de l'ordinateur
- Multipostes : plusieurs consoles sur un même ordinateur (CPU puissant, tout est partageable)
- Réseau : plusieurs CPU et MC non partageable (sauf réseau de multipostes), MdM et périphériques
partageables ou locaux.
Langages de programmation
Un ordinateur est une machine bête, ne sachant qu'obéir, et à très peu de choses :
* addition, soustraction, multiplication en binaire, uniquement sur des entiers,
* sortir un résultat ou lire une valeur binaire (dans une mémoire par exemple),
* comparer des nombres.
Sa puissance vient du fait qu'il peut être PROGRAMME, c'est à dire que l'on peut lui donner, à l'avance,
la séquence (la suite ordonnée) des ordres à effectuer l'un après l'autre. Le grand avantage de l'ordinateur
est sa rapidité. Par contre, c'est le programmeur qui doit TOUT faire. L'ordinateur ne comprenant que des
ordres codés en binaire (le langage machine), des langages dits "évolués" ont été mis au point pour
faciliter la programmation, au début des années 60, en particulier FORTRAN (FORmula TRANslator)
pour le calcul scientifique et COBOL pour les applications de gestion. Puis, pour des besoins
pédagogiques principalement, ont été créés le BASIC, pour une approche simple de la programmation, et
PASCAL au début des années 70. Ce dernier (comme le C) favorise une approche méthodique et
disciplinée (on dit "structurée"). Le C a été développé conjointement au système d'exploitation UNIX,
dans les Laboratoires BELL, par Brian W Kernigham et Dennis M Ritchie, qui ont défini en 78, dans
"The C Language", les règles de base de ce langage. Le but principal était de combiner une approche
structurée (et donc une programmation facile) avec des possibilités proches de celles de l'assembleur
(donc une efficacité maximale en exécution, quitte à passer plus de temps de programmation), tout en
restant standard (c'est à dire pouvoir être implanté sur n'importe quelle machine). Puis ce langage a été
normalisé en 88 (norme ANSI), cette norme apportant un nombre non négligeable de modifications au
langage.
Le C est un langage compilé, c'est à dire qu'il faut :
http://www-ipst.u-strasbg.fr/pat/program/tpc01.htm (1 of 2) [21-11-2001 17:44:26]

Langage C - Introduction (première partie)
* entrer un texte dans l'ordinateur (à l'aide d'un programme appelé EDITEUR),

* le traduire en langage machine (c'est à dire en codes binaires compréhensibles par l'ordinateur) : c'est la
compilation et, si plusieurs modules ont été compilés séparément, l'édition de liens (LINK ou BIND),
* l'exécuter.
Contrairement à un basic interprété, l'exécution sera beaucoup plus rapide puisqu'il n'y a plus de
traduction à effectuer, mais la phase de mise au point sera plus complexe.
Bien que le langage soit normalisé, un certain nombre de points dépendent de la machine et du
compilateur utilisé (par exemple comment appeler le compilateur). Ces indications ne seront pas données
ici. Si vous avez le choix, je vous conseille TURBO C, le plus pratique d'emploi (en particulier parce
qu'il possède son propre éditeur de texte). Il permet une mise au point aussi simple que si le langage était
interprété

❍ Organisation de l'ordinateur
❍ Langages de programmation
● La syntaxe du C
❍ Second exemple, définitions
❍ Variables / identificateurs / adresse / pointeurs
❍ Expressions / opérateurs
■ Arithmétiques
■ unaires
■ deuxaires
■ Relationnels
■ comparaisons
■ binaires
■ Affectation
■ Opérateurs d'adresses
■ Autres
■ séquentiel ,
■ Ordre de priorité et associativité
❍ Instructions
❍ Structures de contrôle
■ Boucles
http://www-ipst.u-strasbg.fr/pat/program/tpc_c.htm (1 of 3) [21-11-2001 17:44:30]


■ For (pour)
■ Branchements conditionnels
■ Branchements inconditionnels
■ Goto (aller à)
■ Exit (sortir)
❍ Déclaration et stockage des variables
❍ Fonctions
■ Récursivité, gestion de la pile
■ Arguments passés par adresse
■ Fonction retournant un pointeur et pointeur de fonction
■ int : entier
■ float : réel
■ Enumérations
❍ Tableaux
■ Tableaux unidimensionnels
■ Tableaux et pointeurs / arithmétique des pointeurs

■ Bibliothèques de fonctions pour tableaux et chaînes
■ Allocation dynamique de mémoire
■ Tableaux multidimensionnels
■ Déclaration
■ Utilisation
■ Champs de bits
■ Unions
❍ Fichiers bruts

Langage C - Connaissances de base
Connaissances de base
regardons ce petit programme :
#include <stdio.h>
#define TVA 18.6
void main(void)
{
float HT,TTC;
puts ("veuillez entrer le prix H.T.");
scanf("%f",&HT);
TTC=HT*(1+(TVA/100));
printf("prix T.T.C. %f\n",TTC);
}
On trouve dans ce programme :
* des directives du pré processeur (commençant par #)
#include : inclure le fichier définissant (on préfère dire déclarant) les fonctions standard d'entrées/sorties
(en anglais STanDard In/Out), qui feront le lien entre le programme et la console (clavier/écran). Dans
cet exemple il s'agit de puts, scanf et printf.
#define : définit une constante. A chaque fois que le compilateur rencontrera, dans sa traduction de la
suite du fichier en langage machine, le mot TVA, ces trois lettres seront remplacées par 18.6. Ces
transformation sont faites dans une première passe (appelée pré compilation), où l'on ne fait que du
"traitement de texte", c'est à dire des remplacements d'un texte par un autre sans chercher à en
comprendre la signification.
* une entête de fonction. Dans ce cas on ne possède qu'une seule fonction, la fonction principale (main
function). Cette ligne est obligatoire en C, elle définit le "point d'entrée" du programme, c'est à dire
l'endroit où débutera l'exécution du programme.
* un "bloc d'instructions", délimité par des accolades {}, et comportant :
* des déclarations de variables, sous la forme : type listevariables;
Une variable est un case mémoire de l'ordinateur, que l'on se réserve pour notre programme. On définit le
nom que l'on choisit pour chaque variable, ainsi que son type, ici float, c'est à dire réel (type dit à virgule
flottante, d'où ce nom). Les trois types scalaires de base du C sont l'entier (int), le réel (float) et le
caractère (char). On ne peut jamais utiliser de variable sans l'avoir déclarée auparavant. Une faute de
frappe devrait donc être facilement détectée, à condition d'avoir choisi des noms de variables

Langage C - Connaissances de base
suffisamment différents (et de plus d'une lettre).

* des instructions, toutes terminées par un ;. Une instruction est un ordre élémentaire que l'on donne à la
machine, qui manipulera les données (variables) du programme, ici soit par appel de fonctions (puts,
scanf, printf) soit par affectation (=).
Détaillons les 4 instructions de notre programme :
puts affiche à l'écran le texte qu'on lui donne (entre parenthèses, comme tout ce que l'on donne à une
fonction, et entre guillemets, comme toute constante texte en C).
scanf attend que l'on entre une valeur au clavier, puis la met dans la mémoire (on préfère dire variable)
HT, sous format réel (%f).
une affectation : on commence par diviser TVA par 100 (à cause des parenthèses), puis on y ajoute 1,
puis on le multiplie par le contenu de la variable HT. Le résultat de ce calcul est stocké (affecté) dans la
variable cible TTC. Une affectation se fait toujours dans le même sens : on détermine (évalue) tout
d'abord la valeur à droite du signe =, en faisant tous les calculs nécessaires, puis elle est transférée dans la
mémoire dont le nom est indiqué à gauche du =. On peut donc placer une expression complexe à droite
du =, mais à sa gauche seul un nom de variable est possible, aucune opération.
printf affichera enfin le résultat stocké dans TTC.

Langage C - Fonctions d'entrées/sorties les plus utilisées
Fonctions d'entrées/sorties les plus

utilisées
Le langage C se veut totalement indépendant du matériel sur lequel il est implanté. Les entrées sorties,
bien que nécessaires à tout programme (il faut lui donner les données de départ et connaître les résultats),
ne font donc pas partie intégrante du langage. On a simplement prévu des bibliothèques de fonctions de
base, qui sont néanmoins standardisées, c'est à dire que sur chaque compilateur on dispose de ces
bibliothèques, contenant les même fonctions (du moins du même nom et faisant apparemment la même
chose, mais programmées différemment en fonction du matériel). Ces bibliothèques ont été définies par
la norme ANSI, on peut donc les utiliser tout en restant portable. Nous détaillerons ici deux bibliothèques
: CONIO.H et STDIO.H.
Dans CONIO.H on trouve les fonctions de base de gestion de la console :
putch(char) : affiche sur l'écran (ou du moins stdout) le caractère fourni en argument (entre
parenthèses). stdout est l'écran, ou un fichier si on a redirigé l'écran (en rajoutant >nomfichier derrière
l'appel du programme, sous DOS ou UNIX). Si besoin est, cette fonction rend le caractère affiché ou
EOF en cas d'erreur.
getch(void) : attend le prochain appui sur le clavier, et rend le caractère qui a été saisi. L'appui sur une
touche se fait sans écho, c'est à dire que rien n'est affiché à l'écran. En cas de redirection du clavier, on
prend le prochain caractère dans le fichier d'entrée.
getche(void) : idem getch mais avec écho. On pourrait réécrire cette fonction en fonction des deux
précédentes :
char getche(void);
{
char caractere;
caractere=getch();
putch(caractere);
return(caractere);
}
ou même {return(putch(getch))}
Dans la pratique, ce n'est pas ainsi que getche est réellement défini, mais en assembleur pour un résultat
plus rapide.
Dans STDIO.H, on trouve des fonctions plus évoluées, pouvant traiter plusieurs caractères à la suite (par
les fonctions de conio.h), et les transformer pour en faire une chaîne de caractères ou une valeur

numérique, entière ou réelle par exemple. Les entrées sont dites "bufférisées", c'est à dire que le texte
n'est pas transmis, et peut donc encore être modifié, avant le retour chariot.
puts(chaîne) affiche, sur stdout, la chaîne de caractères puis positionne le curseur en début de ligne
suivante. puts retourne EOF en cas d'erreur.
gets(chaîne) lecture d'une chaîne sur stdin. Tous les caractères peuvent être entrés, y compris les blancs.
La saisie est terminée par un retour chariot. Gets retourne un pointeur sur le premier caractère entré (donc
égal à son paramètre d'entrée, ou le pointeur NULL en cas d'erreur (fin du fichier stdin par exemple).
printf(format,listevaleurs) affiche la liste de valeurs (variables ou expressions) dans le format choisi.
Le format est une chaîne de caractères entre guillemets (doubles quote "), dans laquelle se trouve un texte
qui sera écrit tel quel, des spécifications de format (débutant par %) qui seront remplacées par la valeur
effective des variables, dans l'ordre donné dans listevaleurs, et de caractères spéciaux (\). Printf retourne
le nombre de caractères écrits, ou EOF en cas de problème.
Une spécification de format est de la forme :
% [flag][largeur][.précision][modificateur]type (entre [] facultatifs)
Le flag peut valoir : - (cadrage à gauche, rajout de blancs si nécessaire à droite), + (impression du signe,
même pour les positifs), blanc (impression d'un blanc devant un nombre positif, à la place du signe), 0 (la
justification d'un nombre se ferra par rajout de 0 à gauche au lieu de blancs). D'autres Flags sont
possibles mais moins utiles, pour plus de détails voir l'aide en ligne de Turbo C.
La largeur est le nombre minimal de caractères à écrire (des blancs sont rajoutés si nécessaire). Si le
texte à écrire est plus long, il est néanmoins écrit en totalité. En donnant le signe * comme largeur, le
prochain argument de la liste de valeurs donnera la largeur (ex printf("%*f",largeur,réel)).
La précision définit, pour les réels, le nombre de chiffres après la virgule (doit être inférieur à la largeur).
Dans la cas d'entiers, indique le nombre minimal de chiffes désiré (ajout de 0 sinon), alors que pour une
chaîne (%s), elle indique la longueur maximale imprimée (tronqué si trop long). La précision peut,
comme la largeur, être variable en donnant .*
Le modificateur peut être : h (short, pour les entiers), l (long pour les entiers, double pour les réels), L
(long double pour les réels).
Le type est : c (char), s (chaîne de caractères, jusqu'au \0), d (int), u (entier non signé), x ou X (entier
affiché en hexadécimal), o (entier affiché en octal), f (réel en virgule fixe), e ou E (réel en notation
exponentielle), g ou G (réel en f si possible, e sinon), p (pointeur), % (pour afficher le signe %).
Les caractères spéciaux utilisables dans le format sont \t (tabulation), \n (retour à la ligne), \\ (signe \), \nb
tout code ASCII, en décimal, hexa ou octal (\32=\040=\0x20=' ').
scanf(format,listeadresse) lecture au clavier de valeurs, dans le format spécifié. Les arguments sont des
pointeurs sur les variables résultats (dans le cas de variables scalaires, les précéder par l'opérateur &).
Scanf retourne le nombre de valeurs effectivement lues et mémorisées (pas les %*).
Le format peut contenir (entre ") : du texte (il devra être tapé exactement ainsi par l'utilisateur, et ne sera
pas stocké), des séparateurs blancs (l'utilisateur devra taper un ou plusieurs blancs, tabulations, retours à

la ligne), et des spécifications de format, sous la forme %[*][largeur][modificateur] type.

* signifie que la valeur sera lue mais ne sera pas stockée (ex scanf("%d%*c%d",&i,&j) : lecture de deux
entiers séparés par n'importe quel caractère)
la largeur est la largeur maximale lue, scanf s'arrête avant s'il trouve un séparateur (blanc, tab, CR).
les modificateurs et types sont les mêmes que pour printf (excepté d,o,x : pour entiers short, D,O,X pour
long). Dans le cas des chaînes (%s), le blanc est également un séparateur. On ne pourra donc pas entrer
une chaîne avec des blancs par scanf, il faut utiliser gets.
Scanf lit dans stdin en considérant les retours chariot (CR) comme des blancs. on peut donc séparer par
des CR plusieurs valeurs demandées dans le même scanf. Mais de même, si scanf a pu lire tous ses
arguments sans arriver à la fin de la ligne, la suite servira au prochain scanf. Utilisez gets(bidon) avant
(pour être sur de commencer sur une nouvelle ligne) ou après scanf (pour ignorer la fin de la ligne) si
nécessaire.
getchar(void) fonctionne comme getche, mais utilise le même tampon que scanf.
On dispose aussi de sprintf(chaîne, format, listevaleurs) qui permet d'écrire dans une chaîne plutôt que
sur l'écran, et donc faire des conversions numériques ->ASCII; et de sscanf(chaîne, format,l
isteadresse) qui lit dans une chaîne plutôt qu'au clavier. On possède encore d'autres fonctions dans
STDIO, en particulier pour gérer les fichiers.

Langage C - La syntaxe du C
La syntaxe du C
● Second exemple, définitions
● Variables / identificateurs / adresse / pointeurs
● Expressions / opérateurs
❍ Arithmétiques
■ unaires
■ deuxaires
❍ Relationnels
■ comparaisons
■ binaires
❍ Affectation
❍ Opérateurs d'adresses
❍ Autres
■ séquentiel ,
❍ Ordre de priorité et associativité
● Instructions
● Structures de contrôle
❍ Boucles
■ For (pour)
❍ Branchements conditionnels
❍ Branchements inconditionnels

■ Goto (aller à)
■ Exit (sortir)
● Déclaration et stockage des variables
❍ Déclarations locales
❍ Déclarations globales
❍ Déclaration de type
● Fonctions
❍ Définitions générales
❍ Récursivité, gestion de la pile
❍ Arguments passés par adresse
❍ La fonction main
❍ Fonction retournant un pointeur et pointeur de fonction
● Les types de données du C
❍ Variables scalaires
■ int : entier
■ float : réel
■ Enumérations
● Tableaux
❍ Tableaux unidimensionnels
❍ Tableaux et pointeurs / arithmétique des pointeurs
❍ Chaînes de caractères
❍ Bibliothèques de fonctions pour tableaux et chaînes
❍ Allocation dynamique de mémoire
❍ Tableaux multidimensionnels
● Structures et unions
❍ Déclaration
❍ Utilisation
❍ Champs de bits

❍ Unions
❍ Structures chaînées
Second exemple, définitions

Considérons le programme ci-dessous :
#include <stdio.h>
void affiche_calcul(float,float); /* prototype */
float produit(float,float);
int varglob;
void main(void)
{
float a,b; /* déclaration locale */
varglob=0;
puts("veuillez entrer 2 valeurs");
scanf("%f %f",&a,&b);
affiche_calcul(a,b);
printf("nombre d'appels à produit : %d\n",varglob);
}
float produit(float r, float s)

{
varglob++;
return(r*s);
}
void affiche_calcul(float x,float y)

{
float varloc;
varloc=produit(x,y);
varloc=produit(varloc,varloc);
printf("le carré du produit est %f\n",varloc);
}
Un programme C est composé :
* de directivess du pré-processeur, commençant par #, terminées par un retour à la ligne (pas de ;)
* de déclarations globales (terminées par un ;)
* d'une suite de fonctions, écrites les unes après les autres (sans imbrication comme on le ferait en Pascal)
Les fonctions sont écrites sous la forme : entête { corps }
L'entête est de la forme : type_résultat nom (arguments) . Le type_résultat n'était obligatoire (avant la

norme ANSI) que s'il était différent de int (entier). Il doit désormais être void (rien) si la fonction ne
renvoie rien (dans un autre langage on l'aurait alors appelé sous-programme, procédure, ou sous-routine).
Les arguments, s'ils existent, sont passés par valeur. Si la fonction ne nécessite aucun argument, il faut
indiquer (void) d'après la norme ANSI, ou du moins ().
Le corps est composé de déclarations de variables locales, et d'instructions, toutes terminées par un ;
Variables / identificateurs / adresse / pointeurs

On appelle variable une mémoire de l'ordinateur (ou plusieurs), à laquelle on a donné un nom, ainsi qu'un
type (on a précisé ce qu'on mettra dans cette variable (entier, réel, caractère,...), pour que le compilateur
puisse lui réserver la quantité de mémoire nécessaire. Dans cette variable, on pourra y stocker une valeur, et
la modifier au cours du programme.
Exemple : int a; a est une variable entière, le compilateur va lui réserver en mémoire la place nécessaire à
un entier (2 octets en Turbo C). Le nom de cette variable est choisi par le programmeur. On préfère utiliser
le terme identificateur plutôt que nom, car il permet d'identifier tout objet que l'on voudra utiliser (pas
seulement les variables). Les identificateurs doivent suivre quelques règles de base : il peut être formé de
lettres (A à Z), de chiffres et du caractère _ (souligné). Le premier caractère doit être une lettre (ou _ mais il
vaut mieux le réserver au compilateur). Par exemple valeur1 ou prem_valeur sont possibles, mais pas
1ere_valeur. En C, les minuscules sont différentes des majuscules (SURFace et surFACE désignent deux
objets différents). Le blanc est donc interdit dans un identificateur (utilisez _). Les lettres accentuées sont
également interdites. La plupart des compilateurs acceptent n'importe quelle longueur d'identificateurs (tout
en restant sur la même ligne) mais seuls les 32 premiers caractères sont significatifs.
On considère comme blanc : soit un blanc (espace), soit un retour à la ligne, soit une tabulation, soit un
commentaire, soit plusieurs de ceux-ci. Les commentaires sont une portion de texte commençant par /* et
finissant par le premier */ rencontré. les commentaires ne peuvent donc pas être imbriqués. mais un
commentaire peut comporter n'importe quel autre texte, y compris sur plusieurs lignes.
Un identificateur se termine soit par un blanc, soit par un signe non autorisé dans les identificateurs
(parenthèse, opérateur, ; ...). Le blanc est alors autorisé mais non obligatoire.
L'endroit où le compilateur a choisi de mettre la variable est appelé adresse de la variable (c'est en général
un nombre, chaque mémoire d'un ordinateur étant numérotée de 0 à ? ). Cette adresse ne nous intéresse que
rarement de manière explicite, mais souvent de manière indirecte. Par exemple, dans un tableau, composé
d'éléments consécutifs en mémoire, en connaissant son adresse (son début), on retrouve facilement l'adresse
des différentes composantes par une simple addition. On appelle pointeur une variable dans laquelle on
place (mémorise) une adresse de variable (où elle est) plutôt qu'une valeur (ce qu'elle vaut).
Les types de variables scalaires simples que l'on utilise le plus couramment sont le char (un caractère), l'int
(entier) et le float (réel). Le char est en fait un cas particulier des int, chaque caractère étant représenté par
son numéro de code ASCII.

Expressions / opérateurs
Une expression est un calcul qui donne une valeur résultat (exemple : 8+5). Une expression comporte des
variables, des appels de fonction et des constantes combinés entre eux par des opérateurs (ex :
MaVariable*sin(VarAngle*PI/180) ).
Une expression de base peut donc être un appel à une fonction (exemple sin(3.1416). Une fonction est un
bout de programme (que vous avez écrit ou faisant partie d'une bibliothèque) auquel on "donne" des valeurs
(arguments), entre parenthèses et séparés par des virgules. La fonction fait un calcul sur ces arguments pour
"retourner" un résultat. Ce résultat pourra servir, si nécessaire, dans une autre expression, voire comme
argument d'une fonction exemple atan(tan(x)). Les arguments donnés à l'appel de la fonction (dits
paramètres réels ou effectifs) sont recopiés dans le même ordre dans des copies (paramètres formels), qui
elles ne pourront que modifier les copies (et pas les paramètres réels). Dans le cas de fonctions devant
modifier une variable, il faut fournir en argument l'adresse (par l'opérateur &, voir plus bas), comme par
exemple pour scanf.
Pour former une expression, les opérateurs possibles sont assez nombreux, nous allons les détailler suivant
les types de variables qu'ils gèrent.
Arithmétiques
Ces opérateurs s'appliquent à des valeurs entières ou réelles.
unaires
Ce sont les opérateurs à un seul argument : - et + (ce dernier a été rajouté par la norme ANSI). Le résultat
est du même type que l'argument.
deuxaires
Le terme "deuxaire" n'est pas standard, je l'utilise parce que binaire est pour moi associé à la base 2.
Ces opérateurs nécessitent deux arguments, placés de part et d'autre de l'opérateur. Ce sont + (addition), -
(soustraction), * (produit), / (division), % (reste de la division). % nécessite obligatoirement deux
arguments entiers, les autres utilisent soit des entiers, soit des réels. Les opérandes doivent être du même
type, le résultat sera toujours du type des opérandes. Lorsque les deux opérandes sont de type différent
(mais numérique évidement), le compilateur prévoit une conversion implicite (vous ne l'avez pas demandée
mais il la fait néanmoins) suivant l'ordre : { char -> int -> long -> float -> double } et { signed -> unsigned
}. On remarque qu'il considère les char comme des entiers, les opérations sont en fait faites sur les numéros
de code (ASCII). Les calculs arithmétiques sont faits uniquement soit en long soit en double, pour éviter
des dépassements de capacité.
exemples :
int a=1,b=2,c=32000;
float x=1,y=2;
a=(c*2)/1000; /* que des int, le résultat est 64, bien que l'on soit
passé par un résultat intermédiaire (64000) qui dépassait la capacité

des entiers (mais pas celle des long) */

b=7/b; /* signe = donc en premier calcul de l'argument à droite : 7
(entier) / 2 (entier) donne 3 (entier, reste 1, que l'on obtient par
5%2). donc b=3 */
x=7/b; /* 7 et b entiers => passage en réel inutile, calcul de 7/3 donne
2 (entier, reste 1) puis opérateur = (transformation du 2 en 2.0 puis
transfert dans X qui vaut donc 2.0) */
x=7/y; /* un int et un float autour de / : transformation implicite de 7
en réel (7.0), division des deux réel (3.5), puis transfert dans x */
x=((float)(a+1))/b; /* calcul (entier) de a+1, puis transformation
explicite en float, et donc implicite de b en float, division 65.0/3.0
-> 21.666... */
Relationnels
comparaisons
Ces opérateurs sont deuxaires : = = (égalité), != (différent), <, >, <=, >=. Des deux côtés du signe
opératoire, il faut deux opérandes de même type (sinon, transformation implicite) mais numérique (les
caractères sont classés suivant leur numéro de code ASCII). Le résultat de l'opération est 0 si faux, 1 si vrai
(le résultat est de type int). Exemple : (5<7)+3*((1+1)= =2) donne 4. Attention, le compilateur ne vous
prévient pas si vous avez mis = au lieu de = = (= est aussi un opérateur, voir plus loin), mais le résultat sera
différent de celui prévu.
logique booléenne
Le résultat est toujours 0 (faux) ou 1 (vrai), les opérandes devant être de type entier (si char conversion
implicite), 0 symbolisant faux, toute autre valeur étant considérée vraie.
Opérateur unaire : ! (non). !arg vaut 1 si arg vaut 0, et 0 sinon.
Opérateurs deuxaires : && (ET, vaut 1 si les 2 opérandes sont non nuls, 0 sinon) et || (OU, vaut 0 si les
deux opérandes sont nuls, 1 sinon). Le deuxième opérande n'est évalué que si le premier n'a pas suffi pour
conclure au résultat (ex (a= =0)&&(x++<0) incrémente x si a est nul, le laisse intact sinon).
binaires
Ces opérateurs ne fonctionnent qu'avec des entiers. Ils effectuent des opérations binaires bit à bit. On peut
utiliser ~ (complément, unaire), & (et), | (ou inclusif), ^ (ou exclusif), >> (décalage à droite, le 2ème
opérande est le nombre de décalages), << (décalage à gauche). Contrairement aux opérateurs relationnels,
les résultats ne se limitent pas à 0 et 1.
exemples : 7&12 donne 4 (car 0111&1100 donne 0100); ~0 donne -1 (tous les bits à 1, y compris celui de
signe); 8>>2 donne 32.

Affectation
affectation simple =
En C, l'affectation (signe =) est une opération comme une autre. Elle nécessite deux opérantes, un à droite,
appelé Rvalue, qui doit être une expression donnant un résultat d'un type donné, et un à gauche (Lvalue)
qui doit désigner l'endroit en mémoire où l'on veut stocker la Rvalue. Les deux opérandes doivent être de
même type, dans le cas d'opérandes numériques si ce n'est pas le cas le compilateur effectuera une
conversion implicite (la Lvalue doit être de type "plus fort" que la Rvalue). L'opération d'affectation rend
une valeur, celle qui a été transférée, et peut donc servir de Rvalue.
Exemples : a=5 (met la valeur 5 dans la variable a. Si a est float, il y a conversion implicite en float);
b=(a*5)/2 (calcule d'abord la Rvalue, puis met le résultat dans b); a=5+(b=2) (Le compilateur lit
l'expression de gauche à droite. la première affectation nécessite le calcul d'une Rvalue : 5+(b=2). Celle ci
comporte une addition, dont il évalue le premier opérande (5) puis le second (b=2). Il met donc 2 dans b, le
résultat de l'opération est 2, qui sera donc ajouté à 5 pour être mis dans a. A vaut donc 7 et b, 2. Le résultat
de l'expression est 7 (si l'on veut s'en servir).
Remarque : il ne faut pas confondre = et = =. Le compilateur ne peut pas remarquer une erreur
(contrairement au Pascal ou Fortran) car les deux sont possibles. Exemple : if (a=0) est toujours faux car
quelle que soit la valeur initiale de a, on l'écrase par la valeur 0, le résultat de l'opération vaut 0 et est donc
interprété par IF comme faux.
incrémentation / décrémentation
++a : ajoute 1 à la variable a. Le résultat de l'expression est la valeur finale de a (c'est à dire après
incrémentation). On l'appelle incrémentation préfixée.
a++ : ajoute 1 à la variable a. Le résultat de l'expression est la valeur initiale de a (c'est à dire avant
incrémentation). C'est l'incrémentation postfixée.
de même, la décrémentation --a et a-- soustrait 1 à a.
exemple : j=++i est équivalent à j=(i=i+1)
affectation élargie
+= , -= , *= , /= , %= , <<= , >>= , &= , ^= , |=

a+=5 est équivalent à a=(a+5). Il faut encore ici une Rvalue à droite et une Lvalue à gauche.
Opérateurs d'adresses
Ces opérateurs sont utilisées avec des pointeurs. On utilise
● &variable : donne l'adresse d'une variable
● *pointeur : réfère à la variable pointée (opérateur d'indirection)
● . : champ d'une structure
● -> : champ pointé

exemple : supposons déclarer : int i1=1,i2=2; int *p1,*p2; i1 et i2 sont deux mémoires contenant un entier,
alors que p1 et p2 sont des pointeurs, puisqu'ils contiennent une adresse d'entier. p1=&i1; met dans p1
l'adresse de i1. p2=p1; met la même adresse (celle de i1) dans p2. printf("%d\n",*p1) affiche ce qui est
désigné (pointé) par p1 donc i1 donc 1. p2=&i2;*p2=*p1; à l'adresse pointée par p2 mettre ce qui est pointé
par p1, donc copier la valeur de i1 dans i2. printf("%d\n",i2) affiche donc 1.
Autres
conditionnel ? :
C'est un (le seul) opérateur ternaire. L'expression a?b:c vaut la valeur de b si a est vrai (entier, différent de
0), et c si a est faux. Exemple : max=a>b?a:b
séquentiel ,
Cet opérateur permet de regrouper deux sous expressions en une seule. On effectue le premier opérande
puis le second, la valeur finale de l'expression étant celle du second opérande. On l'utilise pour évaluer
deux (ou plus) expressions là où la syntaxe du C ne nous permettait que d'en mettre une, exemple :
for(i=j=0;i>10;i++,j++). Dans le cas d'une utilisation de cet opérateur dans une liste, utilisez les parenthèses
pour distinguer les signes , : exemple (inutile) : printf("%d %d",(i++,j++),k) i est modifié mais sa valeur
n'est pas affichée.
Ordre de priorité et associativité

opérateurs associativité description
() [] -> . ->
! ~ ++ -- - + & * (cast) <- unaires (* pointeurs)
*/% -> multiplicatifs
+- -> addition
>> << -> décalages
< <= > >= -> relations d'ordre
= = != -> égalité
& -> binaire
^ -> binaire
| -> binaire
&& -> logique
|| -> logique
?: -> conditionnel (ternaire)
= += -= *= etc. <- affectation
, <- séquentiel
Dans ce tableau, les opérateurs sont classés par priorité décroissante (même priorité pour les opérateurs

d'une même ligne). Les opérateurs les plus prioritaires se verront évaluer en premier. L'associativité définit
l'ordre d'évaluation des opérandes. La plupart se font de gauche à droite ( 4/2/2 donne (4/2)/2 donc 1 (et pas
4/(2/2))).
Les seules exceptions sont :
● les opérateurs unaires, écrits à gauche de l'opérateur. L'opérande est évalué puis l'opération est
effectuée, le résultat est celui de l'opération; sauf dans le cas de l'incrémentation / décrémentation
postfixée, où le résultat de l'expression est la valeur de l'argument avant l'opération.
● L'affectation : on calcule l'opérande de droite, puis on l'affecte à celui de gauche. Le résultat est la
valeur transférée.
● La virgule : la valeur à droite est calculée avant celle à gauche (en particulier lors d'un appel de
fonction)
● Les opérateurs logiques et conditionnel évaluent toujours leur premier argument. Le second par
contre n'est évalué que si c'est nécessaire.
Instructions
Une instruction peut être :
- soit une expression (pouvant comprendre une affectation, un appel de fonction...), terminé par un ; qui en
fait signifie "on peut oublier le résultat de l'expression et passer à la suite",
- soit une structure de contrôle (boucle, branchement...),
- soit un bloc d'instructions : ensemble de déclarations et instructions délimités par des accolades {}. Un
bloc sera utilisé à chaque fois que l'on désire mettre plusieurs instructions là où on ne peut en mettre qu'une.
Seule la première forme est terminée par un ;. Un cas particulier est l'instruction vide, qui se compose
uniquement d'un ; (utilisé là où une instruction est nécessaire d'après la syntaxe).
Structures de contrôle
Normalement, les instructions s'effectuent séquentiellement, c'est à dire l'une après l'autre. Pour accéder à
une autre instruction que la suivante, on a trois solutions : le branchement inconditionnel, le branchement
conditionnel et la boucle.
Boucles
Une boucle permet de répéter plusieurs fois un bloc d'instructions.
While (tant que)
structure : while (expression) instruction

Tant que l'expression est vraie (!=0), on effectue l'instruction, qui peut être simple (terminée par ;), bloc
(entre {}) ou vide (; seul). L'expression est au moins évaluée une fois. Tant qu'elle est vraie, on effectue
l'instruction, dès qu'elle est fausse, on passe à l'instruction suivante (si elle est fausse dès le début,
l'instruction n'est jamais effectuée).

exemple :
#include <stdio.h>
void main(void)
{
float nombre,racine=0;
puts("entrez un nombre réel entre 0 et 10");
scanf("%f",&nombre);
while (racine*racine<nombre) racine+=0.01;
printf("la racine de %f vaut %4.2f à 1%% près\n",
nombre, racine);
}
Exercice (while_puiss) : faire un programme qui affiche toutes les puissances de 2, jusqu'à une valeur
maximale donnée par l'utilisateur. On calculera la puissance par multiplications successives par 2. Cliquez
ici pour une solution.
Exercice (while_err) : que fait ce programme ?
#include <stdio.h>
#include <math.h>
#define debut 100
#define pas 0.01
void main(void)
{
float nombre=debut;
int compte=0,tous_les;
puts("afficher les résultats intermédiaires
tous les ? (333 par exemple) ?");
scanf("%d",&tous_les);
while (fabs(nombre-(debut+(compte*pas)))<pas)
{
nombre+=pas;
if (!(++compte%tous_les))
printf("valeur obtenue %12.8f, au lieu de %6.2f en %d calculs\n",
nombre,(float)(debut+(compte*pas)), compte);
}
printf("erreur de 100%% en %d calculs\n",compte);
}
Cliquez ici pour une solution.
Do While (faire tant que)
structure : do instruction while (expression); (attention au ; final)

comme while, mais l'instruction est au moins faite une fois, avant la première évaluation de l'expression.

exemple :
#include <stdio.h>
void main(void)
{
int a;
do
{
puts("entrez le nombre 482");
scanf("%d",&a);
}
while (a!=482);
puts("c'est gentil de m'avoir obéi");
}
Exercice (do_while) : écrivez un programme de jeu demandant de deviner un nombre entre 0 et 10 choisi
par l'ordinateur. On ne donnera pas d'indications avant la découverte de la solution, où l'on indiquera le
nombre d'essais. La solution sera choisie par l'ordinateur par la fonction rand() qui rend un entier aléatoire
(déclarée dans stdlib.h). Cliquez ici pour une solution.
For (pour)
structure : for ( expr_initiale;expr_condition;expr_incrémentation) instruction

Cette boucle est surtout utilisée lorsque l'on connaît à l'avance le nombre d'itération à effectuer.
L'expr_initiale est effectuée une fois, en premier. Puis on teste la condition. On effectue l'instruction puis
l'incrémentation tant que la condition est vraie. L'instruction et l'incrémentation peuvent ne jamais être
effectuées. La boucle est équivalente à :
expr_initiale;
while (expr_condition)
{
instruction
expr_incrémentation;
}
Une ou plusieurs des trois expressions peuvent être omises, l'instruction peut être vide. for(;;); est donc une
boucle infinie.
exemple :
{ char c; for(c='Z';c>='A';c--)putchar(c); }
Exercice (for) : faire un programme qui calcule la moyenne de N notes. N et les notes seront saisies par
scanf. Le calcul de la moyenne s'effectue en initialisant une variable à 0, puis en y ajoutant progressivement
les notes saisies puis division par N. Cliquez ici pour une solution.

Branchements conditionnels
On a souvent besoin de n'effectuer certaines instructions que dans certains cas. On dispose pour cela du IF
et du SWITCH.
If - Else (Si - Sinon)
structure : if (expression) instruction1

ou : if (expression) instruction1 else instruction2
Si l'expression est vraie (!=0) on effectue l'instruction1, puis on passe à la suite. Sinon, on effectue
l'instruction 2 puis on passe à la suite (dans le cas sans else on passe directement à la suite).
Exercice (jeu) : modifier le jeu de l'exercice (do_while) en précisant au joueur à chaque essai si sa
proposition est trop grande ou trop petite. Cliquez ici pour une solution.
L'instruction d'un if peut être un autre if (imbriqué)

exemple :
if(c1) i1;
else if (c2) i2;
else if (c3) i3;
else i4;
i5;
si c1 alors i1 puis i5, sinon mais si c2 alors i2 puis i5, ... Si ni c1 ni c2 ni c3 alors i4 puis i5.
Le else étant facultatif, il peut y avoir une ambiguïté s'il y a moins de else que de if. En fait, un else se
rapporte toujours au if non terminé (c'est à dire à qui on n'a pas encore attribué de else) le plus proche. On
peut aussi terminer un if sans else en l'entourant de {}.
exemple : if(c1) if(c2) i1; else i2; : si c1 et c2 alors i1, si c1 et pas c2 alors i2, si pas c1
alors (quel que soit c2) rien.
if (c1) {if (c2) i1;} else i2; : si c1 et c2 alors i1, si c1 et pas c2 alors rien, si pas c1 alors
i2.
Switch - Case (brancher - dans le cas)
Cette structure de contrôle correspond à un "goto calculé".

structure :
switch (expression_entière)
{
case cste1:instructions
case cste2:instructions
........

case csteN:instructions
default :instructions
}
L'expression ne peut être qu'entière (char, int, long). L'expression est évaluée, puis on passe directement au
"case" correspondant à la valeur trouvée. Le cas default est facultatif, mais si il est prévu il doit être le
dernier cas.
exemple : fonction vérifiant si son argument c est une voyelle.
int voyelle(char c)
{
switch(c)
{
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
case 'y':return(1); /* 1=vrai */
default :return(0);
}
}
Remarque : l'instruction break permet de passer directement à la fin d'un switch (au } ). Dans le cas de
switch imbriqués on ne peut sortir que du switch intérieur.
Exemple :
switch (a)
{
case 1:inst1;inst2;....;break;
case 2:....;break;
default:.....
}
/*endroit où l'on arrive après un break*/
Exercice (calcul) : faire un programme simulant une calculatrice 4 opérations. Cliquez ici pour une
solution.
Branchements inconditionnels
Quand on arrive sur une telle instruction, on se branche obligatoirement sur une autre partie du programme.
Ces instructions sont à éviter si possible, car ils rendent le programme plus complexe à maintenir, le fait
d'être dans une ligne de programme ne suffisant plus pour connaître immédiatement quelle instruction on a
fait auparavant, et donc ne permet plus d'assurer que ce qui est au dessus est correctement terminé. Il ne
faut les utiliser que dans certains cas simples.
Break (interrompre)

Il provoque la sortie immédiate de la boucle ou switch en cours. Il est limité à un seul niveau d'imbrication.
exemples :
do {if(i= =0)break;....}while (i!=0); /* un while aurait été mieux */
for (i=0;i<10;i++){....;if (erreur) break;} /* à remplacer par
for(i=0;(i<10)&&(!erreur);i++){...} */
Continue (continuer)
Cette instruction provoque le passage à la prochaine itération d'une boucle. Dans le cas d'un while ou do
while, saut vers l'évaluation du test de sortie de boucle. Dans le cas d'un for on passe à l'expression
d'incrémentation puis seulement au test de bouclage. En cas de boucles imbriquées, permet uniquement de
continuer la boucle la plus interne.
exemple :
for (i=0;i<10;i++) {if (i= =j) continue; ...... }
peut être remplacé par :
for (i=0;i<10;i++) if (i!=j) { ...... }
Goto (aller à)
La pratique des informaticiens a montré que l'utilisation des goto donne souvent des programmes non
maintenables (impossibles à corriger ou modifier). Les problèmes qu'ils posent ont amené les
programmeurs expérimentés à ne s'en servir qu'exceptionnellement.
structure : goto label;
Label est un identificateur (non déclaré, mais non utilisé pour autre chose), suivi de deux points (:), et
indiquant la destination du saut. Un goto permet de sortir d'un bloc depuis n'importe quel endroit. Mais on
ne peut entrer dans un bloc que par son { (qui créera proprement les variables locales du bloc).
{.....
{.....
goto truc;
.....
}
.....
truc:
.....
}
Return (retourner)
Permet de sortir de la fonction actuelle (y compris main), en se branchant à son dernier }. Return permet
également (et surtout) de rendre la valeur résultat de la fonction.
structure : return ou return(valeur)
exemple :

int max(int a, int b) {if (a>b) return(a); else return(b);}
Exit (sortir)
Ceci n'est pas un mot clef du C mais une fonction disponible dans la plupart des compilateurs (définie par
ANSI, dans STDLIB.H). Elle permet de quitter directement le programme (même depuis une fonction). On
peut lui donner comme argument le code de sortie (celui que l'on aurait donné à return dans main). Cette
fonction libère la mémoire utilisée par le programme (variables + alloc) et ferme (sur beaucoup de
compilateurs) les fichiers ouverts.
structure : exit(); ou exit(valeur);
Déclaration et stockage des variables

Une variable doit être définie par le programmateur dans une déclaration, où l'on indique le nom que l'on
désire lui donner, son type (int, float,...) pour que le compilateur sache combien de mémoire il doit lui
réserver et les opérateurs qui peuvent lui être associés, mais aussi comment elle doit être gérée (visibilité,
durée de vie,...).
Déclarations locales
Dans tout bloc d'instructions, avant la première instruction, on peut déclarer des variables. Elles seront alors
"locales au bloc" : elles n'existent qu'à l'intérieur du bloc. Ces variables sont mises en mémoire dans une
zone de type "pile" : quand, à l'exécution, on arrive sur le début du bloc ({), on réserve la mémoire
nécessaire aux variables locales au sommet de la pile (ce qui en augmente la hauteur), et on les retire en
quittant le bloc. L'intérêt consiste à n'utiliser, à un instant donné, que la quantité nécessaire de mémoire, qui
peut donc resservir par après pour d'autres variables. Le désavantage (rarement gênant et pouvant être
contrecarré par la classe STATIC) est qu'en quittant le bloc (par } ou un branchement), et y entrant à
nouveau plus tard (par son {), les variables locales ne sont plus nécessairement recréées au même endroit,
et n'auront plus le même contenu. De plus la libération/réservation de la pile aura fait perdre un peu de
temps. Par contre, lorsque l'on quitte temporairement un bloc (par appel à une fonction), les variables
locales restent réservées. La sortie d'un bloc par un branchement gère la libération des variables locales,
mais seule l'entrée dans un bloc par son { gère leur création.
Exemple :
#include <stdio.h>
int doubl(int b)
{int c; c=2*b; b=0; return(c); }
void main(void)
{
int a=5;
printf("%d %d\n",doubl(a),a);
}
A l'entrée du bloc main, création de a, à qui l'on donne la valeur 5. Puis appel de doubl : création de b au
sommet de la pile, on lui donne la valeur de a. Puis entrée dans le bloc, création sur la pile de c, on lui

donne la valeur b*2=10, on annule b (mais pas a), on rend 10 à la fonction appelante, et on libère le
sommet de la pile (c et b n'existent plus) mais a reste (avec son ancienne valeur) jusqu'à la sortie de main.
On affichera donc : 10 5.
Une variable locale est créée à l'entrée du bloc, et libérée à la sortie. Cette période est appelée sa durée de
vie. Mais pendant sa durée de vie, une variable peut être visible ou non. Elle est visible : dans le texte
source du bloc d'instruction à partir de sa déclaration jusqu'au }, mais tant qu'une autre variable locale de
même nom ne la cache pas. Par contre elle n'est pas visible dans une fonction appelée par le bloc (puisque
son code source est hors du bloc).
autre exemple :
void main(void);
{int a=1; [1]
{int b=2; [2]
{int a=3; [3]
fonction(a); [4]
} [5]
fonction(a); [6]
} [7]
} [8]
int fonction (int b) [a]
{int c=0; [b]
c=b+8; [c]
} [d]
analysons progressivement l'évolution de la pile au cours du temps (en gras : variable visible) :
[1] a=1
[2] a=1 | b=2
[3] a=1 | b=2 | a=3 : seul le a le plus haut est visible (a=3), l'autre vit encore (valeur 1 gardée) mais n'est
plus visible.
[4a] a=1 | b=2 | a=3 | b=3 : entrée dans la fonction, recopie de l'argument réel (a) dans l'argument formel
(b). Mais a n'est plus visible.
[4b] a=1 | b=2 | a=3 | b=3 | c=0
[4c] a=1 | b=2 | a=3 | b=3 | c=11 : quand le compilateur cherche la valeur de b, il prend la plus haute de la
pile donc 3 (c'est la seule visible), met le résultat dans le c le plus haut. L'autre b n'est pas modifié.
[4d] a=1 | b=2 | a=3 : suppression des variables locales b et c du sommet de la pile
[5] a=1 | b=2 : sortie de bloc donc libération de la pile
[6a] a=1 | b=2 | b=1 : l'argument réel (a) n'est plus le même qu'en [4a]
[6b] a=1 | b=2 | b=1 | c=0
[6c] a=1 | b=2 | b=1 | c=9
[6d] a=1 | b=2 : suppression b et c
[7] a=1
[8] la pile est vide, on quitte le programme
Notez que la réservation et l'initialisation prennent un peu de temps à chaque entrée du bloc. Mais ne
présumez jamais retrouver une valeur sur la pile, même si votre programme n'a pas utilisé la pile entre

temps (surtout sur système multitâche ou avec mémoire virtuelle).

Une déclaration a toujours la structure suivante :
[classe] type liste_variables [initialisateur]; (entre [] facultatif)
Le type peut être simple (char, int, float,...) ou composé (tableaux, structures..., voir plus loin).
La liste_variables est la liste des noms des variables désirées, séparées par des virgules s'il y en a plusieurs.
Chaque nom de la liste peut être précédés d'une *, ceci spécifiant un pointeur.
L'initialisateur est un signe =, suivi de la valeur à donner à la variable lors de sa création (à chaque entrée
du bloc par exemple). La valeur peut être une constante, mais aussi une expression avec des constantes
voire des variables (visibles, déjà initialisées).
La classe peut être :
● auto (ou omise, c'est la classe par défaut pour les variables locales) : la variable est créée à l'entrée
du bloc (dans la pile) et libérée automatiquement à sa sortie (comme expliqué plus haut).
● register : la variable est créée, possède la même durée de vie et visibilité qu'une classe auto, mais
sera placée dans un registre du (micro)processeur. Elle sera donc d'un accès très rapide. Si tous les
registres sont déjà utilisés, la variable sera de classe auto. Mais le compilateur peut avoir besoin des
registres pour ses besoins internes ou pour les fonctions des bibliothèques, s'il n'en reste plus le gain
peut se transformer en perte. De plus les compilateurs optimisés choisissent de mettre en registre des
variables auto, et souvent de manière plus pertinente que vous. Mais le compilateur ne sait pas à
l'avance quelles fonctions seront appelées le plus souvent, dans ce cas une optimisation manuelle
peut être utile, par exemples dans le cas des éléments finis où une même instruction peut être répétée
des milliards de fois.
● static : la variable ne sera pas dans la pile mais dans la même zone que le code machine du
programme. Sa durée de vie sera donc celle du programme. Elle ne sera initialisée qu'une fois, au
début du programme, et restera toujours réservée. En retournant dans un bloc, elle possédera donc
encore la valeur qu'elle avait à la précédente sortie. Sa visibilité reste la même (limitée au bloc). Une
variable statique permet en général un gain en temps d'exécution contre une perte en place mémoire.
Déclarations globales
Une déclaration faite à l'extérieur d'un bloc d'instructions (en général en début du fichier) est dite globale.
La variable est stockée en mémoire statique, sa durée de vie est celle du programme. Elle est visible de sa
déclaration jusqu'à la fin du fichier. Elle sera initialisée une fois, à l'entrée du programme (initialisée à 0 si
pas d'autre précision). Le format d'une déclaration globale est identique à une déclaration locale, seules les
classes varient.
Par défaut, la variable est publique, c'est à dire qu'elle pourra même être visible dans des fichiers compilés
séparément (et reliés au link).
La classe static, par contre, rend la visibilité de la variable limitée au fichier actuel.
La classe extern permet de déclarer une variable d'un autre fichier (et donc ne pas lui réserver de mémoire
ici, mais la rendre visible). Elle ne doit pas être initialisée ici. Une variable commune à plusieurs fichiers
devra donc être déclarée sans classe dans un fichier (et y être initialisée), extern dans les autres.

Toute fonction, pour pouvoir être utilisée, doit également être déclarée. Une déclaration de fonction ne peut
être que globale, et connue des autres fonctions. Une déclaration de fonction est appelée "prototype". Le
prototype est de la forme :
[classe] type_retourné nom_fonction(liste_arguments);
elle est donc identique à l'entête de la fonction mais :
- est terminée par un ; comme toute déclaration
- les noms des arguments n'ont pas besoin d'être les mêmes, il peuvent même être omis (les types des
arguments doivent être identiques).
Sans précision de classe, la fonction est publique. Sinon, la classe peut être extern (c'est ce que l'on trouve
dans les fichiers .H) ou static (visibilité limitée au fichier). Le prototype peut être utilisé pour utiliser une
fonction du même fichier, mais avant de l'avoir définie (par exemple si l'on veut main en début du fichier).
En général, lorsque l'on crée une bibliothèque (groupe de fonctions et variables regroupées dans un fichier
compilé séparément), on prépare un fichier regroupant toutes les déclarations extern, noté .H, qui pourra
être inclus dans tout fichier utilisant la bibliothèque.
exemples de déclarations globales :
int i,j; /* publiques, initialisées à 0 */
static int k=1; /* privée, initialisée à 1 */
extern int z; /* déclarée (et initialisée) dans un autre fichier */
float produit(float,float); /* prototype d'une fonction définie plus
loin dans ce fichier */
extern void échange(int *a, int *b); /* prototype d'une fonction définie
dans un autre fichier */
Avant la norme ANSI, le prototype n'existait pas. Une fonction non définie auparavant était considérée
comme rendant un int (il fallait utiliser un cast si ce n'était pas le cas).
Déclaration de type
La norme ANSI permet de définir de nouveaux types de variables par typedef.
structure : typedef type_de_base nouveau_nom;
Ceci permet de donner un nom à un type donné, mais ne crée aucune variable. Une déclaration typedef est
normalement globale et publique.
exemple :
typedef long int entierlong; /* définition d'un nouveau type */
entierlong i; /* création d'une variable i de type entierlong */
typedef entierlong *pointeur; /* nouveau type : pointeur = pointeur d'entierlong */
pointeur p; /* création de p (qui contiendra une adresse), peut être initialisé par =&i */
Remarque : Le premier typedef pouvait être remplacé par un #define mais pas le second.

Fonctions
Définitions générales
Une fonction est définie par son entête, suivie d'un bloc d'instructions
entête : type_retourné nom_fonction(liste_arguments) (pas de ;)
Avant la norme ANSI, le type_retourné pouvait être omis si int. Désormais il est obligatoire, si la fonction
ne retourne rien on indique : void.
La liste_arguments doit être typée (ANSI), alors qu'auparavant les types étaient précisés entre l'entête et le
bloc :
ANSI: float truc(int a, float b) {bloc}
K&R: float truc(a,b) int a;float b; {bloc}
Si la fonction n'utilise pas d'arguments il faut la déclarer (ANSI) nom(void) ou (K&R) nom(). L'appel se
fera dans les deux cas par nom() (parenthèses obligatoires).
Les arguments (formels) sont des variables locales à la fonction. Les valeurs fournies à l'appel de la
fonction (arguments réels) y sont recopiés à l'entrée dans la fonction. Les instructions de la fonction
s'exécutent du début du bloc ({) jusqu'à return(valeur) ou la sortie du bloc (}). La valeur retournée par la
fonction est indiquée en argument de return.
exemple :
float produit(float a;float b)

{
float z;
z=a*b;
return(z);
}
Récursivité, gestion de la pile

Une fonction peut s'appeler elle-même :
int factorielle(int i)
{
if (i>1) return(i*factorielle(i-1));
else return(1);
}
analysons la pile en appelant factorielle(3) :
i=1
i=2 i=2 i=2
i=3 i=3 i=3 i=3 i=3

(a) (b) (c) (d) (e)

● (a) appel de factorielle(3), création de i, à qui on affecte la valeur 3. comme i>1 on calcule
i*factorielle(i-1) : i=3,i-1=2 on appelle factorielle(2)
● (b) création i, affecté de la valeur 2, i>1 donc on appelle factorielle(1)
● (c) création de i, i=1 donc on quitte la fonction, on libère le pile de son sommet, on retourne où la
fonction factorielle(1) a été appelée en rendant 1.
● (d) on peut maintenant calculer i*factorielle(1), i (sommet de la pile) vaut 2, factorielle(1) vaut 1, on
peut rendre 2, puis on "dépile" i
● (e) on peut calculer i*factorielle(2), i vaut 3 (sommet de la pile), factorielle(2) vaut 2 3*2=6, on
retourne 6, la pile est vidée et retrouve sont état initial.
Attention, la récursivité est gourmande en temps et mémoire, il ne faut l'utiliser que si l'on ne sait pas
facilement faire autrement :
int factorielle(int i)
{
int result;
for(result=1;i>1;i--) result*=i;
return(result);
}
Arguments passés par adresse

Imaginons la fonction :
void échange(int i;int j)
{int k;k=i;i=j;j=k;}
Lors d'un appel à cette fonction par échange(x,y), les variables locales i,j,k sont créées sur la pile, i vaut la
valeur de x, j celle de y. Les contenus de i et j sont échangés puis la pile est libérée, sans modifier x et y.
Pour résoudre ce problème, il faut passer par des pointeurs. On utilisera les opérateurs unaires : & (adresse
de) et * (contenu de). Définissons donc la fonction ainsi :
void échange(int *i;int *j)
{int k;k=*i;*i=*j;*j=k;}
On appelle la fonction par échange(&x,&y); les deux arguments formels de la fonction (i et j) sont des
pointeurs sur des int, c'est à dire qu'à l'appel, on crée sur la pile des variables i et j pouvant contenir une
adresse, dans i on recopie l'argument réel qui et l'adresse de x, et l'adresse de y dans j. en entrant dans le
bloc, on crée une variable locale k pouvant contenir un entier. Puis on met dans k non pas la valeur de i
mais le contenu pointé par i (donc ce qui se trouve à l'adresse marquée dans i, qui est l'adresse de x), donc
le contenu de x. On place la valeur pointée par j (donc y) à l'adresse pointée par j (donc x). Puis on place la
valeur de k à l'adresse pointée par j (y). On a donc échangé x et y.
On a tout intérêt à essayer cet exemple en se fixant des adresses et des valeurs, et voir l'évolution des
contenus des variables.

En conclusion, pour effectuer un passage d'argument par adresse, il suffit d'ajouter l'opérateur & devant
l'argument réel (à l'appel de la fonction), et l'opérateur * devant chaque apparition de l'argument formel,
aussi bien dans l'entête que le bloc de la fonction.
La fonction main
Si on le désire, la fonction main peut rendre un entier (non signé) au système d'exploitation (sous MSDOS,
on récupère cette valeur par ERRORLEVEL). Une valeur 0 signale en général une fin normale du
programme, sinon elle représente un numéro d'erreur. L'arrivée sur le } final retourne la valeur 0, dans le
cas où on n'a pas indiqué de return(code).
De même, le système d'exploitation peut transmettre des arguments au programme. La déclaration complète
de l'entête de la fonction main est :
int main(int argc,char *argv[], char *env[])
Le dernier argument est optionnel).
On peut aussi utiliser char **argv, mais cela peut paraître moins clair. argc indique le nombre de
mots de la ligne de commande du système d'exploitation, argv est un tableau de pointeurs sur chaque mot
de la ligne de commande, env pointe sur les variables de l'environnement (sous MSDOS obtenues par SET,
mais aussi très utilisées sous UNIX par env).
Si votre programme s'appelle COPIER, et que sous MSDOS vous ayez entré la commande COPIER TRUC
MACHIN alors argc vaut 3, argv[0] pointe sur "COPIER", argv[1] sur "TRUC" et argv[2] sur "MACHIN".
argv[3] vaut le pointeur NULL. env est un tableau de pointeurs sur les variables d'environnement, on n'en
connaît pas le nombre mais le dernier vaut le pointeur NULL.
Fonction retournant un pointeur et pointeur de fonction

type*fonc(arguments) est une fonction qui renvoie un pointeur.
exemple :
int *max(int tableau[], int taille)

{
int i,*grand;
for(grand=tableau,i=1;i<taille;i++)
if(tableau[i]>*grand) grand=tableau+i;
return(grand);
}
Cette fonction rend l'adresse du plus grand entier du tableau.
type (*fonc)(arguments) est un pointeur sur une fonction
exemple :
int max(int,int);
int min(int,int);

void main(void);
{
int (*calcul)(int,int);
/* calcul est un pointeur donc une variable qui
peut être locale */
char c;
puts("utiliser max (A) ou min (I) ?");
do c=getchar(); while ((c!='A')&&(c!='I'));
calcul=(c= ='A')?&max:&min;
printf("%d\n",(*calcul)(10,20));
}
int max(int a,int b) {return(a>b?a:b);}
int min(int a,int b) {return(a<b?a:b);}
Cette fonctionnalité du C est assez peu utilisée, mais est nécessaire dans les langages orientés objets.
Les types de données du C

Nous allons définir les différents types de variables existantes en C. On verra les types scalaires (entiers,...)
et les types agrégés (combinaisons de scalaires, tableaux par exemple).
Variables scalaires
On appelle variable scalaire une variable ne contenant qu'une seule valeur, sur laquelle on pourra faire un
calcul arithmétique. On possède trois types de base (char, int, float) que l'on peut modifier par 3
spécificateurs (short, long, unsigned).
char : caractère (8 bits)
Une constante caractère est désignée entre apostrophes (simples quotes). 'a' correspond à un octet (alors que
"a" à deux octets : 'a' et '\0', pour plus de détails voir le paragraphe chaînes de caractères). On peut définir
certains caractères spéciaux, par le préfixe \ (antislash) :
● \n nouvelle ligne
● \t tabulation
● \b backspace
● \r retour chariot (même ligne)
● \f form feed (nouvelle page)
● \' apostrophe
● \\ antislash
● \" double quote
● \0 nul
● \nombre en octal sur 3 chiffres (ou moins si non suivi d'un chiffre).
● \xnombre : en hexa
Les char sont considérés dans les calculs comme des int (on considère leur code ASCII). Par défaut en C un

char est signé donc peut varier de -128 à +127. Pour utiliser les caractères spéciaux du PC (non standard), il
vaut mieux utiliser des unsigned char (de 0 à 255). Mais le comme C fait les calculs modulo 256, ça
marche presque pareil.
int : entier
Si l'on désire une taille précise, utiliser short int (16 bits) ou long int (32 bits). Sans précision, int donnera
les programmes les plus rapides pour une machine donnée (int = short sur PC, mais long sur les stations 32
bits). Par défaut, les int sont signés, mais on peut préciser unsigned int.
Désormais certains compilateurs considèrent short comme 16 bits, int comme 32 bits et long comme 64
bits.
float : réel
Un flottant est un nombre stocké en deux parties, une mantisse et un exposant. La taille de la mantisse
définit le nombre de chiffres significatifs, alors que la taille de l'exposant définit le plus grand nombre
acceptable par la machine. Les opérations sur les réels sont plus lents que sur les entiers. Pour une addition
par exemple, il faut d'abord décaler la mantisse pour égaliser les exposants puis faire l'addition. Les réels
sont toujours signés. On peut par contre utiliser le spécificateur long pour des réels avec une précision
accrue. On peut également utiliser le nom double au lieu de long float. Certains compilateurs acceptent
même des long double (quadruple précision).
Tailles et plages
type taille (en bits) plage de valeurs

char 8 -128 à +127
unsigned char 8 0 à 255
short (short int) 16 -32768 à 32767
unsigned short 16 0 à 65535
long (long int) 32 -2.147.483.648 à 2.147.483.647
unsigned long 32 0 à 4.294.967.295
float 32 -3.4e38 à 3.4e38 (7 chiffres significatifs)
double (long float) 64 -1.7e308 à 1.7e308 (15 chiffres significatifs)
long double (non standard) 80 3.4E-4932 à 1.1E+4932 (19 chiffres signif.)
Conversions de type / cast
Dans les calculs, les char sont automatiquement transformés en int. Quand un opérateur possède des
arguments de type différent, une transformation de type est effectuée automatiquement, suivant l'ordre :
char -> int -> long -> float -> double
signed -> unsigned
Attention la transformation n'est effectuée que le plus tard possible, si nécessaire. 5/2+3.5 donnera donc
5.5. De plus les opérations arithmétiques sont toujours effectuées sur des long ou double, pour une

précision maximale quels que soient les résultats intermédiaires (voir exemples au chapitre expressions
arithmétiques).
On peut forcer une transformation en utilisant le cast, qui est un opérateur unaire. La syntaxe est :
(type_résultat) valeur_à_transformer
exemple : {float x;int a=5; x=(float)a;}
Un cast transformant un réel en entier prendra la partie entière. Cette transformation doit être explicite, elle
est impossible implicitement. Pour obtenir l'entier le plus proche , utiliser
(int)(réel_positif+0.5).
Il faut bien noter que le cast n'est une opération de transformation que pour les types scalaires, pour tous les
autres types, le cast ne permet que de faire croire au compilateur que la variable est d'un autre type que ce
qu'il attendait, pour qu'il n'émette pas de message d'erreur (à utiliser avec grande prudence).
Enumérations
On peut définir un nouveau type (d'entiers) sous la forme :

[classe] enum nomdutype {liste_valeurs} [liste_variables]; ([] facultatifs)
exemple : enum jour {lundi, mardi, mercredi, jeudi, vendredi, samedi,
dimanche};
On a créé un nouveau type. toute variable de type jour pourra valoir soit lundi, soit mardi, etc... On peut
directement mettre la liste des variables à créer (entre le "}" et le ";"), ou indiquer :
enum nomdutype liste_variables;
exemple : enum jour aujourd_hui=mardi;)
En fait le type jour est un type int, avec lundi=0, mardi=1,... On peut donc faire toutes les opérations
entières (aujourd_hui++ par exemple). Il n'y a aucun test de validité (dimanche+1 donne 7). Ceci permet de
rendre les programmes plus clairs. On obtiendrait un résultat équivalent avec #define. Attention, printf
affichera un entier, mais on peut faire:
char *nom[7]={"lundi", "mardi", "mercredi", "jeudi", "vendredi",
"samedi"," dimanche"};
puis printf("%s",nom[aujourd_hui]);
On peut aussi prévoir une codification non continue :
enum truc {a=4,b,c,d=2,e,f} : d=2,e=3,f=a=4,b=5,c=6
En utilisant typedef, on n'a pas besoin de répéter enum dans la déclaration de variables :
typedef enum {coeur,carreau,pique,trèfle}couleurs;
couleurs i,j,k;

Tableaux
Tableaux unidimensionnels
Un tableau est un regroupement, dans une même variable, de plusieurs variables simples, toutes de même
type.
déclaration : [classe] type nom [nombre_d'éléments];
exemple : int tab[10];
Ceci réserve en mémoire un espace contigu pouvant contenir 10 entiers. Le premier est tab[0], jusqu'à
tab[9]. Attention, en utilisant tab[10] ou plus, aucune erreur ne sera signalée et vous utiliserez une partie de
mémoire qui a certainement été réservée pour autre chose. Il est possible de définir un tableau de n'importe
quel type de composantes (scalaires, pointeurs, structures et même tableaux). Il est également possible de
définir un type tableau par typedef :
typedef float vecteur[3];
vecteur x,y,z;
On peut aussi initialiser un tableau. Dans ce cas la dimension n'est pas nécessaire. Mais si elle est donnée,
et est supérieure au nombre de valeurs données, les suivantes seront initialisées à 0 :
vecteur vect0={0,0,0};
int chiffres[]={0,1,2,3,4,5,6,7,8,9};
int tableau[20]={1,2,3}; /* les 17 autres à 0 */
On peut également déclarer un tableau sans en donner sa dimension. Dans ce cas là le compilateur ne lui
réserve pas de place, elle aura du être réservée autre part (par exemple tableau externe ou argument formel
d'une fonction).
Exercice (moyenne) : Ecrire le programme qui lit une liste de Nb nombres, calcule et affiche la moyenne
puis l'écart entre chaque note et cette moyenne. Cliquez ici pour une solution.
Tableaux et pointeurs / arithmétique des pointeurs

En déclarant, par exemple, int TAB[10]; l'identificateur TAB correspond en fait à l'adresse du début
du tableau. Les deux écritures TAB et &TAB[0] sont équivalentes (ainsi que TAB[0] et *TAB). On définit
l'opération d'incrémentation pour les pointeurs par TAB+1=adresse de l'élément suivant du tableau.
L'arithmétique des pointeurs en C a cette particularité que l'opération dépend du type de variable pointée,
ajouter 1 consistant à ajouter à l'adresse la taille de l'objet pointé. On définit donc l'addition
(pointeur+entier): TAB+i=&TAB[i], la soustraction (pointeur - entier), mais également la soustraction
(pointeur - pointeur) qui donne un nombre d'éléments. Les opérations de comparaisons entre pointeurs sont
donc également possibles.
Déclarons : int TAB[10],i,*ptr;
Ceci réserve en mémoire
- la place pour 10 entiers, l'adresse du début de cette zone est TAB,
- la place pour l'entier i,
- la place pour un pointeur d'entier (le type pointé est important pour définir l'addition).

Analysons les instructions suivantes :
ptr=TAB; /*met l'adresse du début du tableau dans ptr*/

for(i=0;i<10;i++)
{
printf("entrez la %dième valeur :\n",i+1);
/* +1 pour commencer à 1*/
scanf("%d",ptr+i);
/* ou &TAB[i] puisque scanf veut une adresse*/
}
puts("affichage du tableau");
for(ptr=TAB;ptr<TAB+10 /* ou &TAB[10] */;ptr++)
printf("%d ",*ptr);
puts(" ");
/* attention actuellement on pointe derrière le tableau ! */
ptr-=10; /* ou plutôt ptr=TAB qui lui n'a pas changé */
printf("%d",*ptr+1); /* affiche (TAB[0])+1 */
printf("%d",*(ptr+1)); /* affiche TAB[1] */
printf("%d",*ptr++); /* affiche TAB[0] puis pointe sur TAB[1] */
printf("%d",(*ptr)++); /* affiche TAB[1] puis ajoute 1 à TAB[1]*/
TAB est une "constante pointeur", alors que ptr est une variable (donc TAB++ est impossible). La
déclaration d'un tableau réserve la place qui lui est nécessaire, celle d'un pointeur uniquement la place d'une
adresse.
Pour passer un tableau en argument d'une fonction, on ne peut que le passer par adresse (recopier le tableau
prendrait de la place et du temps).
exemple utilisant ces deux écritures équivalentes :
#include <stdio.h>
void annule_tableau(int *t,int max)
{
for(;max>0;max--)*(t++)=0;
}
void affiche_tableau(int t[], int max)
{
int i;
for(i=0;i<max;i++) printf("%d : %d\n",i,t[i]);
}
void main(void)
{
int tableau[10];
annule_tableau(tableau,10);
affiche_tableau(tableau,10);
}
Exercice (rotation) : Ecrire un programme qui lit une liste de Nb nombres, la décale d'un cran vers le haut

(le premier doit se retrouver en dernier), l'affiche puis la décale vers le bas. On pourra décomposer le
programme en fonctions. Cliquez ici pour une solution.
Exercice (classer) : Classer automatiquement un tableau de Nb entiers puis l'afficher dans l'ordre croissant
puis décroissant. On pourra utiliser des fonctions de l'exercice précédent. On pourra créer un (ou plusieurs)
tableau temporaire (donc local). Si vous vous en sentez la force, prévoyez le cas de valeurs égales. Cliquez
ici pour une solution.
Chaînes de caractères
En C, comme dans les autres langages, certaines fonctionnalités ont été ajoutées aux tableaux dans le cas
des tableaux de caractères. En C, on représente les chaînes par un tableau de caractères, dont le dernier est
un caractère de code nul (\0). Une constante caractères est identifiée par ses délimiteurs, les guillemets "
(double quote).
exemples :
puts("salut");
char mess[]="bonjour"; /* évite de mettre ={'b','o',..,'r',\0} */
puts (mess);
mess est un tableau de 8 caractères (\0 compris). On peut au cours du programme modifier le contenu de
mess, à condition de ne pas dépasser 8 caractères (mais on peut en mettre moins, le \0 indiquant la fin de la
chaîne). Mais on peut également initialiser un pointeur avec une chaîne de caractères :
char *strptr="bonjour";
Le compilateur crée la chaîne en mémoire de code (constante) et une variable strptr contenant l'adresse de
la chaîne. Le programme pourra donc changer le contenu de strptr (et donc pointer sur une autre chaîne),
mais pas changer le contenu de la chaîne initialement créée.
Exercice (chaînes) : écrire un programme qui détermine le nombre et la position d'une sous-chaîne dans
une chaîne (exemple ON dans FONCTION : en position 1 et 6). Cliquez ici pour une solution.
Bibliothèques de fonctions pour tableaux et chaînes

Toutes les fonctions standard d'entrée / sortie de chaînes considèrent la chaîne terminée par un \0, c'est
pourquoi en entrée elles rajoutent automatiquement le \0 (gets, scanf), en sortie elles affichent jusqu'au \0
(puts, printf). La bibliothèque de chaînes (inclure string.h) possède des fonctions utiles à la manipulation de
chaînes :
● int strlen(chaîne) donne la longueur de la chaîne (\0 non compris)
● char *strcpy(char *destination,char *source) recopie la source dans la

destination, rend un pointeur sur la destination
● char *strncpy(char *destination,char *source,int longmax) idem strcpy
mais s'arrête au \0 ou longmax (qui doit comprendre le \0)
● char *strcat(char *destination,char *source) recopie la source à la suite de la
destination, rend un pointeur sur la destination
● char *strncat(char *destination,char *source,int longmax) idem

● int strcmp(char *str1,char*str2) rend 0 si str1= =str2, <0 si str1<str2, >0 si str1>str2.
Idem strncmp
Des fonctions similaires, mais pour tous tableaux (sans s'arrêter au \0) sont déclarées dans mem.h. La
longueur est à donner en octets (on peut utiliser sizeof) :
● int memcmp(void *s1,void *s2,int longueur);
● void *memcpy(void *dest,void *src,int longueur);
On possède également des fonctions de conversions entre scalaires et chaînes, déclarées dans stdlib.h
● int atoi(char *s) traduit la chaîne en entier (s'arrête au premier caractère impossible, 0 si erreur dès le
premier caractère)
● de même atol et atof
Dans ctype.h, on trouve des fonctions utiles (limitées au caractères) :

● int isdigit(int c) rend un entier non nul si c'est un chiffre ('0' à '9'), 0 sinon.
● de même : isalpha (A à Z et a à z, mais pas les accents), isalnum (isalpha||isdigit), isascii (0 à 127),
iscntrl (0 à 31), islower (minuscule), isupper, isspace (blanc, tab, return...), isxdigit (0 à 9,A à F,a à
f)...
● int toupper(int c) rend A à Z si c est a à z, rend c sinon. Egalement tolower
Allocation dynamique de mémoire

La taille déclarée d'un tableau est définie à la compilation. Dans le cas d'une taille inconnue à l'avance, il
faut donc surdimensionner le tableau (et donc réserver des mémoires dont on ne servira que rarement, au
dépends d'autres variables ou tableaux. En C, le lien entre les tableaux et pointeurs permet de réserver, lors
de l'exécution, une zone de mémoire contiguë, de la taille désirée (mais pas plus). Il faut d'abord déclarer
une variable pointeur qui contiendra l'adresse du début du tableau. A l'exécution, lorsque l'on connaît la
taille désiré, on peut réserver une zone mémoire (dans la zone appelée "tas" ou "heap") par les fonctions :
- void *malloc(int taille) : réserve une zone mémoire contiguë de taille octets, et retourne un pointeur sur le
début du bloc réservé. Retourne le pointeur NULL en cas d'erreur (en général car pas assez de mémoire).
- void *calloc(int nb, int taille) : équivalent à malloc(nb*taille).
exemple :
float *tab;
int nb;
puts("taille désirée ?");
scanf("%d",&nb);
tab=(float*)calloc(nb,sizeof(float));
malloc et calloc nécessitent un cast pour que le compilateur ne signale pas d'erreur.
- void free(void *pointeur) libère la place réservée auparavant par malloc ou calloc. Pointeur est l'adresse
retournée lors de l'allocation. En quittant proprement le programme, la mémoire allouée est
automatiquement restituée même si on omet d'appeler free.
- void *realloc(void *pointeur,int taille) essaie, si possible, de réajuster la taille d'un bloc de mémoire déjà
alloué (augmentation ou diminution de taille). Si nécessaire, le bloc est déplacé et son contenu recopié. En

retour, l'adresse du bloc modifié (pas nécessairement la même qu'avant) ou le pointeur NULL en cas
d'erreur.
Ces fonctions sont définies dans stdlib.h ou alloc.h (suivant votre compilateur).
Une erreur fréquente consiste à "perdre" l'adresse du début de la zone allouée (par tab++ par exemple) et
donc il est alors impossible d'accéder au début de la zone, ni de la libérer.
Tableaux multidimensionnels
On peut déclarer par exemple int tab[2][3] : matrice de 2 lignes de 3 éléments. Un tableau peut être
initialisé : int t[2][3]={{1,2,3},{4,5,6}} mais cette écriture est équivalente à {1,2,3,4,5,6}, car il place dans
l'ordre t[0][0],t[0][1],t[0][2],t[1][0],t[1][1],t[1][2], c'est à dire ligne après ligne. Dans un tableau
multidimensionnel initialisé, seule la dimension la plus à gauche peut être omise (ici int t[][3]={...} était
possible).
t correspond à l'adresse &t[0][0], mais t[1] est aussi un tableau (une ligne), donc désigne l'adresse &t[1][0].
En fait, une matrice est un tableau de lignes. On peut expliciter cela par typedef :
typedef int ligne[3];
typedef ligne matrice[2];
En utilisant pointeurs et allocation dynamique, pour gérer un tableau de NBLIG lignes de NBCOL
éléments, , on peut :
● soit créer une matrice complète : allocation par t=malloc(NBLIG* NBCOL* sizeof(élément)), accès
à l'élément l,c par *(t+l*NBCOL+c).
● soit créer un tableau de NBLIG pointeurs de lignes, puis chaque ligne séparément. Ceci permet une
optimisation si les lignes n'ont pas toutes la même longueur (traitement de textes par exemple) mais
aussi de manipuler facilement les lignes (exemple : échanger deux lignes sans recopier leur contenu).
Cette méthode est plus rapide que la précédente, car les adresses de chaque début de ligne sont
immédiatement connues, sans calcul.
● soit utiliser des pointeurs de pointeurs (même principe que le cas précédent, mais remplacement du
tableau de pointeurs (dimension prévue à l'avance) par une allocation dynamique.
Exercice (matrices) : faire le calcul de multiplication d'une matrice (M lignes, L colonnes) par une matrice
(L,N) : résultat (M,N).
Cliquez ici pour une solution.
Exercice (déterminant) : écrire un programme qui calcule le déterminant d'une matrice carrée (N,N),
sachant qu'il vaut la somme (sur chaque ligne) de l'élément de la ligne en 1ère colonne par le déterminant
de la sous-matrice obtenue en enlevant la ligne et la 1ère colonne (en changeant le signe à chaque fois). Le
déterminant d'une matrice (1,1) est sont seul élément. On utilisera bien évidement la récursivité. Il existe
(heureusement) d'autres méthodes plus rapides. Cliquez ici pour une solution.
Structures et unions
Dans un tableau, tous les constituants doivent être du même type. Ce n'est pas le cas des structures, qui sont
des variables composées de plusieurs variables (ou CHAMPS) de types différents. Chaque champ n'est plus

désigné par un numéro comme dans un tableau, mais par un identificateur.
Déclaration
déclaration : struct nom_type {déclaration des champs} liste_variables ;
exemple :
struct identite { char nom[30];

char prenom[20];
int age;
}jean,jacques,groupe[20];
Toute variable de type identité (jean, jacques, groupe[i]) comporte trois champs : nom, prenom et age.
sizeof(jacques) retournera 52. Les champs peuvent être de n'importe quel type valable (scalaires, tableaux,
pointeurs...), y compris une structure (à condition d'être déclaré plus haut). nom_type et liste_variables sont
optionnels mais au moins l'un des deux doit être présent. Les noms de champs ont une portée limitée à la
structure (c'est à dire qu'un autre objet peut avoir le même nom, s'il n'est pas cité dans cette structure).
Nom_type (ici identite) est le nom d'un nouveau type, il peut être utilisé plus loin pour déclarer d'autres
variables, voire d'autres types:
struct identite lui;
struct prisonnier {long numero; struct identite id;} moi;
Il est également possible d'utiliser typedef, et (pas sur tous les compilateurs) d'initialiser une structure :
typedef struct {int jour;int mois;int année;}date;
date aujourdhui={24,12,1992}; /*évite de répéter struct*/
Utilisation
On accède à une composante par NOM_VARIABLE . NOM_CHAMP , par l'opérateur unaire "."
gets(jean.nom);
printf("initiales : %c %c\n",lui.nom[0],lui.prenom[0]);
printf("nom %s \n",groupe[10].nom);
scanf("%d",&moi.id.age);
Une composante d'enregistrement s'utilise comme une variable du même type (avec les mêmes possibilités
mais aussi les mêmes limitations). Depuis la norme ANSI, on peut utiliser l'affectation pour des structures
(recopie de tous les champs), ainsi que le passage des structures en arguments de fonction passés par
valeur. Sur les compilateurs non ANSI, il faut utiliser des pointeurs.
On utilise des pointeurs de structures comme des pointeurs sur n'importe quel autre type. L'opérateur ->
permet une simplification d'écriture (il signifie champ pointé) :
date *ptr;
ptr=(struct date *)malloc(sizeof(date));
*ptr.jour=14;ptr->mois=7;

Champs de bits
En ne définissant que des champs entiers (signés ou non), on peut définir la taille (en bits) de chaque
champ. Il suffit pour cela de préciser, derrière chaque champ, sa taille après un ":".
struct état{unsigned ReadOnly:1;int Crc:6;}
Les champs sont créés à partir des bits de poids faible. Le nom du champ est optionnel (dans le cas de
champs réservés, non utilisés par le programme). Les champs n'ont alors pas d'adresse (impossible d'utiliser
& sur un champ). On utilise ces structures comme les autres.
Unions
déclaration : union nom_type {déclaration des champs} liste_variables ;
Les différents champs commenceront tous à la même adresse (permet d'utiliser des variables pouvant avoir
des types différents au cours du temps, mais un seul à un instant donné). Les champs peuvent être de tout
type, y compris structures. On les utilise comme les structures, avec les opérateurs "." et "->".
Exercice (tel) A l'aide d'un tableau de personnes (nom, prénom, numéro dans la rue, rue, code postal, ville,
numéro de téléphone), faire un programme de recherche automatique de toutes les informations sur les
personnes répondant à une valeur d'une rubrique donnée (tous les PATRICK , tous ceux d'Obernai,
travaillant à l'IPST, etc...). On suppose que le tableau est déjà initialisé. Cliquez ici pour une solution.
Structures chaînées
Le principal problème des données stockées sous forme de tableaux est que celles-ci doivent être ordonnées
: le "suivant" doit toujours être stocké physiquement derrière. Imaginons gérer une association. Un tableau
correspond à une gestion dans un cahier : un adhérent par page. Supposons désirer stocker les adhérents par
ordre alphabétique. Si un nouvel adhérent se présente, il va falloir trouver où l'insérer, gommer toutes les
pages suivantes pour les réécrire une page plus loin, puis insérer le nouvel adhérent. Une solution un peu
plus simple serait de numéroter les pages, entrer les adhérents dans n'importe quel ordre et disposer d'un
index : un feuille où sont indiqués les noms, dans l'ordre, associés à leur "adresse" : le numéro de page.
Toute insertion ne nécessitera de décalages que dans l'index. Cette méthode permet l'utilisation de plusieurs
index (par exemple un second par date de naissance). La troisième solution est la liste chaînée : les pages
sont numérotées, sur chaque page est indiquée la page de l'adhérent suivant, sur le revers de couverture on
indique l'adresse du premier. L'utilisation d'une telle liste nécessite un véritable "jeu de piste", mais
l'insertion d'un nouvel adhérent se fera avec le minimum d'opérations.
Appliquons cela , de manière informatique, à une liste d'entiers, avec pour chaque valeur l'adresse (numéro
de mémoire) du suivant :
Si l'on veut insérer une valeur dans la liste, les modifications à apporter sont minimes :

En C on définira un type structure regroupant une valeur entière et un pointeur :

struct page {int val; struct page *suivant; };
Un pointeur (souvent global) nous indiquera toujours le début de la liste:
struct page *premier;
Au fur et à mesure des besoins on se crée une nouvelle page :
nouveau=(struct page *)malloc(sizeof(struct page));
En n'oubliant pas de préciser le lien avec le précédent :
precedent->suivant=nouveau;
le dernier élément ne doit pas pointer sur n'importe quoi, on choisit généralement soit le pointeur NULL,
soit le premier (la liste est dite bouclée).
exemple :
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <alloc.h> /*ou stdlib.h*/
int encore(void) /* demande si on en veut encore*/

{
printf("encore (O/N) ? ");
return(toupper(getche())= ='O');
}
void lecture(void)
{
struct page *precedent,*nouveau;
premier=(struct page *)malloc(sizeof(struct page));
puts("entrez votre premier entier");
scanf("%d",&premier->val);
precedent=premier;
while (encore())
{
precedent=nouveau;

puts("\nentrez votre entier");

scanf("%d",&nouveau->val);
}
precedent->suivant=NULL;
}
void affiche(struct page *debut)
{
printf("\nliste : ");
while(debut!=NULL)
{
printf("%d ",debut->val);
debut=debut->suivant;
}
printf("\n");
}
void main(void)
{
lecture();
affiche(premier);
}
Exercice (liste) : modifier la fonction lecture ci-dessus pour que la liste soit stockée dans l'ordre inverse de
son introduction (chaque nouvel élément est placé devant la liste déjà existante).
Cliquez ici pour une solution de cet exercice (et du suivant).
Les modifications sont aisées, une fois que l'on a repéré l'endroit de la modification. Exemple : suppression
d'un élément :
void suppression(void)
{
struct page *actu,*prec;
actu=premier;
while (actu!=NULL)
{
printf("\nvaleur : %d - supprimer celui_ci (O/N) ? ",
actu->val);
if (toupper(getche())= ='O')
{
if(actu= =premier)premier=actu->suivant;
else prec->suivant=actu->suivant;
free(actu);
break;
}
else
{
prec=actu;
actu=prec->suivant;

}
}
}
Exercice (insertion) : ajouter au programme précédent une procédure d'insertion d'une valeur dans la liste.
La solution de l'exercice précédent contient également cette insertion
Ce type de données (structure pointant sur un même type) est utilisé dans d'autres cas. Par exemple, pour
représenter un arbre, il suffit pour chaque élément de connaître l'adresse de chaque fils :
Remarque : si le nombre de fils n'est pas constant, on a intérêt à stocker uniquement le fils aîné, ainsi que le
frère suivant(voir partie algorithmique et structures de données).

Langage C - Les fichiers de données
Les fichiers de données

● Fichiers bruts
● Fichiers bufférisés
Les données stockées en mémoire sont perdues dès la sortie du programme. Les fichiers sur support
magnétique (bande, disquette, disque) sont par contre conservables, mais au prix d'un temps d'accès aux
données très supérieur. On peut distinguer les fichiers séquentiels (on accède au contenu dans l'ordre du
stockage) ou à accès direct (on peut directement accéder à n'importe quel endroit du fichier). Les fichiers
sont soit binaires (un float sera stocké comme il est codé en mémoire , d'où gain de place mais
incompatibilité entre logiciels), soit formaté ASCII (un float binaire sera transformé en décimal puis on
écrira le caractère correspondant à chaque chiffre). Les fichiers étant dépendants du matériel, ils ne sont
pas prévus dans la syntaxe du C mais par l'intermédiaire de fonctions spécifiques.
Fichiers bruts
C'est la méthode la plus efficace et rapide pour stocker et récupérer des données sur fichier (mais aussi la
moins pratique). On accède au fichier par lecture ou écriture de blocs (groupe d'octets de taille définie par
le programmeur). C'est au programmeur de préparer et gérer ses blocs. On choisira en général une taille
de bloc constante pour tout le fichier, et correspondant à la taille d'un enregistrement physique (secteur,
cluster...). On traite les fichiers par l'intermédiaire de fonctions, prototypées dans stdio.h (ouverture et
fermeture) et dans io.h (les autres), disponibles sur la plupart des compilateurs (DOS, UNIX) mais pas
standardisés.
La première opération à effectuer est d'ouvrir le fichier. Ceci consiste à définir le nom du fichier
(comment il s'appelle sous le système) et comment on veut l'utiliser. On appelle pour cela la fonction :
int open(char *nomfic, int mode);
nomfic pointe sur le nom du fichier (pouvant contenir un chemin d'accès). Mode permet de définir
comment on utilisera le fichier. On utilise pour cela des constantes définies dans fcntl.h :
O_RDONLY lecture seule, O_WRONLY écriture seule, O_RDWR lecture et écriture. On peut combiner
cet accès avec d'autres spécifications, par une opération OU (|) :
O_APPEND positionnement en fin de fichier (permet d'augmenter le fichier), O_CREAT crée le fichier
s'il n'existe pas, au lieu de donner une erreur, sans effet s'il existe (rajouter en 3ème argument S_IREAD |
S_IWRITE | S_IEXEC déclarés dans stat.h pour être compatible UNIX et créer un fichier lecture/
écriture/ exécution autorisée, seul S_IWRITE utile sur PC), O_TRUNC vide le fichier s'il existait,
O_EXCL renvoie une erreur si fichier existant (utilisé avec O_CREAT).

Deux modes spécifiques au PC sont disponibles : O_TEXT change tous les \n en paire CR/LF et
inversement, O_BINARY n'effectue aucune transformation.
La fonction rend un entier positif dont on se servira par la suite pour accéder au fichier (HANDLE), ou -1
en cas d'erreur. Dans ce cas, le type d'erreur est donné dans la variable errno, détaillée dans errno.h.
On peut ensuite, suivant le mode d'ouverture, soit lire soit écrire un bloc (l'opération est alors directement
effectuée sur disque) :
int write(int handle, void *bloc, unsigned taille);
On désigne le fichier destination par son handle (celui rendu par open), l'adresse du bloc à écrire et la
taille (en octets) de ce bloc. Le nombre d'octets écrits est retourné, -1 si erreur.
int read(int handle, void *bloc, unsigned taille);
lit dans le fichier désigné par son handle, et le met dans le bloc dont on donne l'adresse et la taille. La
fonction retourne le nombre d'octets lus (<=taille, <si fin du fichier en cours de lecture, 0 si on était déjà
sur la fin du fichier, -1 si erreur).
int eof(int handle)
dit si on se trouve (1) ou non (0) sur la fin du fichier.
Lorsque l'on ne se sert plus du fichier, il faut le fermer (obligatoire pour que le fichier soit utilisable par
le système d'exploitation, entre autre mise à jour de sa taille :
int close(int handle)
fermeture, rend 0 si ok, -1 si erreur.
Le fichier peut être utilisé séquentiellement (le "pointeur de fichier" est toujours placé derrière le bloc
que l'on vient de traiter, pour pouvoir traiter le suivant). Pour déplacer le pointeur de fichier en n'importe
que autre endroit, on appelle la fonction :
long lseek(int handle, long combien, int code);
déplace le pointeur de fichier de combien octets, à partir de : début du fichier si code=0, position actuelle
si 0, fin du fichier si 2. La fonction retourne la position atteinte (en nb d'octets), -1L si erreur.
long filelength(int handle);
rend la taille d'un fichier (sans déplacer le pointeur de fichier).
Exemple : copie de fichier (les noms de fichiers sont donnés en argument du programme)
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <sys\stat.h>
#define taillebloc 1024
int main(int argc,char *argv[])

{
int source, destination;
char buffer[taillebloc];
int nb_lus,nb_ecrits;
if (argc!=3) {puts("erreur arguments");return(1);}
if((source=open(argv[1],O_RDONLY|O_BINARY))<0)
{puts("erreur ouverture");return(2);}
if((destination=open(argv[2], O_WRONLY| O_CREAT| O_TRUNC| O_BINARY,
S_IREAD| S_IWRITE| S_IEXEC))<0)
{puts("erreur ouverture");return(2);}
do
{
nb_lus=read(source,(char *)buffer,taillebloc);
if (nb_lus>0) nb_ecrits= write(destination,(char*)buffer, nb_lus);
}
while ((nb_lus==taillebloc)&&(nb_ecrits>0));
close(source);
close(destination);
return(0);
}
Fichiers bufférisés
Les opérations d'entrée / sortie sur ces fichiers se font par l'intermédiaire d'un "buffer" (bloc en mémoire)
géré automatiquement. Ceci signifie qu'une instruction d'écriture n'impliquera pas une écriture physique
sur le disque mais dans le buffer, avec écriture sur disque uniquement quand le buffer est plein.
Les fichiers sont identifiés non par un entier mais par un pointeur sur une structure FILE (définie par un
typedef dans stdio.h). Les fonctions disponibles (prototypées dans stdio.h) sont :
FILE *fopen(char *nomfic, char *mode) : ouvre le fichier, suivant le mode : r (lecture seule), w
(écriture, si le fichier existe il est d'abord vidé), a (append : écriture à la suite du contenu actuel, création
si inexistant), r+ (lecture et écriture, le fichier doit exister), w+ (lecture et écriture mais effacement au
départ du fichier si existant), a+ (lecture et écriture, positionnement en fin de fichier si existant, création
sinon). Sur PC, on peut rajouter t ou b au mode pour des fichiers texte (gestion des CR/LF, option par
défaut) ou binaires, ou le définir par défaut en donnant à la variable _fmode la valeur O_TEXT ou
O_BINARY. fopen rend un identificateur (ID) qui nous servira pour accéder au fichier. En cas d'erreur,
le pointeur NULL est retourné, le type d'erreur est donné dans une variable errno, détaillée dans errno.h.
La fonction void perror(char *s mess) affichera le message correspondant à l'erreur, en général on lui
donne le nom du fichier.
int fread(void *bloc, int taille, int nb, FILE *id) : lit nb éléments dont on donne la taille unitaire en
octets, dans le fichier désigné par id, le résultat étant stocké à l'adresse bloc. La fonction rend le nombre
d'éléments lus (<nb si fin de fichier), 0 si erreur.
int fwrite(void *bloc, int taille, int nb, FILE *id) : écriture du bloc sur fichier, si le nombre rendu est

différent de nb, il y a eu erreur (tester ferror ou errno).

int fclose(FILE *id) : ferme le fichier, en y recopiant le reste du buffer si nécessaire. Cette fonction est
obligatoire pour être sur d'avoir l'intégralité des données effectivement transférées sur le disque.
Retourne 0 si tout s'est bien passé.
int fflush(FILE *id) : transfère effectivement le reste du buffer sur disque, sans fermer le fichier (à
appeler par exemple avant une instruction qui risque de créer un "plantage").
int fseek(FILE *id, long combien, int code) : déplace le pointeur de fichier de combien octets, à partir
de : début du fichier (mode=0), position actuelle (mode=1) ou fin du fichier (mode=2). Retourne 0 si tout
c'est bien passé. Cette fonction n'est utilisable que si l'on connaît la taille des données dans le fichier
(impossible d'aller directement à une ligne donnée d'un texte si on ne connaît pas la longueur de chaque
ligne).
int feof(FILE *id) dit si on est en fin de fichier ou non (0).
Les fichiers bufférisés permettent aussi des sorties formatées :
au niveau caractère : char fgetc(FILE *id), char fputc(char c, FILE *id), et même char ungetc(char
c, FILE *id) qui permet de "reculer" d'un caractère. Cette fonction correspond donc à
{fseek(id,-1,1);c=fgetc(id)}.
au niveau chaîne de caractères :
char *fgets(char *s, int max, FILE *id) : lit une chaîne en s'arrêtant au \n ou à max-1 caractères lus,
résultat dans la zone pointée par s, et retour du pointeur s ou NULL si erreur.
char fputs(char *s, FILE *id) : écrit la chaîne dans le fichier sans ajouter de \n, rend le dernier caractère
écrit ou EOF si erreur.
int fprintf(FILE *id, char *format, listearguments) : rend le nb d'octets écrits, ou EOF si erreur. Les
\n sont transformés en CR/LF si fichier en mode texte (spécifique PC).
int fscanf(FILE *id, char *format, listeadresses) : rend le nombre de variables lues et stockées, 0 si
erreur).
En général, on utilise les fichiers bufférisés :
- Soit en accès direct, en lecture et écriture, avec tous les éléments de même type et même taille (souvent
une structure, en format binaire), ceci permettant d'accéder directement à un élément donné (le 48ème, le
précédent, l'avant dernier...).
- Soit en accès séquentiel, avec des éléments de type différent, tous formatés sous forme ASCII, en
lecture seule ou écriture seule (il est peu probable que le remplacement d'un élément se fasse avec le
même nombre d'octets et nécessiterait un décalage dans le fichier), ces fichiers seront compréhensibles
par n'importe quel autre programme (éditeur de texte, imprimante...). Un tel fichier s'utilise comme
l'écran et le clavier, par des fonctions similaires.
Exercice (agenda) : modifier l'agenda de l'exercice tel en permettant de sauver les données sur disque.
On utilisera un fichier binaire à accès direct. On pourra ensuite apporter les améliorations suivantes :

recherche rapide par dichotomie sans lire tout le fichier (en le supposant classé par ordre alphabétique),
création de fichiers index classés alphabétiquement sur les noms, département et ville pour accès rapide
par dichotomie, les autres se faisant par recherche séquentielle, avec possibilité d'ajout, suppression,
édition du fichier.
Exercice (fic_formaté) : modifier le programme de produit de matrices en lui permettant de donner sur
la ligne de commande trois noms de fichiers : les deux premiers contiendront la description des matrices
à multiplier, le dernier sera créé et contiendra le résultat. Les fichiers seront formatés, contiendront en
première ligne le nombre de lignes puis le nombre de colonnes, puis chaque ligne du fichier contiendra
une ligne de la matrice.

Langage C - Directives du pré-compilateur
Directives du pré-compilateur
Attention, les directives se terminent par le retour à la ligne et pas un ";".
#include <nomfic> permet d'insérer à cet endroit un fichier, qui serra cherché dans le répertoire
correspondant à la bibliothèque du C (sur PC dans \TC\INCLUDE)
#include "nomfic" permet d'insérer à cet endroit un fichier, comme s'il était écrit ici, en le cherchant
dans le répertoire actuel (le votre)
#define nom valeur : remplace chaque occurrence du nom par la valeur. On ne peut prendre en compte
qu'une ligne (le retour à la ligne terminant la définition). En C on a l'habitude de noter les constantes
numériques en majuscules.
exemple :
#define PI 3.1415926
#define begin {
#define end }
#define macro(parametres) définition : permet la définition d'une macro, les paramètres seront
substitués lors de la réécriture. Il ne faut pas de blanc entre le nom de la macro et la "(" pour différencier
d'un define simple.
#define double(a) a*2
remplacera double (i+5) par i+5*2. Il faut donc utiliser des parenthèses, même si elles semblent inutiles :
#define double(a) (a)*2
autre exemple:
#define max(x,y) x>y?x:y
replacera max(a,max(b,c)) par a>b>c?b:c?a:b>c?b:c
#define max(x,y) (((x)>(y)?(x):(y)
replacera max(a,max(b,c)) par (((a)>( (((b)>(c))?(b):(c)) )) ? (a) : (((( b)>(c)) ? (b) : (c))) ce qui donne des
parenthèses superflues mais le résultat escompté.
Une macro ressemble à une fonction, mais sera d'exécution plus rapide : le texte est directement inséré à
l'endroit voulu, mais pas de gestion de pile.
#undef nom : annule le précédent #define nom ...
#if (expression) : les lignes qui suivent ne seront lues (et compilées que si l'expression est vraie
#endif : fin de portée du #if précédent

Langage C - Directives du pré-compilateur
#else : possible mais optionnel, faire attention en cas de #if imbriqués

#ifdef nom : comme #if mais vrai s'il y a eu auparavant un #define nom
#ifndef nom : vrai si variable non définie
exemples:
#ifndef entier
#define entier int
/* si une autre bibliothèque incluse plus haut l'a
déjà défini, on ne le redéfinit plus */
#endif
#ifdef biblio_graphique
initialise_ecran();
efface_ecran();
trace(dessin);
#else
puts("si on avait eu un écran graphique j'aurai fait un dessin");
#endif
/* biblio_graphique peut être défini dans un "header"
(fichier.h) inclus ou non plus haut */

Langage C - Utiliser Turbo C (3.5 par exemple)
Utiliser Turbo C (3.5 par exemple)

Turbo C est d'après moi le compilateur le plus intéressant sur PC en phase d'apprentissage : éditeur
intégré, lié aux messages d'erreur, éditeur multifenêtres, aide en ligne, débogueur puissant. Placez vous
dans votre répertoire (pas celui de Turbo C pour ne pas mélanger avec vos fichier) et appelez TC.
Les commandes sont accessibles par menus, il vaut mieux posséder une souris. Sinon, on accède à une
commande d'un menu par ALT et lettre en surbrillance, on change d'option par TAB, on valide par
ESPACE. Au menu principal, on peut :
FILE : gérer les fichiers : en créer un nouveau (new), reprendre un fichier déjà existant (open, puis
choisir le fichier dans la liste), sauver le fichier actuel (save ou save as), quitter TC (quit ou ALT X).
EDIT : couper - coller, et surtout remettre une ligne de texte dans son état initial (restore line), surtout
après l'avoir effacée par erreur par CTRL Y.
SEARCH : recherche ou remplacement d'un texte dans tout le fichier (CTRL L pour rechercher le
suivant).
RUN : exécuter le programme. On peut exécuter le programme pas à pas : Aller jusqu'à la ligne dans
laquelle est le curseur, avancer d'une ligne (trace into ou step over). Ceci permet de voir dans quel ordre
s'exécutent les instructions.
COMPILE : compiler pour voir les erreurs, il faut faire un EXE pour pouvoir utiliser le programme hors
de TC.
DEBUG : en mode pas à pas on peut voir ou modifier l'état d'une variable (evaluate, inspect), voir l'état
de la pile (imbrication des fonctions et arguments réels : call stack) voir dans une fenêtre à tout moment
l'état d'une variable (add watch).
PROJECT : un projet contient la liste de fichiers nécessaires au fonctionnement d'un programme (fichiers
séparés).
OPTION : on peut tout choisir : répertoires, niveau de messages d'erreur de compilation, mode 43 lignes
(environnement preferences) et même couleurs.
WINDOW : choix des fenêtres ouvertes, déplacement, changement de taille... Entre autres la fenêtre
OUTPUT correspond à l'écran tel que le gère votre programme, utile pour voir à la fois vos résultats et
votre programme.
HELP : aide
En vous plaçant sur une commande d'un menu, l'appui sur F1 vous détaille ce que permet cette
commande. Dans une fenêtre de texte , l'appui sur CTRL F1 vous donne une aide sur le mot sous le
curseur, uniquement si c'est un mot clef du C (mais connaît toutes les fonctions, sait dans quel header elle

Langage C - Utiliser Turbo C (3.5 par exemple)
est déclarée). par exemple, tapez printf puis CTRL F1, vous aurez une indication sur tous les formats
possibles ainsi que des exemples.
En choisissant l'option menus longs, les touches de raccourci sont indiquées à côté des fonctions des
menus.
Dernier conseil, sauvez votre source avant de l'exécuter, au cas ou votre programme planterait la machine
(automatisation possible sous options)

Correction des exercices

langage C / Patrick TRAU
1. while_puiss
2. while_err
3. do_while
4. for
5. jeu
6. calcul
7. moyenne
8. rotation
9. classer
10. chaînes
11. matrices
12. déterminant
13. tel
14. liste et insertion
15. agenda
1. while_puiss
#include <stdio.h>
void main(void)
{
int puissance=1,max;
puts("nombre maximal désiré (ne pas dépasser 16000) ?");
scanf("%d",&max);
while (puissance<max) printf("%d\n",puissance*=2);
}
retour au sujet de cet exercice
2. while_err
Ce programme démontre les erreurs de calcul toujours effectuées sur des nombres réels. On additione successivement 0.01
(qui n'a pas de représentation finie en binaire) à un réel initialement nul. On compte le nombre de calculs jusqu'à obtenir une
erreur de 100%. Dans ce cas il faut 16246 calculs. On peut essayer d'autres pas et d'autres débuts.
http://www-ipst.u-strasbg.fr/pat/program/tpcex.htm (1 of 18) [21-11-2001 17:46:06]

3. do_while
#include <stdio.h>
#include <stdlib.h> /* pour rand() */
#include <time.h> /* pour trouver l'heure pour srand */
void main(void)
{
int solution,reponse,nb_essais=0;
{time_t t;srand((unsigned) time(&t)); } /* initialiser le générateur
à partir du compteur de temps, pour qu'il soit plus aléatoire */
solution=rand()%11; /* reste sera toujours entre 0 et 10 */
do
{
nb_essais++;
puts("proposez votre nombre entre 0 et 10");
scanf("%d",&reponse);
}
while (reponse!=solution);
printf("trouvé en %d essais\n",nb_essais);
}
4. for
#include <stdio.h>
void main(void)
{
int i,N;
float note,somme=0,moyenne;
puts("nombre de notes ? ");
scanf("%d",&N);
for(i=0;i<N;i++)
{
printf("entrez votre %dième note",i+1);
scanf("%f",&note);
somme+=note;
}
moyenne=somme/N;
printf("moyenne calculée :%5.2f\n",moyenne);
}
5. jeu
#include <stdio.h>
#include <stdlib.h> /* pour rand() */
#include <time.h> /* pour trouver l'heure pour srand */
void main(void)

{
int solution,reponse,nb_essais=0;
{ time_t t;srand((unsigned) time(&t)); } /* initialiser le générateur*/
solution=rand()%11; /* reste sera toujours entre 0 et 10 */
do
{
nb_essais++;
puts("proposez votre nombre entre 0 et 10");
scanf("%d",&reponse);
if (reponse>solution) puts("trop grand");
else if (reponse!=solution) puts("trop petit");
}
while (reponse!=solution);
printf("trouvé en %d essais\n",nb_essais);
if (nb_essais==1) puts("vous avez eu un peu de chance");
else if (nb_essais<4) puts("bravo");
else if (nb_essais>6) puts("ce score me semble bien minable");
}
6. calcul
#include <stdio.h>
void main(void)
{
float val1,val2,res;
char op;
int fin=0;
do
{
puts("calcul à effectuer (par ex 5*2), ou 1=1 pour finir ? ");
scanf("%f%c%f",&val1,&op,&val2);
switch (op)
{
case '*':res=val1*val2;break;
case '/':res=val1/val2;break;
case '+':res=val1+val2;break;
case '-':res=val1-val2;break;
case '=':fin++; /* pas besoin de break, je suis déjà au } */
}
if (!fin) printf("%f%c%f=%f\n",val1,op,val2,res);
}
while (!fin);
}
7. moyenne
#include <stdio.h>
#define max 100

typedef float tableau[max];

tableau tab;
int Nb;
void lecture(void)
{
int i;
puts("entrez le nombre de notes à traiter :");
do scanf("%d",&Nb); while ((Nb<=0)||(Nb>max));
for(i=0;i<Nb;i++)
{
printf("valeur n° %d ? ",i+1);
scanf("%f",&tab[i]);
}
}
float moyenne(void)
{
int i;
float somme=0;
for (i=0;i<Nb;i++) somme+=tab[i];
return(somme/Nb);
}
void affichage(float moy)
{
int i;
printf("la moyenne des %d notes est %f\n",Nb,moy);
for(i=0;i<Nb;i++) printf("%dième note : écart : %f\n",i+1,tab[i]-moy);
}
void main(void)
{
lecture();
affichage(moyenne());
}
8. rotation
#include <stdio.h>
typedef int composante;
void lecture(composante *t,int *nb)
{
int i;
puts("nombre de valeurs à entrer ? ");
scanf("%d",nb);
for(i=1;i<=*nb;i++)
{
printf("%dième valeur : ",i);
scanf("%d",t++);
}
}
void affiche(composante *t, int max)
{
int i;

for(i=0;i<max;i++) printf("%d ",*t++);

puts(" ");
}
void decale_bas(composante *deb, int max)
{
composante c,*t;
t=deb+(max-1);
c=*t;
while (t>deb) {*t=*(t-1);t--;}
*t=c;
}
void decale_haut(composante *t, int nb)
{
composante c;int i;
c=*t;
for (i=1;i<nb;i++) {*t=*(t+1);t++;}
*t=c;
}
void main(void)
{
composante tableau[100];
int nombre;
lecture(tableau,&nombre);
puts("tableau initial :");
affiche(tableau,nombre);
decale_haut(tableau,nombre);
puts("décalage vers le haut :");
decale_bas(tableau,nombre);
puts("décalage vers le bas :");
}
9. classer
#include <stdio.h>
#define dim 100
typedef int composante;
void lecture(composante *t,int *nb)
{
int i;
puts("nombre de valeurs à entrer ? ");
scanf("%d",nb);
for(i=1;i<=*nb;i++)
{
printf("%dième valeur : ",i);
scanf("%d",t++);
}
}
void affiche(composante *t, int max)
{

int i;
for(i=0;i<max;i++) printf("%d ",*t++);
puts(" ");
}
int indice_min(composante t[],int indice_dep, int nb_indices)
/* cherche l'indice de la valeur du tableau :
* -soit égale à t[indice_dep], mais d'indice > à indice_dep;
* -soit la plus petite mais >t[indice_deb]
*/
{
int i,indice_resultat=-1;
for(i=indice_dep+1;i<nb_indices;i++) if (t[i]==t[indice_dep]) return(i);
/* si on est encore là c'est qu'il n'y en pas d'égal */
for(i=0;i<nb_indices;i++)
if ((t[i]>t[indice_dep]) && ((indice_resultat<0) || (t[i]<t[indice_resultat])))
indice_resultat=i;
return(indice_resultat);
}
void copier(composante *source, composante *dest, int nb)
/* copie le tableau source dans le tableau dest */
{
int i;
for(i=0;i<nb;i++) *(dest++)=*(source++);
}
void classe(composante tab[], int nb)
{
composante tempo[dim]; /* un malloc(sizeof(composante)*nb) aurait été
mieux mais on n'en a pas encore parlé en cours */
int i,ind_faits,indice;
/* 1er : recherche du plus petit, le 1er si ex aequo */
indice=0;
for(i=1;i<nb;i++)
if(tab[i]<tab[indice]) indice=i;
tempo[ind_faits=0]=tab[indice];
/* les suivants : recherche le + petit mais > au précédent */
for(ind_faits=1;ind_faits<nb;ind_faits++)
{
indice=indice_min(tab,indice,nb);
tempo[ind_faits]=tab[indice];
}
copier(tempo,tab,nb);
}
void main(void)
{
composante tableau[dim];
int nombre;
lecture(tableau,&nombre);
puts("tableau initial :");
classe(tableau,nombre);
puts("tableau classé :");
}

10. chaînes
#include <stdio.h>
#define taille 255
int debut_egal(char *ch,char *sch)
/* répond si sch est exactement le début de ch */
{
while (*sch && *ch)
{
if (*sch!=*ch) return(0); else {ch++;sch++;}
}
return(!(*sch));
}
void recherche(char *ch,char *sch)
{
int pos=0;
while (*ch)
{
if (debut_egal(ch,sch)) printf("trouvé en position %d\n",pos);
ch++;pos++;
}
}
void main(void)
{
char ch[taille],sch[taille];
puts("chaîne à tester ? ");
gets(ch);
puts("sous-chaîne à trouver ?");
gets(sch);
recherche(ch,sch);
}
11. matrices
#include <stdio.h>
#define DIM 10
typedef float ligne[DIM];
typedef ligne matrice[DIM];
typedef float *pointeur;
void lecture(matrice t,int *lig,int *col)

/* lit à l'écran une matrice */
{
int l,c;
float f;
puts("nombre de lignes de la matrice ?");
scanf("%d",lig);

puts("nombre de colonnes de la matrice ?");

scanf("%d",col);
for (l=0;l<*lig;l++) for(c=0;c<*col;c++)
{
printf("élément [%d,%d] ? ",l,c);
scanf("%f",&f);
t[l][c]=f;
}
}
void zero(float *t)
/* met toute la matrice à 0 */
{
int i;
for(i=0;i<DIM*DIM;i++) *t++=0;
}
void unit(matrice t)
/* remplit la matrice unité (1 diagonale, 0 autre) */
{
int i;
zero(t);
for(i=0;i<DIM;i++) t[i][i]=1;
}
void init(matrice t)
/* initialisation de matrice à numlig.numcol */
{
int i,j;
for(i=0;i<DIM;i++) for(j=0;j<DIM;j++) t[i][j]=i+j/10.0;
}
void affiche(matrice t,int l,int c)
/* puts("affichage du tableau ligne par ligne :"); */
{
int i,j;
for(i=0;i<l;i++)
{
printf("ligne %d : ",i);
for(j=0;j<c;j++) printf("%3.1f ",t[i][j]);
printf("\n");
}
}
void produit(matrice a,matrice b,matrice c,int m,int l,int n)
/* calcul du produit */
{
int im,il,in;
zero(c);
for(im=0;im<m;im++)
for(in=0;in<n;in++)
for(il=0;il<l;il++)
c[im][in]+=a[im][il]*b[il][in];
}
void main(void)
{
int m,l,n,i;
matrice a,b,c;
lecture(a,&m,&l);

lecture(b,&i,&n);
if(i!=l) puts("calcul impossible : dimensions incompatibles");
affiche(a,m,l);
puts("--- FOIS ---");
affiche(b,l,n);
puts("--- FAIT ---");
produit(a,b,c,m,l,n);
affiche(c,m,n);
}
12. determinant
#include <stdio.h>
#include <stdlib.h>
#define DIM 10
typedef float ligne[DIM];
typedef ligne matrice[DIM];
typedef float *pointeur;
long nb_appels;
void lecture(matrice t,int *lig)

/* lit une matrice (au clavier) */
{
int l,c;
float f;
puts("dimension de la matrice ?");
scanf("%d",lig);
for (l=0;l<*lig;l++) for(c=0;c<*lig;c++)
{
printf("élément [%d,%d] ? ",l,c);
scanf("%f",&f);
t[l][c]=f;
}
}
void zero(matrice t,int dim)
/* met toute la matrice à 0 */
{
int i,j;
for(i=0;i<dim;i++)for(j=0;j<dim;j++) t[i][j]=0;
}
void unit(matrice t, int dim)
/* remplit la matrice unité (1 diagonale, 0 autre) */
{
int i;
zero(t,dim);
for(i=0;i<dim;i++) t[i][i]=1;
}
void affiche(matrice t,int l)
/* puts("affichage du tableau ligne par ligne :"); */
{
int i,j;

for(i=0;i<l;i++)
{
printf("ligne %d : ",i);
for(j=0;j<l;j++) printf("%3.1f ",t[i][j]);
printf("\n");
}
}
void copiesauflc(matrice source,matrice dest,int dim,int ligavirer)
{
int l,c,ld=0;
for (l=0;l<dim;l++) if (l!=ligavirer)
{
for (c=1;c<dim;c++) dest[ld][c-1]=source[l][c];
ld++;
}
}
float determinant(matrice m,int dim)
{
matrice sous_m;
int l,signe=1;
float det=0;
nb_appels++;
if (dim==1) return(m[0][0]);
for(l=0;l<dim;l++)
{
copiesauflc(m,sous_m,dim,l);
det+=signe*m[l][0]*determinant(sous_m,dim-1);
signe=-signe;
}
return(det);
}
void produit(matrice a,matrice b,matrice c,int dim)
/* calcul du produit */
{
int im,il,in;
zero(c,dim);
for(im=0;im<dim;im++)
for(in=0;in<dim;in++)
for(il=0;il<dim;il++)
c[im][in]+=a[im][il]*b[il][in];
}
void main(int argc,char *argv[])
{
int taille;
matrice mat;
/* lecture(mat,&taille); */
taille=atoi(argv[1]); /* test avec matrice unité, */
unit(mat,taille); /* au moins je connais le résultat*/
affiche(mat,taille);
printf("déterminant : %20.17f ",determinant(mat,taille));
printf(" en %ld appels\n",nb_appels);
}

13. tel
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define DIM 100
enum champs {nom,prenom,num,rue,cp,ville,tel};
char *nomchamp[7]={"Nom", "Prénom", "Numéro", "Rue",
"Code Postal", "Ville", "Tel"};
typedef struct
{
char nom[15];
char prenom[20];
int num;
char rue[60];
long codepostal;
char ville[20];
char tel[15];
} fiche;
fiche *rech_nom(fiche *,char *);

fiche *rech_prenom(fiche *,char *);
fiche *rech_num(fiche *,char *);
fiche *rech_rue(fiche *,char *);
fiche *rech_cp(fiche *,char *);
fiche *rech_ville(fiche *,char *);
fiche *rech_tel(fiche *,char *);
typedef fiche *ptrfiche;

typedef ptrfiche (*ptrfonction)(ptrfiche,char*);
ptrfonction tabfonction[7]={rech_nom, rech_prenom, rech_num,
rech_rue, rech_cp, rech_ville, rech_tel};
void affiche(fiche *f)

{
if(f->nom[0])
printf("%s %s\n%d, %s\n%ld %s\nTel : %s\n", f->nom, f->prenom,
f->num, f->rue, f->codepostal, f->ville, f->tel);
else
printf("fiche inconnue\n");
}
int idem(char *s1,char *s2)
/* compare deux chaines, dit si elles sont égales (1), ou non (0). On
pourrait supposer égalité quand la chaine s2 est incluse dans s1 */
{
return(strcmp(s1,s2)?0:1);
}
fiche *rech_nom(fiche *pf,char *n)

{while ((pf->nom[0])&&(!idem(pf->nom,n)))pf++;
return(pf);}

fiche *rech_prenom(fiche *pf,char *n)

{while ((pf->nom[0])&&(!idem(pf->prenom,n)))pf++;
return(pf);}
fiche *rech_num(fiche *pf,char *n)
{while ((pf->nom[0])&&(pf->num!=atoi(n)))pf++;
return(pf);}
fiche *rech_rue(fiche *pf,char *n)
{while ((pf->nom[0])&&(!idem(pf->rue,n)))pf++;
return(pf);}
fiche *rech_cp(fiche *pf,char *n)
{while ((pf->nom[0])&&(pf->codepostal!=atoi(n)))pf++;
return(pf);}
fiche *rech_ville(fiche *pf,char *n)
{while ((pf->nom[0])&&(!idem(pf->ville,n)))pf++;
return(pf);}
fiche *rech_tel(fiche *pf,char *n)
{while ((pf->nom[0])&&(!idem(pf->tel,n)))pf++;
return(pf);}
int choix(void)
{
char lig[40];
enum champs i,rep;
for (i=nom;i<=tel;i++) printf("%d:%s ",i,nomchamp[i]);
printf("\nou -1 pour quitter. Type de recherche désirée ? ");
gets(lig);
sscanf(lig,"%d",&rep);
return(rep);
}
void lecture(fiche *tab)

{
char lig[40];
do
{
printf("nom (rien pour finir) ?");
gets(tab->nom);
if(tab->nom[0])
{
printf(" prénom ? ");
gets(tab->prenom);
printf(" N° ? ");
gets(lig);
sscanf(lig,"%d",&(tab->num));
printf(" rue ? ");
gets(tab->rue);
printf(" code postal ? ");
gets(lig);
sscanf(lig,"%ld",&(tab->codepostal));
printf(" ville ? ");
gets(tab->ville);
printf("n° de téléphone ? ");
gets(tab->tel);
}

}
while ((tab++)->nom[0]);
}
void main(void)
{
enum champs c;
char clef[40];
fiche tab[DIM];
lecture(tab);
do
{
if (((c=choix())<0)||(c>6)) break;
printf("quel(le) %s recherche-t'on ? ",nomchamp[c]);
gets(clef);
affiche(tabfonction[c](tab,clef));
}
while (c>=0);
}
14. liste et insertion
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <alloc.h>

int encore(void) /* demande si on en veut encore*/

{
printf("encore (O/N) ? ");
return(toupper(getche())=='O');
}
void lecture(void)
{
struct page *precedent,*nouveau;
premier=(struct page *)malloc(sizeof(struct page));
puts("entrez votre premier entier");
scanf("%d",&premier->val);
precedent=premier;
while (encore())
{
precedent=nouveau;
puts("\nentrez votre entier");
scanf("%d",&nouveau->val);
}

precedent->suivant=NULL;
}
void affiche(struct page *debut)

{
printf("\nliste : ");
while(debut!=NULL)
{
printf("%d ",debut->val);
debut=debut->suivant;
}
printf("\n");
}
void suppression(void)
{
struct page *actu,*prec;
actu=premier;
while (actu!=NULL)
{
printf("\nvaleur : %d - supprimer celui-ci (O/N) ? ",actu->val);
if (toupper(getche())=='O')
{
if(actu==premier)premier=actu->suivant;
else prec->suivant=actu->suivant;
free(actu);
break;
}
else
{
prec=actu;
actu=prec->suivant;
}
}
}
void ajouter(void)
{
struct page *nouveau,*prec;
printf("\najouter en premier (O/N) ? ");
{
nouveau->suivant=premier;
premier=nouveau;
printf("\nnouvelle valeur ? ");
scanf("%d",&(nouveau->val));
}
else
{
prec=premier;
while(prec!=NULL)
{
printf("\nvaleur : %d - insérer après celui_ci (O/N) ? ", prec->val);

{
nouveau->suivant=prec->suivant;
prec->suivant=nouveau;
printf("\nnouvelle valeur ? ");
scanf("%d",&(nouveau->val));
break;
}
else prec=prec->suivant;
}
}
}
void main(void)
{
lecture();
affiche(premier);
do
{
suppression();
affiche(premier);
}
while(encore());
do
{
ajouter();
affiche(premier);
}
while(encore());
}
15. agenda
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <conio.h>
/* définitions des types et variables associées */

enum champs {nom,prenom,num,rue,cp,ville,tel};
char *nomchamp[7]={"Nom","Prénom","Numéro","Rue",
"Code Postal","Ville","Tel"};
typedef struct
{
char nom[15];
char prenom[20];
int num;
char rue[60];
long codepostal;
char ville[20];

char tel[15];
} fiche;
#define taille sizeof(fiche)
typedef fiche *ptrfiche;
/* définitions des fonctions de recherche, regroupées dans un tableau */

fiche *rech_prenom(fiche *,char *);
fiche *rech_num(fiche *,char *);
fiche *rech_rue(fiche *,char *);
fiche *rech_cp(fiche *,char *);
fiche *rech_ville(fiche *,char *);
fiche *rech_tel(fiche *,char *);
typedef ptrfiche (*ptrfonction)(ptrfiche,char*);

ptrfonction tabfonction[7]= {rech_nom, rech_prenom, rech_num,
rech_rue, rech_cp, rech_ville, rech_tel};
/* variables globales */
FILE *fic; /* fichier de données */
char *nomfic="agenda.dat";
int nb; /* nb de fiches dans le fichier */
void init(void)
/* ouvre le fichier, détermine le nb de fiches de fic */
{
if ((fic=fopen(nomfic,"a+b"))==NULL)
{
puts("ouverture impossible du fichier de données");
exit(1);
}
fseek(fic,0,2);
nb=(int)ftell(fic)/taille;
printf("%d fiches présentes dans l'agenda\n",nb);
}
void ajouter(void)
{
char lig[40];
fiche f;
printf("nom ? ");
gets(f.nom);
printf(" prénom ? ");
gets(f.prenom);
printf(" Numero ? ");
gets(lig);
sscanf(lig,"%d",&(f.num));
printf(" rue ? ");
gets(f.rue);
printf(" code postal ? ");
gets(lig);
sscanf(lig,"%ld",&(f.codepostal));
printf(" ville ? ");

gets(f.ville);
printf("n° de téléphone ? ");
gets(f.tel);
fseek(fic,0L,2);
if(fwrite(&f,taille,1,fic)!=1)
{
puts("impossible d'ajouter cette fiche au fichier ");
exit(0);
}
nb++;
}
void affiche(fiche *f)

{
if((f!=NULL)&&(f->nom[0]))
printf("%s %s\n%d, %s\n%ld %s\nTel : %s\n",f->nom, f-> prenom,
f->num, f->rue,f->codepostal,f->ville,f->tel);
else
printf("fiche inconnue\n");
}
int idem(char *s1,char *s2)

/* compare deux chaines, dit si elles sont égales (1), ou non (0).
On considère égales majuscules et minuscules.
Une des chaines peut se terminer par *, on supposera identique
si tout ce qui précède l'* était identique */
{
for(;;)
{
if (((!*s1)&&(!*s2))||(*s1=='*')||(*s2=='*')) return(1);
if ((toupper(*s1)!=toupper(*s2))||(!*s1)||(!*s2)) return(0);
s1++;s2++;
}
}
fiche *rech_nom(fiche *pf,char *n)

{
int nblu;
fseek(fic,0L,0);
do
nblu=fread(pf,taille,1,fic);
while ((nblu==1)&&(!idem(pf->nom,n)));
if (nblu==1) return(pf); else return(NULL);
}
/* les autres recherches sont à continuer */
int choix(void)
{
char lig[40];
enum champs i,rep;
for (i=nom;i<=tel;i++) printf("%d:%s ",i,nomchamp[i]);
printf("\nou -1 pour quitter. Type de recherche désirée ? ");
gets(lig);

sscanf(lig,"%d",&rep);
return(rep);
}
void recherche(void)
{
enum champs c;
char clef[40];
fiche f;
do
{
if (((c=choix())<0)||(c>6)) break;
printf("quel(le) %s recherche-t'on ? ",nomchamp[c]);
gets(clef);
affiche(tabfonction[c](&f,clef));
}
while (c>=0);
}
void main(void)
{
char rep;
init();
do
{
puts("Ajouter une fiche, Recherche d'une fiche, Quitter le prog ? ");
switch (rep=toupper(getch()))
{
case 'A':ajouter();break;
case 'R':recherche();break;
case 'Q':fclose(fic);puts("Au revoir");break;
default :puts("option non prévue");
}
}
while (rep!='Q');
}

Langage C - Liens externes
Liens vers d'autres sites sur le C

Je ne suis pas le seul à publier mon cours sur Internet. Voici d'autres liens, pour compléter (ou remplacer)
ce que je propose.
● Le cours d'Irène Charon (ENST Paris) : le language est présenté progressivement à partir
d'exemples. C'est un très bon complément à qui n'a pas trop aimé ma méthode de présentation
(mes étudiants par exemple)
● Le cours de Alain Dancel : Très bon cours, très complet.
● cours ANSI-C de Fred Faber (Lycée Technique des Arts et Métiers, Luxembourg)
● le cours d'Yves Papegay (Inria) (sous Unix)
vous cherchez un compilateur (freeware, évidement) ? DJGPP pour DOS, ou GNU-Win32 pour Win
95/NT, ou GCC pour Unix (c'est le seul que j'ai essayé). De nouveaux arrivants : Pacific : sous DOS
(freeware), avec un environnement sympa (un peu comme Turbo C), et une doc en pdf (la version
Windows est payante). Désormais, Inprise (Borland) vous propose ses compilateurs gratuitement !
(pour certaines versions Turbo C, Turbo Pascal, Borland C, Delphi..., évidement pas les plus récentes).
http://www-ipst.u-strasbg.fr/pat/program/tpcliens.htm [21-11-2001 17:46:11]

Algo

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Algo

Încărcat de

Drepturi de autor:

Formate disponibile

Données et Algorithmique

Données et Données et Algorithmique

http://www-ipst.u-strasbg.fr/pat/program/algo.htm (1 of 4) [21-11-2001 17:39:47]

http://www-ipst.u-strasbg.fr/pat/program/algo.htm (2 of 4) [21-11-2001 17:39:47]

http://www-ipst.u-strasbg.fr/pat/program/algo.htm (3 of 4) [21-11-2001 17:39:47]

http://www-ipst.u-strasbg.fr/pat/program/algo.htm (4 of 4) [21-11-2001 17:39:47]

http://www-ipst.u-strasbg.fr/pat/program/algo_t.htm [21-11-2001 17:39:57]

http://www-ipst.u-strasbg.fr/pat/program/algo01.htm [21-11-2001 17:40:12]

http://www-ipst.u-strasbg.fr/pat/program/ (1 of 2) [21-11-2001 17:40:27]

Depuis le 20/3/1997, vous êtes le ème lecteur de cette page

http://www-ipst.u-strasbg.fr/pat/program/ (2 of 2) [21-11-2001 17:40:27]

Données et Algorithmique - Sommaire

http://www-ipst.u-strasbg.fr/pat/program/algo_c.htm (1 of 3) [21-11-2001 17:40:36]

http://www-ipst.u-strasbg.fr/pat/program/algo_c.htm (2 of 3) [21-11-2001 17:40:36]

http://www-ipst.u-strasbg.fr/pat/program/algo_c.htm (3 of 3) [21-11-2001 17:40:36]

Données et Algorithmique - Index

http://www-ipst.u-strasbg.fr/pat/program/algo_i.htm (1 of 6) [21-11-2001 17:40:43]

http://www-ipst.u-strasbg.fr/pat/program/algo_i.htm (2 of 6) [21-11-2001 17:40:43]

http://www-ipst.u-strasbg.fr/pat/program/algo_i.htm (3 of 6) [21-11-2001 17:40:43]

http://www-ipst.u-strasbg.fr/pat/program/algo_i.htm (4 of 6) [21-11-2001 17:40:43]

http://www-ipst.u-strasbg.fr/pat/program/algo_i.htm (5 of 6) [21-11-2001 17:40:43]

❍ fusion [1] [2]

http://www-ipst.u-strasbg.fr/pat/program/algo_i.htm (6 of 6) [21-11-2001 17:40:43]

http://www-ipst.u-strasbg.fr/pat/program/tpc_t.htm (1 of 2) [21-11-2001 17:40:49]

● Introduction (première partie)

http://www-ipst.u-strasbg.fr/pat/program/tpc_t.htm (2 of 2) [21-11-2001 17:40:49]

http://www-ipst.u-strasbg.fr/pat/program/tpc_i.htm (1 of 9) [21-11-2001 17:40:58]

http://www-ipst.u-strasbg.fr/pat/program/tpc_i.htm (2 of 9) [21-11-2001 17:40:58]

http://www-ipst.u-strasbg.fr/pat/program/tpc_i.htm (3 of 9) [21-11-2001 17:40:58]

http://www-ipst.u-strasbg.fr/pat/program/tpc_i.htm (4 of 9) [21-11-2001 17:40:58]

http://www-ipst.u-strasbg.fr/pat/program/tpc_i.htm (5 of 9) [21-11-2001 17:40:58]

● malloc [1] [2]

http://www-ipst.u-strasbg.fr/pat/program/tpc_i.htm (6 of 9) [21-11-2001 17:40:58]

http://www-ipst.u-strasbg.fr/pat/program/tpc_i.htm (7 of 9) [21-11-2001 17:40:58]

● structure [1] [2]

http://www-ipst.u-strasbg.fr/pat/program/tpc_i.htm (8 of 9) [21-11-2001 17:40:58]

http://www-ipst.u-strasbg.fr/pat/program/tpc_i.htm (9 of 9) [21-11-2001 17:40:58]

LES VARIABLES SCALAIRES

http://www-ipst.u-strasbg.fr/pat/program/algo02.htm (1 of 4) [21-11-2001 17:41:05]

http://www-ipst.u-strasbg.fr/pat/program/algo02.htm (2 of 4) [21-11-2001 17:41:05]

http://www-ipst.u-strasbg.fr/pat/program/algo02.htm (3 of 4) [21-11-2001 17:41:05]

récursivité, l'empilement des variables locales et l'exemple de la factorielle).

http://www-ipst.u-strasbg.fr/pat/program/algo02.htm (4 of 4) [21-11-2001 17:41:05]

LES TABLEAUX STATIQUES

http://www-ipst.u-strasbg.fr/pat/program/algo03.htm (1 of 15) [21-11-2001 17:41:35]

#define composante float

#define composante float

fonctions de base (fichier inclus base_tus)

void init_tus(type_tus tab,int *taille,int dim)

int ajoute_val_tus(type_tus tab,int *taille,int dim,composante val)

void affiche_tus(type_tus tab,int taille)

http://www-ipst.u-strasbg.fr/pat/program/algo03.htm (2 of 15) [21-11-2001 17:41:35]

manipulations dans les tableaux (mani_tus)

void suppr_tus(type_tus tab,int *taille,int position)

int insert_tus(type_tus tab,int *taille,int dim,int position,composante val)

http://www-ipst.u-strasbg.fr/pat/program/algo03.htm (3 of 15) [21-11-2001 17:41:35]

void rot_gauche_tus(type_tus tab,int taille)

http://www-ipst.u-strasbg.fr/pat/program/algo03.htm (4 of 15) [21-11-2001 17:41:35]

void tri_bulle_tus(type_tus tab, int N)

le tri par insertion

void tri_insertion_tus(type_tus tab, int N)

http://www-ipst.u-strasbg.fr/pat/program/algo03.htm (5 of 15) [21-11-2001 17:41:35]

int pt,ppg; /* position testée, premier plus grand */