tome 1

Algorithmique et
programmation en Langage C
TOME 1
Michel Combacau
Professeur à l'Université Paul Sabatier
Table des matières
Objectifs.................................................................................................................................2
1- Éléments d'algorithmique..................................................................................................3
1.1- Introduction.................................................................................................................4
1.2- Algorithmique élémentaire..........................................................................................5
1.2.1- Bloc de programme............................................................................................5
1.2.2- Les expressions.................................................................................................5
1.2.1- Les instructions..................................................................................................6
1.2.2- Exécution séquentielle d'un programme............................................................6
1.3- Les données d'un programme informatique...............................................................6
1.3.1- Les différents type de données..........................................................................7
1.3.1.1- Les données scalaires...............................................................................7
1.3.1.1- Les tableaux...............................................................................................7
1.3.1.1- Les données complexes structurées.........................................................7
1.3.2- Les variables, les constantes et leur déclaration...............................................7
1.4- Les entrées / sorties.................................................................................................11
1.5- Les structures de contrôle d'un algorithme...............................................................11
1.5.1- L'alternative......................................................................................................12
1.5.2- Les choix multiples ou sélection......................................................................14
1.5.3- Les boucles......................................................................................................14
1.5.3.1- Forme générale sans connaissance a priori du nombre d'itérations.......14
1.5.3.2- Cas particulier d'un nombre d'itérations connu.......................................16
1.6- Les structures de données complexes : fichier........................................................17
1.7- Programmation modulaire .......................................................................................20
1.7.1- Concept de sous programme ..........................................................................20
1.7.2- Portée des variables........................................................................................22
1.8- Quelques problèmes algorithmiques résolus...........................................................23
1.8.1- Moyenne de n valeurs saisies au clavier.........................................................23
1.8.2- Saisie d'une matrice de données....................................................................24
1.8.3- Produit matriciel................................................................................................25
1.8.4- Tri par sélection................................................................................................27
1.8.5- Tri par permutation (« tri à bulle »)...................................................................28
1

Objectifs
Ce polycopié a pour but de donner les bases d'algorithmique et de programmation
structurée afin de former l'étudiant à la conception d'une application informatique spécifiée
par un cahier des charges décrivant les besoins sous forme textuelle. Il s'agit d'utiliser une
démarche structurée pendant la conception et un langage cible standard, le langage C.
Cet enseignement se situe au niveau de la troisième année de la licence et ne va
donc pas aborder tous les aspects de l'algorithmique et de la programmation. Il ne traite
pas en particulier des aspects dynamiques des applications informatiques. Ainsi, les
structures de données dynamiques (files, piles, listes, arbres...) et les algorithmes récursifs
ne sont pas abordés dans ce cours. Il s'agit en effet de concepts algorithmiques et de
programmation « avancés » ne relevant pas, me semble-t-il du niveau de la licence
d'ingénierie électrique.
Tout étudiant ayant acquis les concepts développés dans ce cours pourra aborder la
réalisation d'un projet informatique de taille conséquente, pourvu que la dimension des
structures de données puisse être définie à l'avance ou tout au moins que l'on puisse en
estimer la borne supérieure. Si le programme ainsi conçu se trouve confronté à un
ensemble de données de taille supérieure à cette limite, il ne pourra pas s'exécuter
correctement. La protection de l'application contre ce type de dysfonctionnement fait
partie, bien sûr, des concepts de ce cours.
Le problèmes pouvant être résolus en n'utilisant que les concepts développés dans
ce cours couvrent la grande majorité des cas qui peuvent être rencontrés dans le cadre
professionnel auquel prépare la licence d'ingénierie électrique, notamment des
programmes :
–de calcul numérique spécifique ,
–mettant en œuvre un système de commande automatique,
–émulant ou simulant un système électrique, électronique, etc.
–exécutant des fonctions de traitement du signal, de conversion d'échelle, etc.
–assurant la communication entre deux systèmes par bus série ou parallèle.
Il sera en revanche plus délicat d'aborder des problèmes de gestion d'ensemble de
données dont la taille peut croître de manière très importante (liste de clients, de matériel,
historiques de fonctionnement).
Enfin, ce document n'est pas un manuel de référence du langage C... Il en existe
bien assez ! La partie programmation en langage C donne les clés de la traduction d'un
algorithme de manière à garder une similitude importante entre la réalisation (le code
source) et la conception (l'algorithme). La mise au point du programme est ainsi facilitée.
Mais les détails des « innombrables » options du langage ne sont jamais décrites. En ce
sens ce polycopié est complémentaire du manuel de « Traitement de l'information -
Langage C» distribué pour cette même formation.
2

Première partie
1- Éléments d'algorithmique
3

1.1- Introduction
La conception d'un programme est une opération complexe qui s'appuie sur des
méthodes, des outils des habitudes et des conventions qu'il est préférable de connaître
avant de commencer.
Nous avons déjà évoqué que le problème à résoudre (le programme à écrire) est
décrit sous forme textuelle dans un cahier des charges, parfois incomplet et très souvent
imprécis.
Par exemple :
« L'utilisateur est invité à saisir une série de notes au clavier s'achevant par une note
négative indiquant la fin de la saisie. Le programme devra calculer la moyenne des
nombres entrées au clavier et afficher le résultat avec une précision de deux décimales.»
L 'analyse de ce cahier des charges permet d'appréhender le problème qu'il faut
résoudre. Cela passe par un questionnement qui doit éclaircir les diverses facettes : quelle
est la plage de valeur d'une « note » ? Combien de notes au maximum l'utilisateur peut-il
saisir pour un calcul de moyenne ? Que doit-il se passer si l'utilisateur entre une donnée
erronée (un lettre à la place d'un nombre par exemple) ? Etc. Cette analyse n'entre pas
dans le cadre de l'algorithmique à proprement parler, mais est une étape la précédant
obligatoirement. C'est le problème tel que nous le comprenons que nous traduirons en
algorithme et que nous présenterons sous la forme d'un dictionnaire de données et d'une
structure de contrôle spécifiant l'exécution de la solution. Nous utiliserons pour cette
description un pseudo langage standardisé qui ne dépend pas de la syntaxe du langage
de programmation, mais qui en est proche pour faciliter le codage, c'est à dire l'écriture du
programme en langage source (ici du C). La suite de la construction de l'application
informatique sera confiée à un logiciel appelé compilateur / éditeur de liens (souvent
raccourcie en « compilateur » par abus de langage) qui produit un code binaire
directement exécutable par le processeur de la machine.
En résume, les différentes étapes s'enchaînent comme suit :
L'effort du concepteur de programme porte essentiellement sur la phase analyse et
algorithmique. C'est cette phase qui produit une solution sous une forme conventionnelle.
La traduction de cet algorithme en langage de programmation structuré ne pose en
4
Cahier des charges
Algorithme en pseudo code
Programme en langage C
Application en langage machine
Compilation
Analyse et algorithmique
Codage en langage C

général pas de problème, à condition de maîtriser correctement le langage de
programmation.
1.2- Algorithmique élémentaire
Comme nous venons de le voir, l'algorithmique est une phase qui s'insère entre le
cahier des charges et le codage proprement dit. Les conventions d'écriture des
algorithmes tiennent compte de ces deux nécessités : être lisible pour un concepteur et
être proche du langage de programmation. Si le langage humain n'est sensé poser aucun
problème de lecture et de compréhension pour le concepteur, la signification du langage
de programmation pour ce même concepteur n'est pas forcément naturelle. Compte tenu
de la proximité pseudo-code / langage, la compréhension des règles de l'algorithmique
s'appuie naturellement sur celle du langage de programmation. Nous allons donc
commencer par « enfoncer quelques portes déjà ouvertes »...
1.2.1- Bloc de programme
Un bloc de programme est une suite de phrases syntaxiquement correctes dans le
langage et qui présente une cohésion et une logique forte. Au niveau algorithmique un
bloc de programme est délimité par les deux mots clés « Début » et « Fin ».
Notons tout de suite, que l'application objet du développement que nécessite le
problème à résoudre définit toujours le bloc programme de plus haut niveau, celui qui va
englober tout le reste
On notera donc les limites d'un algorithme par :
Debut //programme
ici se trouve tout l'algorithme de la solution
Fin //programme
le texte qui suit les deux barres obliques est un commentaire. Chaque marque Debut
et Fin doit être commentée par le nom du bloc qu'elle délimite. De même, l'écriture d'un
Debut doit être suivie immédiatement par l'écriture du Fin correspondant. Le bloc de code
peut ensuite être inséré entre ces deux délimiteurs sans risque de défaut de structure.
Chaque fois que l'expression de la solution nécessite d'isoler une partie du
programme, cela passera par l'utilisation de bloc de programme. Attention, les blocs de
programmes peuvent être imbriqués, mais ne doivent pas se chevaucher
Correct
Debut //programme
Debut //bloc1
Debut //bloc2
Fin //bloc2
Fin //bloc1
Fin //programme
Incorrect
Debut //programme
Debut //bloc1
Debut //bloc2
Fin //bloc1
Fin //bloc2
Fin //programme
Notons enfin que pour la lisibilité de l'algorithme il est conseillé d'indenter le texte à
chaque entrée dans un bloc et de revenir à l'indentation précédente à la sortie du bloc.
Voyons maintenant de quoi est constitué un bloc de programme.
1.2.2- Les expressions
La description des calculs que doit effectuer le programme passe par l'écriture
d'expressions. En algorithmique une expression est une combinaison d'opérandes (les
5