Page - 1

Chapitre 1 : Introduction à la
programmation procé durale et au
langage C
Contents
I. Motivation : du langage machine aux langages évolués ................................................................. 1
1. Etapes de programmation ........................................................................................................... 1
2. Langages informatiques .............................................................................................................. 2
3. Langage machine et assembleur ................................................................................................. 2
4. Langages haut niveau .................................................................................................................. 3
II. La programmation procédurale ...................................................................................................... 3
III. Généralités sur le langage C ........................................................................................................ 4
1. Bref historique ............................................................................................................................. 4
2. Caractéristiques du langage C ..................................................................................................... 4
3. Structure d’un programme C....................................................................................................... 5
4. Des exemples............................................................................................................................... 7
5. Quelques règles d’écriture .......................................................................................................... 8

I. Motivation : du langage machine aux langages évolués

1. Etapes de programmation
Pour résoudre un problème réel sur une machine, plusieurs étapes sont nécessaires :

1. Analyser le problème (Comprendre la nature du problème posé, Préciser les données

d’entrée, Préciser les données de sortie, Déterminer les étapes de traitement, etc)
2. Ecrire la solution avec la notation algorithmique (structuré)
3. Traduire l’algorithme dans un langage de programmation (code source)
4. Compiler le code source (traduire en langage machine)
5. Générer un fichier exécutable directement par le processeur

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 2

2. Langages informatiques
• Un langage informatique est un outil permettant de donner des ordres (instructions) à la
machine
o chaque instruction correspond à une action du processeur
• Intérêt : écrire des programmes (suite consécutive d’instructions) destinés à effectuer une
tâche donnée
o Exemple: un programme de gestion de comptes bancaires
• Contrainte: être compréhensible par la machine

3. Langage machine et assembleur

• Langage binaire: l’information est exprimée et manipulée sous forme d’une suite de bits
• Un bit (binary digit) = 0 ou 1 (2 états électriques)
• Une combinaison de 8 bits = 1 Octet -> 28 possibilités qui permettent de coder tous les
caractères alphabétiques, numériques, et symboles tels que ?,*, &, …
• Les opérations logiques et arithmétiques de base (addition, multiplication, …) sont effectuées
en binaire
• Problème: le langage machine est difficile à comprendre par l'humain
• Idée: trouver un langage compréhensible par l'homme qui sera ensuite converti en langage
machine
o Assembleur : exprimer les instructions élémentaires de façon symbolique
ADD A, 5 ; on ajoute à A la valeur 5
LOAD B ; on charge le registre B
MOV A, 7 ; mettre 7 dans A
JMP label ; saut vers label

Après : traduction  langage machine

  déjà plus accessible que le langage machine

  dépend du type de la machine (n’est pas portable)

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 3

  pas assez efficace pour développer des applications complexes

• Apparition des langages évolués (haut niveau): langage très proche
du langage humain

4. Langages haut niveau

• Intérêts multiples pour les langages haut niveau:
o proches du langage humain «anglais» (compréhensible)
o permettent une plus grande portabilité (indépendant du matériel)
o Manipulation de données et d’expressions complexes (réels, objets, …)
• Nécessité d’un traducteur (compilateur/interpréteur), exécution plus ou moins lente selon le
traducteur

Code source en
Compilateur ou Langage machine
langage évolué
interpréteur

II. La programmation procédurale

• En informatique, la programmation procédurale est un paradigme qui se fonde sur le

concept d'appel procédural. Des procédures (ou des fonctions), contenant du code,
peuvent elles-mêmes être appelées par du code, suivant des enchaînements contrôlés.
 Un programme correspond à l’assemblage de plusieurs procédures/fonctions qui
s’appellent entre elles.
• Met l'accent sur les étapes pour réaliser une tâche : Le programme est la liste des tâches et
des opérations à exécuter.
• Attention : Tend à générer du code "Spaghetti"

• La maintenance et l'ajout de nouvelles fonctionnalités demandent de modifier ou

d'insérer des séquences dans ce qui existe déjà
• Peu devenir complexe très rapidement
• Réutilisation ardue => "Couper-coller" = DANGER!
• Travail d'équipe difficile (peu modulaire), donc la qualité du code en souffre

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 4

Figure 1 Illustration de la programmation procédurale

Contrairement à la programmation procédurale, il y a le paradigme orienté objet:

• On s'intéresse à modéliser le problème par un ensemble d'objets

• Le programme est l’ensemble des objets et des interactions entre ces objets

III. Généralités sur le langage C

1. Bref historique
- Le langage a été créé en 1972 dans «Bell Laboratories » par Dennis Ritchie avec l’objectif
d’écrire un système d'exploitation (UNIX).
- En 1978, une première définition rigoureuse du langage C (standard K&R-C) a été réalisée par
Kernighan et Ritchie en publiant le livre «The C Programming Language ».
- Le C devenant de plus en plus populaire dans les années 80, plusieurs groupes mirent sur le
marché des compilateurs comportant des extensions particulières. En 1983, l’ANSI (American
National Standards Institute) décida de normaliser le langage ; ce travail s’acheva en 1989
par la définition de la norme ANSI C (ou C89). Celle-ci fut reprise telle quelle par l’ISO
(International Standards Organization) en 1990 (C ISO ou C90).
- En 1999, une nouvelle évolution du langage est normalisée par l'ISO : C99

2. Caractéristiques du langage C
- C’est un langage compilé c’est à dire un programme C est décrit par un fichier texte appelé
fichier source qui n’est pas exécutable par le microprocesseur ; il faut le traduire en langage
machine : cette traduction est effectuée par un programme appelé compilateur.
- Modulaire: un programme C peut être découpé en modules qui peuvent être compilés
séparément
- Universel (polyvalent): n'est pas orienté vers un domaine d'application particulier
(applications scientifiques, de gestion…)

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 5

- Typé: tout objet C doit être déclaré avant d’être utilisé

- Portable: en respectant le standard ANSI-C, il est possible d'utiliser le même programme sur
plusieurs systèmes (hardware, système d'exploitation)
- Près de la machine : comme C a été développé en premier lieu pour programmer le système
d'exploitation UNIX, il offre des opérateurs qui sont très proches de ceux du langage machine
et des fonctions qui permettent un accès simple et direct aux fonctions internes de
l'ordinateur (réalise des opérations bas niveau) (ex: manipulation de bits, la gestion de la
mémoire, gestion des adresses, etc…).
- Rapide : comme C permet d'utiliser des expressions et des opérateurs qui sont très proches
du langage machine, il est possible de développer des programmes efficients et rapides.

3. Structure d’un programme C

Un programme C est écrit dans un fichier avec une extension « .c » . Un exemple de programme écrit
en C est:

/* Inclusion des informations de la bibliothèque standard */

#include <stdio.h>

/**********************/

/* programme principal*/

/* afficher une chaine de caractères « Hello world » 25 fois */

/************************************************/

int main () {

/* DECLARATION DES VARIABLES */

int iCompteur; /* compteur de boucle */

/* CORPS DU PROGRAMME PRINCIPAL */

/* Pour tous les entiers allant de 1 à la borne 25*/

for (iCompteur=1;iCompteur<=25;iCompteur++)

printf("Hello world numero %d\n",iCompteur); /*Affichage */

return (0) ;

} /* fin du programme principal */

La directive #include :
• Son rôle consiste à lire le contenu du fichier indiqué et à l'insérer dans le code source à
l'endroit de cette directive comme si nous avions eu recours à copier/coller.
• Exemple :

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 6

o #include <stdio.h> : c’est pour inclure les fonctions de la bibliothèque standard dans
le fichier courant dont la fonction printf
• Les fichiers à inclure se trouvent dans un répertoire nommé ‘’include’’
• Ils possèdent l’extension ‘’.h’’
• L’inclusion des bibliothèques est un cas particulier. Ils renferment les définitions des
fonctions prédéfinies du système.

Exemples :

#include <stdio.h> (contient les en-têtes des fonctions

usuelles pour les entrées-sorties (STanDard Input-Output),
telle que printf.)
#include <math.h> (contient les fonctions mathématiques)
#include <graph.h> (contient les fonctions graphiques)
• Plus généralement, la possibilité d'inclure des fichiers sources dans d'autres fichiers sources
s'avère très utile. Par exemple pour insérer dans chacun des fichiers séparés qui constituent
un programme l'ensemble de leurs déclarations communes (types, structures, etc.). Ainsi ces
définitions sont écrites dans un seul fichier, ce qui en facilite la maintenance.

La fonction main
La fonction main est la fonction principale des programmes en C: Elle se trouve obligatoirement dans
tous les programmes. L'exécution d'un programme entraîne automatiquement l'appel de la fonction
main.

Déclarations de variables
o Déclarations de variables, sous la forme : type listevariables;
o Une variable est une 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.
o Les trois types scalaires de base du C sont l'entier (int), le réel (float) et le caractère
(char).
o On ne peut jamais utiliser de variable sans l'avoir déclarée auparavant.

Notion de bloc
Dans un bloc, les déclarations de données précèdent toujours les instructions.

En C, toute instruction simple est terminée par un point-virgule ;

Zone de déclaration de données ;

Zone des instructions ;

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 7

Commentaires :
 Les commentaires sont formés de caractères quelconques placés entre les symboles /* et */.
 La norme C99 autorise une seconde forme de commentaire: // pour un commentaire sur
une seule ligne
o printf ("bonjour\n") ; // ceci est un commentaire

A partir de cet exemple, on peut deviner un exemple de la structure générale d’un programme en C:

<inclusions ou macros>

<déclarations de fonctions/procédures/variables>

int main() {

<déclarations>

<instructions>

4. Des exemples
Exemple 1:

Si on veut écrire un programme qui affiche le message « Bienvenue » :

#include <stdio.h> /*inclusion du fichier stdio.h*/

int main()
{
printf("bienvenue"); /* affichage */
return (0);
}

Exemple 2:

int i,j; /* i,j,a,b,c sont des variables globales */

double a,b,c;
void p1(int k) /* debut de la definition de la procedure p1 */
/* p1 a un seul paramètre entier : k */
{
int s,t; /* variables locales à p1 */
... /* instructions de p1 qui peuvent accéder à */
... /* k,i,j,a,b,c,s et t */
} /* fin de la définition de p1 */
int f1(double x, double y) /* début d la définition de la */
/* fonction f1 qui a deux paramètres flottants: x et y */

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 8

{
double u,v; /* variables locales à f1 */
... /* instructions de f1 qui peuvent accéder à */
... /* x,y,i,j,a,b,c,u et v */
} /* fin de la définition de f1 */

int main() /* début du main, il n'y a pas de paramètres */

{
... /* instructions qui appellerons p1 et f1 */
} /* fin de la définition de main

5. Quelques règles d’écriture

 ne jamais placer plusieurs instructions sur une même ligne.
 Un identificateur
o Doit être significatif
o C'est une suite de lettres ou de chiffres.
o Le premier caractère est obligatoirement une lettre.
o Le caractère _ (souligné) est considéré comme une lettre.
o Le C distingue les minuscules des majuscules. Exemple: canadiens, Canadiens,
CanAdiens et CANADIENS sont des identificateurs valides et tous différents.
o Ne peut pas être un mot réservé (int, float…)
 grâce à l'indentation des lignes, on fera ressortir la structure syntaxique du programme.
 on laissera une ligne blanche entre la dernière ligne des déclarations et la première ligne des
instructions.
 une accolade fermante est seule sur une ligne (à l'exception de l'accolade fermante du bloc
de la structure do ... while)
 aérer les lignes de programme en entourant par exemple les opérateurs avec des espaces.
 il est nécessaire de commenter les listings. Eviter les commentaires triviaux.

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020