Cours Algoritmique & Programmation

Cycle : BACHELOR
Niveau : 1
Support de cours
Algorithmique et programmation
ANNEE ACADEMIQUE 2022-2023

PLANNING DE DEROULEMENT DU COURS
ENSEIGNANT
Nom (s) et prénom (s) : DIFFOUO TAZO Evariste
Grade ou Qualification : Ingénieur Informaticien & Doctorant
Téléphone : (+237) 697 481 969 / (+237) 677 268 237
Courriel : evaristetazo@gmail.com / evariste_tazo@yahoo.fr
Quotas horaire semestriel prévus : 32 heures

Volume horaire hebdomadaire prévu : 8 heures
Volume horaire mensuel prévu : 32 heures
Jours hebdomadaires de cours : /
Période des enseignements : /
Objectifs du cours
Ce cours vise à introduire l’étudiant à l’univers des langages informatiques & programmation afin de lui permettre de com-
prendre l’impact généré aujourd’hui par le numérique.
À la fin de cet enseignement, l’étudiant doit être capable de :

1. Comprendre les fondamentaux du langage informatique & programmation ;
2. Comprendre les enjeux et les objectifs du langage informatique & programmation ;
3. Expliquer pourquoi du langage informatiques & programmation est aujourd’hui un concept indispensable au dévelop-
pement des entreprises ;
4. Comprendre comment procéder pour développer et appliquer les différentes composantes du langage informatique &
programmation ;
5. Maitriser et utiliser des algorithmes en matière de programmation ;
6. Faire de la programmation avec le langage C.
CONTENU DE L’ENSEIGNEMENT
CHAPITRE I : Introduction et généralités sur l’algorithmique et la programmation
CHAPITRE II : Algorithmique : Les instructions élémentaires et les instructions de contrôle
CHAPITRE III : Algorithmique : Les sous programmes et les structures de données
CHAPITRE IV : Notions de base de la programmation en langage C
CHAPITRE V : Les instructions élémentaires et les instructions de contrôle en langage C
APPROCHE PEDAGOGIQUE
L’approche pédagogique est conçue pour impliquer l’étudiant dans la construction et l’utilisation des savoirs.
Ce planning transmis à l’étudiant lui permet de préparer chaque séance de cours. Des travaux à faire lui
sont donnés à la fin de chaque séance de cours afin de lui permettre d’assimiler l’unité d’enseignement.
Diverses stratégies sont utilisées dont : l’enseignement magistral interactif, les exercices pratiques, la mé-
thode des cas, l’apprentissage par problèmes, le réseau de concepts etc.
Déroulement des exercices / cas pratiques et Méthode d’évaluation
Hormis les exercices d’application une liste d’exercices est intégrée à l’annexe du cours.
A chaque séance l’étudiant a droit aux exercices / TP à faire en salle, à la maison ou en équipe.
Le(s) contrôle(s) continu(s) et l’examen final comptent chacun pour 50% de la note finale
Le contrôle continu est constitué de :
➢ La présence et participation en salle ;
➢ L’évaluation en salle ;
➢ Travaux à faire à la maison ;
➢ Les travaux d’équipes.
NB : Les travaux dirigés ou pratiques doivent être remis au début du cours ou envoyés par courrier élec-
tronique.
Planification des activités d’enseignement
§ COURS 1 :
I. Introduction et généralités sur l’algorithmique et la programmation § COURS 5 : Les structures de données en algorithmique
➢ Contextes scientifiques et définitions des concepts : Informatique, ➢ Les tableaux ;
Algorithmique, Programmation, Langage de programmation ; ➢ Les matrices ou tableaux à plusieurs dimensions ;
➢ Etapes de résolution d’un problème en informatique ; Les Enregistrements.
➢ Etape de production d’un algorithme et structure générale d’un al-
gorithme.
II. Matérialisation algorithmique des instructions élémentaires et des § SCEANCE 6 : Travaux Dirigés
instructions de contrôle (Début)
➢ Instructions élémentaires. § COURS 7 : Notions de base de la programmation en langage C
§ COURS 2 : ➢ Historique des langages de programmation ;

➢ Installation des outils.
I. Matérialisation algorithmique des instructions élémentaires et des
➢ Instructions élémentaires (Les types de base du langage, Les va-
instructions de contrôle (Fin) riables et constantes, Principales fonctions d’entrées-sorties stan-
➢ Les structures de contrôle de type conditionnel ; dard) ;
➢ Les structures de contrôle de type itératif ou répétitif (Les boucles) ➢ Les structures de contrôle (Structures conditionnelles, Structures ré-
pétitives).
§ SCEANCE 3 : Travaux Dirigés
§ COURS 8 : Travaux Dirigés (préparation de l’examen)
§ SCEANCE 4 : Les sous programmes en algorithmique (Début)
➢ Définition et déclaration des procédures et fonctions ;
➢ Appel et transmission des paramètres d’un sous-programme ;
Notion de variables locales et de variables globales.
Cours Algorithmique & programmation
Table des matières

Chapitre 1 : ................................................................................................................................................ 7
Introduction et généralités sur l’algorithmique et la programmation ................... 7
I. Contextes scientifiques et définitions des concepts .........................................................................7
1. Informatique...................................................................................................................................7
2. Algorithmique ................................................................................................................................7
3. Programmation ..............................................................................................................................8
II. Résolution d’un problème en informatique .................................................................................9
III. Etape de production d’un algorithme et structure générale d’un algorithme ...................... 10
1. Le concept objet .......................................................................................................................... 10
2. Etapes de production d’un algorithme...................................................................................... 10
3. Dossier algorithmique ................................................................................................................. 12
4. La structure générale d’un algorithme ..................................................................................... 13
Chapitre 2 : .............................................................................................................................................. 14
Algorithmique : Les instructions élémentaires et les instructions de contrôle
....................................................................................................................................................................... 14
I. Instructions élémentaires ............................................................................................................... 14
1. Les variables ................................................................................................................................ 14
2. Les types de données de base ..................................................................................................... 14
3. Déclaration d’une variable ......................................................................................................... 14
4. Opérations et opérateurs de base .............................................................................................. 15
5. Entrées-sorties (lecture ou la saisie - écriture ou l’affichage) ................................................. 16
II. Les structures de contrôle .......................................................................................................... 16
1. Conditions et tests ....................................................................................................................... 17
2. Structures conditionnelles .......................................................................................................... 18
3. Structures répétitives .................................................................................................................. 19
Chapitre 3 : .............................................................................................................................................. 21
Algorithmique : Les sous programmes et les structures de données .................... 21
I. Les sous-programmes (procédures et fonctions) .......................................................................... 21
1. Définition ..................................................................................................................................... 21
2. Déclaration des sous-programmes............................................................................................. 21
3. Représentation détaillée des sous-programmes........................................................................ 21
i. Les fonctions ................................................................................................................................ 21
ii. Les procédures ............................................................................................................................ 22
4. Appel et transmission des paramètres d’un sous-programme................................................ 23
PROPOSE PAR DIFFOUO TAZO EVARISTE 5
5. Notion de variables locales et de variables globales ................................................................. 23

6. Récursivité ................................................................................................................................... 23
II. Les structures de données élémentaires .................................................................................... 25
1. Les tableaux ................................................................................................................................. 25
2. Les matrices ou tableaux à plusieurs dimensions..................................................................... 25
i. Traitements opérants sur les tableaux ...................................................................................... 26
3. Enregistrements .......................................................................................................................... 26
Chapitre IV : ............................................................................................................................................. 28
Notions de base de la programmation en langage en C ................................................... 28
Introduction ............................................................................................................................................. 28
I. Historique, avantages du C et les grandes étapes de la création d'un programme en C .......... 29
1. Historique .................................................................................................................................... 29
2. Les avantages du langage C ....................................................................................................... 30
3. Les grandes étapes de la création d'un programme C............................................................. 30
II. Les unités lexicales et la structure générale d’un programme en C ....................................... 31
1. Les unités lexicales ...................................................................................................................... 31
2. La structure générale d’un programme C ................................................................................ 31
III. Présentation des directives du préprocesseur et de quelques bibliothèques standards ........ 32
1. Des directives du préprocesseur ................................................................................................ 32
2. Présentation de quelques bibliothèques standards .................................................................. 33
III. Instructions élémentaires et de contrôle ................................................................................... 35
1. Description des unités lexicales .................................................................................................. 35
2. Les types de base du langage C .................................................................................................. 38
3. Les variables ................................................................................................................................ 39
4. Les constantes .............................................................................................................................. 40
5. Principales fonctions d’entrées-sorties standard ..................................................................... 41
IV. Les structures de contrôle .......................................................................................................... 43
1. Structures conditionnelles .......................................................................................................... 43
2. Structures répétitives .................................................................................................................. 44

Chapitre 1 :
Introduction et généralités sur l’algorithmique
et la programmation
I. Contextes scientifiques et définitions des concepts
1. Informatique
Le terme informatique est un néologisme proposé en 1962 par Philippe Dreyfus pour caractériser le
traitement automatique de l’information : il est construit sur la contraction de l’expression « infor-
mation automatique ». Ce terme a été accepté par l’Académie française en avril 1966.
Définition 1 : informatique
L’informatique est la science du traitement automatique et rationnel de l’information à l’aide d’un
ordinateur.
Définition 2 : ordinateur
Un ordinateur est une machine de traitement automatique de l’information. Il est capable d’acquérir
de l’information, de la stocker, de la transformer en effectuant des traitements quelconques, puis de
la restituer sous une autre forme.
L’informatique traite de deux aspects complémentaires : les programmes immatériels (logiciel,
software) qui décrivent un traitement à réaliser et les machines (matériel, hardware) qui exécutent
ce traitement.
Définition 3 : matériel informatique
Le matériel informatique est un ensemble de dispositifs physiques utilisés pour traiter automatique-
ment des informations.
Définition 4 : logiciel
Un logiciel est un programme ou ensemble de programme informatique conçu pour la résolution
d’un problème précis à partir d’un ordinateur.
Dans ce cours, nous ne nous intéresserons qu’aux aspects logiciels de l’informatique. Avant
l’écriture d’un programme, il faut avoir mis au point un algorithme de résolution du problème.
2. Algorithmique
Chacun de nous a déjà été confronté un jour à un mode d’emploi pour faire fonctionner un appareil
plus ou moins réticent et donc, consciemment ou non, a déjà exécuté un algorithme.
Définition 5 : algorithme
Un algorithme est une suite finie et ordonnée d’instructions décrivant de façon exhaustive le pro-
cessus de résolution d’un problème donnée dans un intervalle de temps donné. En d’autres termes,

un algorithme est une suite finie d’opérations élémentaires constituant un schéma de calcul ou de
résolution d’un problème.
Définition 6 : algorithmique
L’algorithmique est la science qui a pour objectif la conception des algorithmes. En d’autres termes,
c’est l’ensemble des règles et techniques utilisées pour la définition et la conception des algorithmes.
L’algorithmique s’intéresse à l’art de construire des algorithmes ainsi qu’à caractériser leur
validité, leur robustesse, leur réutilisabilité, leur complexité ou leur efficacité.
Définition 7 : validité d’un algorithme
La validité d’un algorithme est son aptitude à réaliser exactement la tâche pour laquelle il a été
conçu.
Définition 8 : robustesse d’un algorithme
La robustesse d’un algorithme est son aptitude à se protéger de conditions anormales d’utilisation.
Définition 9 : réutilisabilité d’un algorithme
La réutilisabilité d’un algorithme est son aptitude à être réutilisé pour résoudre des tâches équiva-
lentes à celle pour laquelle il a été conçu.
Définition 10 : complexité d’un algorithme
La complexité d’un algorithme est le nombre d’instructions élémentaires à exécuter pour réaliser la
tâche pour laquelle il a été conçu.
Définition 11 : efficacité d’un algorithme
L’efficacité d’un algorithme est son aptitude à utiliser de manière optimale les ressources du maté-
riel qui l’exécute.
Quand on définit un algorithme, celui-ci ne doit contenir que des instructions compréhen-
sibles par celui qui devra l’exécuter. Dans ce cours, nous devrons apprendre à définir des algo-
rithmes pour qu’ils soient compréhensibles et donc exécutables par un ordinateur. La programma-
tion a alors pour rôle de traduire cet algorithme dans un langage « compréhensible » par l’ordinateur
afin qu’il puisse exécuter l’algorithme automatiquement
3. Programmation
Un algorithme exprime la structure logique d’un programme informatique et de ce fait est indépen-
dant du langage de programmation utilisé. Par contre, la traduction de l’algorithme dans un langage
particulier dépend du langage choisi et sa mise en œuvre dépend également de la plateforme d’exé-
cution.
Un programme n’est rien d’autre qu’une suite d’instructions, encodées en respectant de manière très
stricte un ensemble de conventions fixées à l’avance par un langage informatique. Le seul « langage

» que l’ordinateur puisse véritablement « comprendre » est donc très éloigné de ce que nous utilisons
nous-mêmes. C’est une suite de 0 et de 1 (les « bits », binary digit) traités par groupes de 8 (les «
octets », byte), 16, 32, ou même 64. Pour « parler » à un ordinateur, il nous faudra donc utiliser des
systèmes de traduction automatiques, capables de convertir en nombres binaires des suites de ca-
ractères formant des mots-clés qui seront plus significatifs pour nous. Le système de traduction
proprement dit s’appellera interpréteur ou bien compilateur, suivant la méthode utilisée pour effec-
tuer la traduction.
Définition 12 : compilateur
Un compilateur est un programme informatique qui traduit un langage, le langage source, en un
autre, appelé le langage cible.
Définition 13 : interpréteur
Un interpréteur est un outil informatique (logiciel ou matériel) ayant pour tâche d’analyser et d’exé-
cuter un programme écrit dans un langage source.
Définition 14 : langage de programmation
Un langage de programmation est un langage informatique, permettant à un humain d’écrire un code
source qui sera analysé par un ordinateur.
Définition 15 : programmation
La programmation est l’activité de rédaction du code source d’un programme.
II. Résolution d’un problème en informatique
Résoudre un problème en utilisant un ordinateur comporte plusieurs étapes : la spécification des

besoins, l’algorithme (l’analyse, la conception), le codage (dans un langage de programmation
donné), les tests et la maintenance.
Problèmes Spécification
des besoins
Validation
Ecriture des algo- Analyse Méthodes de

rithmes résolution
(70% du travail) Conception Structures

de données
Codage Programme
Test et
Maintenance
Résultat

III. Etape de production d’un algorithme et structure générale d’un algorithme
La démarche à suivre pour produire un algorithme comporte plusieurs étapes. Avant de voir ces
étapes, nous devons appréhender le concept d’objet.
1. Le concept objet
La matière première manipulée en informatique est l’information. Celle-ci se présente sous forme
de données.
Une donnée est une valeur stockée en mémoire centrale d’un ordinateur dans un objet.
Un objet est un récipient utilisé par le processeur pour stocker les informations ou les données
nécessaire à la résolution d’un problème. Chaque objet est caractérisé par son nom et son type.
i. Le nom d’un objet
Encore appelé identificateur, le nom permet d’identifier un objet dans un algorithme. Il est conseillé
de choisir des noms significatifs pour nos objets.
ii. Le type d’un objet
Le type indique l’ensemble dans lequel un objet prend ses valeurs. Il indique aussi les opérations
qui doivent être réalisées sur cet objet. On distingue plusieurs types :
➢ Le type entier
C’est le type qui prend ses valeurs dans l’ensemble Z. Les opérations possibles ici sont : l’addition,
la soustraction, la multiplication et la division.
➢ Le type réel
C’est le type qui prend ses valeurs dans l’ensemble R. Les opérations possibles ici sont : l’addition,
la soustraction, la multiplication et la division.
➢ Le type caractère
C’est l’ensemble constitué des lettres (’a’, ‘b’ … ’z’, ’A’, ’B’ … ‘Z’), des chiffres (‘0’, ‘1’ … ’9’)
et des caractères spéciaux (’#’, ’*’ … ‘+’). La seule opération possible ici est la concaténation +
(Exemple : ’a’+ ‘b’ = ‘ab’ et ’3’+ ‘4’ = ‘34’).
➢ Le type chaine de caractère
C’est une combinaison des caractères placés entre côtes (’’abc’’, ‘’toto2’’ … ’’Bonjour’’,
’’PAPA’’). La seule opération possible ici est la concaténation + (Exemple : ’’Bonjour’’+
‫ٮ‬+’’PAPA’’= ’’Bonjour PAPA’’).
➢ Le type booléen
C’est l’ensemble constitué des valeurs {Vrai, Faux} ou {1, 0}. Les opérations possibles ici sont :
ET, OU, NON.
2. Etapes de production d’un algorithme
i. Définition des objectifs

Pour produire un algorithme, il est important de répondre aux questions suivantes :
▪ Qu’est-ce qu’on me demande de faire ?
▪ Quelle est le travail à fournir ?
En général, l’énoncé fait ressortir les objectifs à atteindre.
ii. Spécification d’une méthode de résolution

Il s’agit ici de dire sans entrer dans les détails comment le problème sera résolu ? (Méthode de
résolution). La spécification peut se faire par des courtes phrases en langage naturel (français, an-
glais…). Elle peut aussi se faire à l’aide des symboles mathématiques et dans ce cas on parle de
spécification formelle.
En général, il est important ici de répondre aux questions suivantes :
▪ Comment dois-je procéder pour résoudre ce problème ?
▪ Quelle est la méthode à utiliser pour obtenir la solution à ce problème ?
iii. Mise en œuvre de la méthode retenue

Elle consiste à donner les structures de données appropriées. Une structure de données est un objet
qui renferme les informations nécessaires au déroulement de l’algorithme avant, pendant et après la
réalisation de cet algorithme.
Le choix d’une structure de données dépend généralement de l’ordre des valeurs des données
à manipuler et de la structuration des informations recueillies sur le problème. Il est possible de
résoudre le même problème avec des structures de données complètement différentes. Le problème
est alors de savoir quelle est l’avantage de la structure de données utilisée par rapport aux autres.
Cette phase se termine par l’écriture d’un algorithme à l’aide d’un pseudo-langage de programma-
tion. Il ne s’agit bien sûr pas d’un langage de programmation de haut niveau tel que le Pascal, le C
ou le Java mais plutôt d’un langage visuel.
iv. Le test de l’algorithme

Il a pour objectif de vérifier que cet algorithme marche et qu’il fournit des bons résultats. Il faut
toujours vérifier à l’aide de quelques données choisies au hasard. Le test se fait en déroulant l’algo-
rithme à la main avec un stylo et un papier. Cette démarche est appelée trace de l’algorithme. La
trace de l’algorithme représente les différentes valeurs des différents objets d’un programme durant
son exécution.

Il faut cependant noter que le fait qu’un algorithme fonctionne correctement avec quelques données
ne suffit pas pour confirmer sa validité.
La démarche de la conception d’un algorithme est généralement résumée dans un dossier
appelé dossier algorithmique.
3. Dossier algorithmique
C’est un document qui résume la démarche utilisée pour produire un algorithme. Il comporte trois
parties :
i. L’énoncé du problème
Il s’agit de dire de clairement en quoi consiste le problème à résoudre.
ii. Le principe de résolution
Il s’agit de dire en utilisant le langage naturel ou des symboles mathématiques comment le problème
sera résolu.
iii. L’environnement
Il est constitué par l’ensemble des objets que l’on utilise pendant le déroulement de l’algorithme.
Les objets contiennent en général des données du problème, les résultats intermédiaires et les résul-
tats finaux.
Pour chaque objet, l’environnement doit indiquer :
- Son nom identificateur ;
- Son type ;
- Sa nature ;
- Son utilisateur ;
- Sa valeur initiale ;
- Sa valeur finale ;
- Son sens.
Tous ces éléments sont rangés dans un tableau de la manière suivante :
Nom Type Nature Utilisateur Valeur initiale Valeur finale Sens
Exemple : Elaborer le dossier algorithmique permettant de lire 02 nombres entiers et de calculer

leur somme et la moyenne.

Nom Type Nature Utilisateur Valeur initiale Valeur finale Sens
X Entier Variable Entrée / / 1er entier

Y Entier Variable Entrée / / 2ème entier
S Entier Variable Sortie / / Somme
C Entier Constante Intermé- 2 2 Diviseur
Moyenne Réel Variable diaire / / Moyenne
Sortie
4. La structure générale d’un algorithme

Un algorithme est caractérisé par :
• Une partie entête : Définie par le terme réservé ALGORITME suivi du nom de l’algo-
rithme.
• Une partie déclarative : qui permet à l’ordinateur de réserver un espace mémoire à chaque
nom d’objet. Les objets peuvent être des constantes, des variables ou des types prédéfinis.
• Une partie du corps de l’algorithme : qui comporte la suite des instructions contenu entre
deux termes DEBUT et FIN.
La structure générale d’un algorithme est la suivante :
Algorithme Nom_algorithme
Déclarations (constantes; variables ; type ;sous programmes…)
Début
Instruction 1;
…
Instruction n;
Fin
Exemple : Ecrire un algorithme qui va lire deux nombres entiers, calcule leur somme et leur pro-
duit.
Algorithme SommeProduit
Var a,b,s,p : entier ;
Debut
Ecrire("Donnez vos deux nombres") ;
Lire(a, b);
s=a+b;
p=a*b;
Ecrire ("la somme des deux nombres est : ",s);
Ecrire ("le produit des deux nombres est : ",p);
Fin

Chapitre 2 :
Algorithmique : Les instructions élémentaires
et les instructions de contrôle
I. Instructions élémentaires
1. Les variables
Une variable est un objet informatique qui associe un nom à une valeur qui peut éventuellement
varier au cours du temps.
2. Les types de données de base
• Le type chaîne de caractère : c’est le type qui sera utilisé pour stocker des chaînes de caractère.
3. Déclaration d’une variable

4. Opérations et opérateurs de base

➢ L’affectation
Le nom de la variable à modifier est placé dans le membre de gauche du signe ←, la valeur qu’on
veut lui attribuer dans le membre de droite. Le membre de droite de l’affectation est d’abord évalué
sans être modifié puis la valeur obtenue est affectée à la variable dont le nom est donné dans le
membre de gauche de l’affectation ; ainsi, cette opération ne modifie que le membre de gauche de
l’affectation. Le membre de droite peut être une constante ou une expression évaluable.
➢ La constante
➢ Opérateurs arithmétiques et expressions

5. Entrées-sorties (lecture ou la saisie - écriture ou l’affichage)
NB : AFFICHER peut-être remplacé par ECRIRE.
NB : SAISIR peut-être remplacé par LIRE.

II. Les structures de contrôle

1. Conditions et tests
❖ Les opérateurs booléens
❖ Les opérateurs ou connecteurs logiques

2. Structures conditionnelles
❖ Structure SI … ALORS
❖ Structure SI … ALORS …SINON
❖ Structure SELON
Exemple : Partie de l’Algorithme de choix de l’abréviation
Cet algorithme est l’équivalent de :

3. Structures répétitives
i. Structure TANTQUE … FAIRE
ii. Structure FAIRE … TANTQUE ou REPETER … TANTQUE
iii. Structure POUR … FAIRE


Chapitre 3 :
Algorithmique : Les sous programmes et
les structures de données
I. Les sous-programmes (procédures et fonctions)
1. Définition
2. Déclaration des sous-programmes
3. Représentation détaillée des sous-programmes

i. Les fonctions

ii. Les procédures

4. Appel et transmission des paramètres d’un sous-programme
5. Notion de variables locales et de variables globales
6. Récursivité
Une fonction ou une procédure est dite récursive si elle s’appelle elle-même : on parle alors d’appel
récursif de la fonction.

Explication des exemples précédents

II. Les structures de données élémentaires

Un programme peut être amené à manipuler de nombreuses variables représentant des valeurs dis-
tinctes mais de même nature. Il est donc difficilement envisageable de définir « manuellement »
autant de variables que de valeurs à stocker. Les tableaux, en informatique, permettent de résoudre
ce problème en proposant la création de plusieurs variables de même type, d’une manière très com-
pacte.
1. Les tableaux
La syntaxe de déclaration d’un tableau est la suivante :
2. Les matrices ou tableaux à plusieurs dimensions
Définition :

Exemple : fonction qui retourne la somme de deux matrices
i. Traitements opérants sur les tableaux
3. Enregistrements
Exemple :
NOTE :


Chapitre IV :
Notions de base de la programmation en langage en C
Introduction
Avant les années 1950, on programmait directement les ordinateurs en langage machine. Un langage
machine est une suite d’instructions codées sur des mots de 32 bits pour le MIPS (million d’instruc-
tions par seconde mais ici il s’agit d’un microprocesseur). La programmation n’étant pas évidente
en langage machine, on a essayé d’améliorer le travail du programmeur.
En premier lieu on a donné des informations symboliques appelées mnémoniques aux instructions
machines. Ce qui a donné naissance au langage assembleur. Ce langage assembleur contient des
instructions faisant intervenir les registres de l'unité centrale de l'ordinateur ainsi que les données.
Ensuite on a introduit des étiquettes dans le langage d'assemblage dans le but de faciliter les bran-
chements conditionnels (boucles, sauts), cela a donné des instructions de la forme BRANCH. Enfin
on a exprimé directement des emplacements mémoires en leur donnant un nom symbolique à la
place de l’adresse en hexadécimal.
L’étape suivante a consisté à s’affranchir complètement de la machine en élaborant ce que l’on

appelle des langages de haut niveau à partir de 1950. Ces langages ont introduit un certain nombre
de constructions qui n’existent pas dans le langage machine (expressions arithmétiques, les notions
de variable, de procédure, de fonction et des structures de données). Dès 1970 sont apparue des
langages à objets qui ont introduit à leur tour des notions de : Classes, objets, méthodes, variables
d’instances, l’héritage et le polymorphisme.
Or ces langages de haut niveau et à objets ne sont pas compris par l’ordinateur. Il a fallu donc
construire des programmes qui traduisent des énoncés exprimés dans ces langages utilisés par les
programmeurs en instructions pour la machine cible. De tels programmes s’appellent des compila-
teurs ou des interpréteurs, suivant la méthode utilisée pour effectuer la traduction.
o L’interpréteur traduit les programmes instruction par instruction dans le cadre d’une interac-
tion continue avec l’utilisateur. Ainsi, le programme est traduit à chaque exécution.
o Le compilateur traduit les programmes dans leur ensemble : tout le programme doit être
fourni en bloc au compilateur pour la traduction. Il est traduit une seule fois dans l’optique de pro-
duire un exécutable.

Ci-dessous une liste non exhaustive des langages de programmation existants avec leur pourcentage
d’utilisation actuel.
I. Historique, avantages du C et les grandes étapes de la création d'un programme

en C
1. Historique
Le principe de résolution d’un problème informatique est appelé algorithme. Cet algorithme ex-
prime la structure logique d’un programme informatique et de ce fait est indépendant du langage de
programmation utilisé. Par contre, la traduction de l’algorithme dans un langage particulier dépend
du langage choisi et sa mise en œuvre dépend également de la plateforme d’exécution.
Un programme n’est rien d’autre qu’une suite d’instructions, encodées en respectant de manière très
stricte un ensemble de conventions fixées à l’avance par un langage informatique.
Le langage C a été conçu pour l'écriture de systèmes d’exploitation, en particulier le système Unix.
Ce langage a subi au cours de son histoire deux grandes étapes de définition. Il a été défini une
première fois par deux chercheurs des Laboratoires Bell, Brian Kernighan et Dennie Ritchie, qui
l’on publié en 1978 dans un ouvrage intitulé « The C Programming Language ».
Suite à l'extraordinaire succès d’Unix au milieu des années 1980, le langage C structuré et très
proche du langage machine était devenu très populaire. De nombreux compilateurs sont apparu mais
présentant des incompatibilités. Face à ce désordre des fournisseurs de compilateurs il devint néces-
saire de mettre de l'ordre et donc de normaliser le langage. Pour accomplir cette tâche, l’organisme

de normalisation américain, ANSI (American National Standards Institute) avait publié en 1988 le
manuel de référence du langage C.
En 1990, l’organisme de normalisation international, l'ISO (International Standards Organi-

zation), adopta tel quel le standard ANSI en tant que standard ISO. Cette seconde version du langage
C avait eu pour nom : Norme ISO C.
2. Les avantages du langage C
Le langage C est un langage aux caractéristiques suivantes :
o Il est portable. C’est-à-dire qu’il s’exécute sur toutes les plates-formes ;

o Il est indépendant de la machine ;
o Il est polyvalent. C’est-à-dire qu’il permet le développement des systèmes d’exploitation,
des programmes scientifiques, des programmes de gestion… ;
o Il est structuré et évolué : il permet le développement d’opérations de bas niveau comme le
langage Assembleur ;
o Il est compact, rapide et extensible ;
o C’est le père syntaxique du C++, du Java et du PHP.
NB : Dès que l’on utilise des bibliothèques externes, la portabilité des programmes en C devient
difficile.
3. Les grandes étapes de la création d'un programme C
La manière de développer et d'utiliser un programme en langage C dépend naturellement de l’envi-

ronnement de programmation dans lequel vous travaillez. Généralement, les grandes étapes de la
création d'un programme sont: édition du programme, la compilation et édition de liens.
i. L'édition du programme
L'édition du programme consiste à créer, à partir d'un clavier et dans un éditeur de texte quelconque
le texte d'un programme: on parle alors de "programme source". En général, ce texte sera conservé
dans un fichier que l'on nommera avec l’extension ‘’.c’’.
ii. La compilation
Elle consiste à traduire le programme source (le contenu d'un fichier source) en langage machine,
en faisant appel à un programme nommé compilateur. Les compilateurs C font subir deux transfor-
mations aux programmes :

➢ un préprocesseur qui réalise des transformations d'ordre purement textuel, pour rendre des
services du type inclusion de source, compilation conditionnelle, et traitement de macros ;
➢ le compilateur proprement dit qui prend le texte généré par le préprocesseur et le traduit
en instructions machine. La compilation crée automatiquement d’autres fichiers ayant le
même nom que le fichier source mais qui diffèrent avec l’extension.
iii. L'édition de liens
Le module objet créé par le compilateur n'est pas directement exécutable. Il lui manque, au moins,
les différents modules objet correspondant aux fonctions prédéfinies (on dit aussi "fonctions stan-
dard") utilisées par votre programme (comme printf, scanf, sqrt). C'est effectivement le rôle de l'édi-
teur de liens que d'aller rechercher dans la "bibliothèque standard" les modules objet nécessaires.
Le résultat de l'édition de liens est ce que l'on nomme un "programme exécutable", c'est-à-dire un
ensemble autonome d'instructions en langage machine. Si ce programme exécutable est rangé dans
un fichier, il pourra ultérieurement être exécuté sans qu'il soit nécessaire de faire appel à un quel-
conque composant de l'environnement de programmation en C.
II. Les unités lexicales et la structure générale d’un programme en C
1. Les unités lexicales

Le langage C n'impose pas un jeu de caractères particulier. Par contre tout le langage (mots-clés,
opérateurs, etc.) est défini en utilisant les caractères ascii. Même les identificateurs doivent être
écrits avec l'alphabet anglais. Par contre, le jeu de caractères utilisé pour les constantes, les carac-
tères, les chaines de caractères et les commentaires est dépendant de l'implémentation.
Le langage C comprend 6 types d'unités lexicales : les mots-clés, les identificateurs, les cons-
tantes, les chaînes, les opérateurs et les signes de ponctuation.
2. La structure générale d’un programme C

De manière générale, un programme C consiste en la construction de blocs individuels appelés fonc-
tions qui peuvent s’invoquer l’un l’autre. Chaque fonction réalisant une tâche précise.
Pour pouvoir s’exécuter, un programme C doit contenir une fonction spéciale appelée main
(int main() ou int main(int argc, char *argv[])) qui sera le point d’entrée de l’exécution (c’est à
dire la première fonction invoquée au démarrage de l’exécution). Il existe aussi dans un programme
C, des lignes spéciales que l'on ne voit qu'en haut des fichiers source. Ces lignes sont facilement
reconnaissables car elles commencent par un dièse(#). Ces lignes spéciales, sont appelées directives
de préprocesseur. Ce sont des lignes qui seront lues par un programme appelé préprocesseur, un
programme qui se lance au début de la compilation.

La structure générale d’un programme en C est la suivante :
Un programme C peut comporter également la déclaration de variables qui correspondent à des

emplacements en mémoire.
Exemple : Ecrire un algorithme qui va lire deux nombre entiers, calcule leur somme et leur pro-
duit.
#include <stdio.h>
int main()
{ int a,b,s,p;
printf("Donnez vos deux nombres\n") ;
scanf("%d %d", &a, &b);
s=a+b; p=a*b;
printf("la somme des deux nombres est : %d\n",s);
printf("le produit des deux nombres est : %d",p);
return 0;
}
III. Présentation des directives du préprocesseur et de quelques bibliothèques
standards
1. Des directives du préprocesseur
Nous avons vu précédemment que la première phase de la compilation d’un code source en langage
C est le traitement par le préprocesseur. Le préprocesseur est donc un programme exécuté lors de la
première phase de la compilation. Il effectue des modifications textuelles sur le fichier source à
partir de directives. Les différentes directives au préprocesseur, introduites par le caractère #, ont
pour but :
– l’incorporation de fichiers source (#include),
– la définition de constantes symboliques et de macros (#define),
– la compilation conditionnelle (#if, #ifdef,...).
i. La directive #include
Elle permet d’incorporer dans le fichier source le texte figurant dans un autre fichier. Ce dernier
peut être un fichier en-tête de la librairie standard (stdio.h, math.h,...) ou n’importe quel autre fichier.

La directive #include possède deux syntaxes voisines : La prémiere : #include <nom-de-

fichier> recherche le fichier mentionné dans un ou plusieurs répertoires systèmes définis par l’im-
plémentation (typiquement /usr/include/). La seconde #include "nom-de-fichier" recherche le fichier
dans le répertoire courant (celui où se trouve le fichier source).
La première syntaxe est généralement utilisée pour les fichiers en-tête de la librairie standard, tandis
que la seconde est plutôt destinée aux fichiers crées par l’utilisateur.
ii. La directive #define
La directive #define permet de définir des constantes symboliques (on parle aussi de macros sans
paramètres) ou des macros avec paramètre. Lorsque le préprocesseur lit une ligne du type : #define
NOM valeur ; il remplace dans toute la suite du code source toute nouvelle occurrence de NOM
par valeur. Il n’y a aucune contrainte quand à ce qui peut se trouver dans valeur.
Exemple :
#define NB_LIGNES 24
#define NB_COLONNES 80
#define TAILLE_MATRICE NB_LIGNES * NB_COLONNES
iii. La compilation conditionnelle
La compilation conditionnelle a pour but d’incorporer ou d’exclure des parties du code source dans
le texte qui sera généré par le préprocesseur, le choix étant basé sur un test exécuté à la compilation.
Elle permet d’adapter le programme au matériel ou à l’environnement sur lequel il s’exécute, ou
d’introduire dans le programme des instructions de débuggage.
Les directives de compilation conditionnelle se répartissent en deux catégories, suivant le

type de la condition invoquée qui est testée : la valeur d’une expression et l’existence ou l’inexis-
tence de symboles
2. Présentation de quelques bibliothèques standards
Ci-dessous, une liste non exhaustive des fonctions de la bibliothèque standard (Les fichiers d’en -
tête de la librairie ANSI), accompagnées de leurs prototypes.
i. Les fonctions mathématiques de <math.h>
Pour utiliser les fonctions de cette librairie, il faut inclure la

librairie par la directive #include <math.h>. Le résultat et les paramètres de toutes ces fonctions
sont de type double. Nous avons ici :
- Les fonctions trigonométriques et hyperboliques

-
Les Fonctions exponentielles et logarithmiques
-
Les Fonctions diverses
ii. Entrées-sorties <stdio.h>

- Entrées et sorties formatées
- Manipulation de fichiers
- Impression et lecture de caractères

iii.
Utilitaires divers <stdlib.h>
➢ Allocation dynamique
➢ Conversion de chaînes de caractères en nombres
➢ Arithmétique sur les entiers
➢ Communication avec l’environnement
III. Instructions élémentaires et de contrôle

1. Description des unités lexicales
Le langage C comprend 6 types d'unités lexicales : les mots-clés, les identificateurs, les constantes,
les chaînes, les opérateurs et les caractères spéciaux (signes de ponctuation).
i. Les mots-clés
Le langage C est un langage à mots-clés, ce qui signifie qu'un certain nombre de mots sont réservés
pour le langage lui-même et ne peuvent donc pas être utilisés comme identificateurs. La liste ex-
haustive des mots-clés est la suivante :

ii. Les identificateurs

Le but d'un identificateur est de donner un nom à une entité du programme (variable, procédure,
etc.). Les identificateurs sont formés d'une suite de lettres, de chiffres et du signe souligné (unders-
core) ; suite dont le premier caractère est une lettre. Les identificateurs sont sensibles à la casse (La
majuscule est différente de la minuscule).
iii. Les constantes
➢ Les constantes entières
➢ Les constants caractères
➢ Les constantes flottantes
Exemple
iv. Les chaînes

v. Les opérateurs
Le langage C défini plusieurs types d’opérateurs : arithmétiques, relationnels ou de comparaisons,

logiques, d’affectation (affectation simple et affectation élargie), conditionnel et les opérateurs d’in-
crémentation et de décrémentation.

Ex.3
vi. Les signes de ponctuation (les caractères spéciaux)

On note les caractères spéciaux (non imprimables) en commençant par \.
2. Les types de base du langage C

i. Le type entier
Le nombre d'octets utilisés pour coder un entier peut être un paramètre de compilation, selon la
plate-forme utilisée. Le mot clé int est utilisé pour caractériser des entiers. Il existe deux types d’at-
tributs pour le type entier : les attributs de précision et les attributs de représentation.
Les attributs de précision sont : - short int ou short : entier codé sur 2 octets avec pour format
d'affichage : %d (ou %hd) ;- int: entier codé sur 2 ou 4 octets avec pour format d'affichage : %d et
- long int ou long : entier codé sur 4 octets avec pour format d'affichage : %ld.
Les attributs de représentation encore appelés unsigned sont des entiers non signés. Ce sont :
unsigned short int codé sur 2 octets et de format d'affichage : %u ; unsigned int codé sur 2 ou 4

octets et de format d'affichage : %u et unsigned long int ou unsigned long : entier long positif
avec pour format d'affichage : %lu. Le tableau suivant détaille les informations pour chaque type
entier.
ii. Le type flottant ou réel :
Les formats d'affichage sont respectivement: %f, %lf, %l. Les constantes numériques sont
par défaut de type double. Ci-dessous les informations pour chaque type flottant.
iii. Le type Caractère
Le
format d'affichage est %c pour les caractères et %s pour les chaînes de caractères. Le tableau
suivant détaille les informations pour chaque type caractère.
3. Les variables
Une variable est un objet informatique qui associe un nom à une valeur qui peut éventuelle-
ment varier au cours du temps.

Des données qui ne changent plus dans le programme, une fois initialisées sont appelées des
constantes.
4. Les constantes
i. Les #define
ii. Les énumérations

5. Principales fonctions d’entrées-sorties standard

Il s’agit des fonctions de la librairie standard stdio.h utilisées avec les unités classiques d’entrées-
sorties, qui sont respectivement le clavier et l’écran. Sur certains compilateurs, l’appel à la librairie
stdio.h par la directive au préprocesseur #include <stdio.h> n’est pas nécessaire pour utiliser les
fonctions présentées ici, notamment printf et scanf.
➢ Les fonctions d’entrées
i. La fonction de saisie scanf
ii. La fonction getchar

➢ Les fonctions de sortie
i. La fonction d’écriture à l’écran formatée printf
ii. La fonction puts
iii. La fonction putchar
NB : Il existe d’autres fonctions d’entrées/sorties permettant notamment la manipulation des

fichiers qui seront abordées dans le chapitre sur les fichiers.

IV. Les structures de contrôle
1. Structures conditionnelles
i. Structure IF
La syntaxe est la suivante : if (condition) {

/* si la condition est vraie */
if (condition)
instruction 1 ;
/* si la condition est vraie */ ou ...
instruction ;
instruction n ;
}
ii. Structure IF … ELSE
if (condition) {
/* si la condition est vraie */
if (condition) instruction1 1
...
/* si la condition est vraie */ ou instruction1 n
instruction1 ; } else {
else
/* si la condition est fausse */ /* si la condition est fausse */
instruction2 ; instruction2 1
...
instruction2 n
}
iii. Structure SWITCH

2. Structures répétitives
iv. Structure « while »

while (expression )
{
while (expression) instruction 1 ;
ou
...
instruction ;
instruction n ;
}
v. Structure « do…while »
Do
{
Do instruction 1 ;
ou
instruction ; ...
instruction n ;
while (expression ); }
while (expression );

vi. Structure « For »
for (expr 1 ;expr 2 ;expr 3)

for (expr 1 ;expr 2 ;expr 3) {
ou instruction 1 ;
instruction ; ...
instruction n ;
}
Cette boucle comporte trois expressions : expr 1 ; expr 2 et expr 3. La première, expr 1 est évaluée
(une seule fois) avant d’entrer dans la boucle : c’est l’initialisation du compteur. La deuxième, expr
2 conditionne la poursuite de la boucle. Elle est évaluée avant chaque parcours. La troisième, expr
3 enfin, est évaluée à la fin de chaque parcours.

Cours Algoritmique & Programmation

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Algoritmique & Programmation

Transféré par

Droits d'auteur :

Formats disponibles

Cycle : BACHELOR

ANNEE ACADEMIQUE 2022-2023

Nom (s) et prénom (s) : DIFFOUO TAZO Evariste

Grade ou Qualification : Ingénieur Informaticien & Doctorant

Téléphone : (+237) 697 481 969 / (+237) 677 268 237

Courriel : evaristetazo@gmail.com / evariste_tazo@yahoo.fr

Quotas horaire semestriel prévus : 32 heures

À la fin de cet enseignement, l’étudiant doit être capable de :

§ COURS 2 : ➢ Historique des langages de programmation ;

Table des matières

5. Notion de variables locales et de variables globales ................................................................. 23

PROPOSE PAR DIFFOUO TAZO EVARISTE 6

PROPOSE PAR DIFFOUO TAZO EVARISTE 7

PROPOSE PAR DIFFOUO TAZO EVARISTE 8

Résoudre un problème en utilisant un ordinateur comporte plusieurs étapes : la spécification des

Ecriture des algo- Analyse Méthodes de

(70% du travail) Conception Structures

PROPOSE PAR DIFFOUO TAZO EVARISTE 9

III. Etape de production d’un algorithme et structure générale d’un algorithme

i. Définition des objectifs

ii. Spécification d’une méthode de résolution

iii. Mise en œuvre de la méthode retenue

iv. Le test de l’algorithme

PROPOSE PAR DIFFOUO TAZO EVARISTE 11

Exemple : Elaborer le dossier algorithmique permettant de lire 02 nombres entiers et de calculer

PROPOSE PAR DIFFOUO TAZO EVARISTE 12

Nom Type Nature Utilisateur Valeur initiale Valeur finale Sens

X Entier Variable Entrée / / 1er entier

4. La structure générale d’un algorithme

La structure générale d’un algorithme est la suivante :

PROPOSE PAR DIFFOUO TAZO EVARISTE 13

2. Les types de données de base

3. Déclaration d’une variable

PROPOSE PAR DIFFOUO TAZO EVARISTE 14

4. Opérations et opérateurs de base

➢ Opérateurs arithmétiques et expressions

PROPOSE PAR DIFFOUO TAZO EVARISTE 15

5. Entrées-sorties (lecture ou la saisie - écriture ou l’affichage)

NB : AFFICHER peut-être remplacé par ECRIRE.

NB : SAISIR peut-être remplacé par LIRE.

PROPOSE PAR DIFFOUO TAZO EVARISTE 16

❖ Les opérateurs booléens

❖ Les opérateurs ou connecteurs logiques

PROPOSE PAR DIFFOUO TAZO EVARISTE 17

❖ Structure SI … ALORS …SINON

Exemple : Partie de l’Algorithme de choix de l’abréviation

Cet algorithme est l’équivalent de :

PROPOSE PAR DIFFOUO TAZO EVARISTE 18

i. Structure TANTQUE … FAIRE

ii. Structure FAIRE … TANTQUE ou REPETER … TANTQUE

iii. Structure POUR … FAIRE

PROPOSE PAR DIFFOUO TAZO EVARISTE 19

PROPOSE PAR DIFFOUO TAZO EVARISTE 20

I. Les sous-programmes (procédures et fonctions)

2. Déclaration des sous-programmes

3. Représentation détaillée des sous-programmes

PROPOSE PAR DIFFOUO TAZO EVARISTE 21

ii. Les procédures

PROPOSE PAR DIFFOUO TAZO EVARISTE 22

4. Appel et transmission des paramètres d’un sous-programme

5. Notion de variables locales et de variables globales

PROPOSE PAR DIFFOUO TAZO EVARISTE 23

Explication des exemples précédents