Cours Structuré 1 VF

Support de cours
PROGRAMMATION STRUCTUREE 1
Par Fatma KAABI HAJJI

Assistant technologue en informatique
Année universitaire : 2014/2015

Programmation structurée 1
Mme. Fatma KAABI HAJJI Page 2

Table des matières
Chapitre 1 : INTRODUCTION GENERALE ................................................................. 13

1.1 Introduction générale ........................................................................................ 14
1.1.1 Qu’est-ce qu’une application informatique ....................................................... 14
1.1.2 Lien entre algorithme et programme ............................................................... 14
1.1.3 Les étapes de résolution d’un problème ........................................................... 14
1.2 Structure d’un algorithme ................................................................................. 15
1.2.1 Structure ...................................................................................................... 15
1.2.2 Exemple ....................................................................................................... 15
1.2.3 Corps d’un algorithme ................................................................................... 16
1.3 Introduction à la programmation........................................................................ 17
1.3.1 Définition ..................................................................................................... 17
1.3.2 Les langages de programmation ..................................................................... 17
Chapitre 2 : LANGAGE DE PROGRAM MATION C ..................................................... 19

2.1 Introduction ..................................................................................................... 20
2.2 Avantages de langages C .................................................................................. 20
2.3 Environnement et bibliothèques de fonctions ...................................................... 21
2.3.1 Environnement .............................................................................................. 21
2.3.2 Utilitaires d’exécution .................................................................................... 22
2.3.3 Bibliothèques de fonctions ............................................................................. 23
2.4 Conclusion ....................................................................................................... 27
Chapitre 3 : LIRE ET ÉCRIRE DES DONNÉES ........................................................... 29

3.1 Écriture formatée de données ............................................................................ 30
3.1.1 printf() ......................................................................................................... 30
3.1.2 Ecriture formatée en langage algorithmique ..................................................... 30
3.1.3 Ecriture formatée en C .................................................................................. 30
3.1.4 Spécificateurs de format pour printf ............................................................... 31
3.2 Lecture formatée de données............................................................................. 32
3.2.1 scanf() ......................................................................................................... 32
3.2.2 Lecture formatée en C .................................................................................. 32
3.2.3 Spécificateurs de format pour scanf ................................................................ 33
3.3 Écriture d'un caractère ..................................................................................... 33

3.4 Lecture d'un caractère ...................................................................................... 33

3.5 Exercices de récapitulation ................................................................................ 34
3.5.1 Exercice 1 .................................................................................................... 34
3.5.2 Exercice 2 .................................................................................................... 34
3.5.3 Interprétation................................................................................................ 35
3.6 Conclusion ....................................................................................................... 35
Chapitre 4 : LA STRUCTURE ALTERNATIVE ............................................................ 36

4.1 La structure if – else ......................................................................................... 37
4.1.1 La structure alternative en langage algorithmique ............................................ 37
4.1.2 La structure alternative en C ......................................................................... 38
4.2 La structure if - else if - ... - else ....................................................................... 39
4.3 Les opérateurs conditionnels .............................................................................. 40
4.3.1 Définition ..................................................................................................... 40
4.3.2 Les opérateurs conditionnels .......................................................................... 40
4.3.3 Exemple ....................................................................................................... 41
4.4 Structure de choix multiple................................................................................ 41
4.4.1 Structure de choix multiple en langage algorithmique ....................................... 41
4.4.2 Structure de choix multiple en C .................................................................... 43
4.5 Conclusion ....................................................................................................... 45
Chapitre 5 : LA STRUCTURE REPETITIVE ................................................................ 46

5.1 La structure for ................................................................................................ 47
5.1.1 Définition ..................................................................................................... 47
5.1.2 La structure pour en langage algorithmique ..................................................... 47
5.1.3 La structure for en C..................................................................................... 48
5.2 La structure do – while ..................................................................................... 49
5.2.1 La structure Répéter …jusqu’ a, en langage algorithmique ................................ 49
5.2.2 La structure do - while en C .......................................................................... 51
5.3 La structure while ............................................................................................. 52
5.3.1 Définition ..................................................................................................... 52
5.3.2 La structure tant que en langage algorithmique ............................................... 52
5.3.3 La structure while en C ................................................................................. 53
5.4 Les instructions de débranchement .................................................................... 54
5.4.1 Instruction break (Interrompre) ...................................................................... 54
5.4.2 L'instruction Continue (continuer) .................................................................. 55
5.5 Branchement inconditionnel............................................................................... 55
5.6 Exercice : comment faire le choix de la structure répétitive ? ............................... 56
5.6.1 Énoncé ......................................................................................................... 56
5.6.2 Solution ....................................................................................................... 56
5.7 Conclusion ....................................................................................................... 58

Chapitre 6 : LES TABLEAUX ...................................................................................... 59

6.1 Les tableaux à une dimension ............................................................................ 60
6.1.1 Déclaration et mémorisation .......................................................................... 60
6.1.2 Initialisation et réservation automatique .......................................................... 60
6.1.3 Affichage et affectation ................................................................................. 61
6.2 Tableau a deux dimensions ................................................................................ 63
6.2.1 Déclarations ................................................................................................. 63
6.2.2 Accès aux composantes ................................................................................. 63
6.2.3 Affichage et affectation ................................................................................. 64
6.3 Exercices de tri, insertion, recherche de valeurs ................................................... 66
6.3.1 Enoncés ....................................................................................................... 66
6.3.2 Solutions des exercices .................................................................................. 68
Chapitre 7 : LES STRUCTURES ................................................................................. 77

7.1 Notion de structure .......................................................................................... 78
7.2 Déclaration et initialisation de structure ............................................................. 78
7.2.1 Déclaration d’une structure ............................................................................ 78
7.2.2 Initialisation d'une structure ........................................................................... 80
7.3 Operations sur les structures ............................................................................. 80
7.3.1 Accès aux membres des structures ................................................................. 80
7.3.2 Affectation de structures ............................................................................... 80
7.3.3 Comparaison de structures............................................................................. 80
7.4 Tableaux de structures...................................................................................... 80
7.5 Exercice ........................................................................................................... 81
7.5.1 Enoncé ......................................................................................................... 81
7.5.2 Solution ....................................................................................................... 81
Chapitre 8 : LES CHAÎNES DE CARACTÈRES ............................................................ 83

8.1 Les chaines de caractères .................................................................................. 84
8.1.1 Déclaration et mémorisation .......................................................................... 84
8.1.2 Les chaînes de caractères constantes .............................................................. 84
8.1.3 Initialisation de chaînes de caractères .............................................................. 85
8.1.4 Accès aux éléments d'une chaîne .................................................................... 86
8.2 Les bibliothèques de fonctions de C pour le traitement de chaînes de caractères .... 87
8.2.1 Les fonctions de <stdio.h> ............................................................................ 87
8.2.2 Les fonctions de <string> .............................................................................. 88
8.2.3 Les fonctions de <ctype> .............................................................................. 89
8.3 Tableaux de chaînes de caractères ..................................................................... 89
8.3.1 Règle générale .............................................................................................. 89
8.3.2 Déclaration, initialisation et mémorisation ....................................................... 89
8.3.3 Accès aux chaînes ......................................................................................... 90

8.3.4 Affectation ................................................................................................... 90

8.4 Algorithmes qui traitent des caractères et des chaînes de caractères ..................... 91
8.4.1 Fonctions standards sur les caractères ............................................................ 91
8.4.2 Procédures standards sur les chaines de caractères .......................................... 91
8.4.3 Fonction standards sur les chaines de caractères ............................................. 92
8.5 Exercices d’applications..................................................................................... 92
Quelques sujets d’examens .......................................................................................... 97
Références bibliographiques ....................................................................................... 101


Avant-propos
Le langage C a été créé en 1972 par Denis Ritchie avec un objectif

relativement limité : écrire un système d'exploitation (UNIX).
Mais le langage a continué d'évoluer après cette date à travers les
différents compilateurs. Son succès international a contribué à sa
normalisation, d'abord par l'ANSI (American National Standard
Institute), jusqu’au 1994 et ensuite par l'AFNOR.
Aujourd'hui C est devenu le langage de programmation standard dans le
domaine des micro-ordinateurs.
Cet ouvrage est un cours intégré de programmation en langage C destiné
aux étudiants des premières années en licences qui a pour objectif de :
- Comprendre les principes de la résolution des problèmes en
algorithmique,
- Apprendre la programmation structurée en utilisant le langage C,
La plupart des chapitres proposent des exercices d’applications avec

solutions pour contrôler les connaissances acquises.
Enfin, outre son caractère didactique, j’ai doté ce support d'une
organisation appropriée à une recherche rapide d'information.

Liste des figures
Figure 1.1 : Fonctionnement d’un ordinateur. 14

Figure 2.1 : Bibliothèques de fonctions et compilation. 26
Figure 6.1 : Schéma d’exécution d’une instruction conditionnelle alternative. 37
Figure 7.1 : Schéma d’exécution d’une boucle « pour ». 47
Figure 7.2 : Schéma d’exécution d’une boucle « répéter » 50
Figure 7.3 : Schéma d’exécution d’une boucle « tantque » 52
Figure 10.1 : Exemple d’un tableau de chaines de caractères. 90

Liste des tableaux
TABLEAU 2.1 : LES COMMANDES C. 25

TABLEAU 2.2 : BIBLIOTHEQUES DE FONCTIONS. 25
TABLEAU 5.1 : SPECIFICATEURS DE FORMAT POUR PRINTF. 32
TABLEAU 5.2 : SPECIFICATEURS DE FORMAT POUR PRINTF. 33
TABLEAU 10.1 : FONCTIONS STANDARDS SUR LES CARACTERES. 91
TABLEAU 10.2 : PROCEDURES STANDARDS SUR LES CHAINES DE CARACTERES. 91
TABLEAU 10.3 : FONCTIONS STANDARDS SUR LES CHAINES DE CARACTERES. 92

Support de cours intégrés Programmation structurée 1
Cours

FICHE MATIERE
Unité d’enseignement : traitement de données 1
ECUE n°1 : programmation structurée 1
Mention : GE
Domaine de formation Sciences appliquées et technologie
Spécialité
Domaine et parcours Licence appliquée GE Semestre S1.
Parcours Tronc commun.
Code UE : 1.4 Code ECUE : 1.4.1
Nombre d’heures/semestre
Coefficient Crédits Système d’évaluation
Cours intégré TP
21 0 2 1.5 Continu
OBJECTIFS DE L’UE
- Comprendre les principes de la résolution des problèmes en algorithmique
- Programmer en un langage procédural
- Apprendre la programmation structurée en utilisant le langage C avec quelques solutions
algorithmiques
OBJECTIFS DE L’ENSEIGNEMENT
- Maîtriser le raisonnement algorithmique.
- Maîtriser la programmation en langage procédural.
PRE - REQUIS
Programme d’informatique du niveau Baccalauréat.
Contenu théorique
- Introduction à la programmation C
- Les entrées – sorties
- Les structures de contrôle
 Les structures conditionnelles
 Les structures répétitives
- Les tableaux
- Les structures.

Chapitre 1 : INTRODUCTION GENERALE
Objectif : Connaitre le but du cours d’algorithme et programmation.
Plan du cours :
1. Qu’est-ce qu’une application

informatique
2. Lien entre algorithme et programme
3. Les étapes de résolution d’un
problème
4. Structure d’un algorithme à l’aide de
quelques exemples
5. Introduction à la programmation.

5.1 Introduction générale
1.1.1 Qu’est-ce qu’une application informatique
Informatisée une application c’est faire réaliser par ordinateur, une tache qui était
réalisée par l’Homme exemple facturation de la consommation d’eau …
Pour faire exécuter une tache par ordinateur, il faut tout d’abord, détailler les étapes de
résolution du problème, pour qu’elle soit exécutable par l’homme ensuite, transférer la
résolution en une suite d’étapes si élémentaires et simple à exécuter pouvant être codée
en un programme dans un langage compréhensible par ordinateur.
1.1.2 Lien entre algorithme et programme
On appelle un algorithme toute suite d’étapes si élémentaires et simple à exécuter.

Un programme est un algorithme codé dans un langage compréhensible par ordinateur à
l’aide d’un compilateur (traducteur).
1.1.3 Les étapes de résolution d’un problème
- Comprendre la problématique.
- Décomposé le problème en sous problèmes plus simple à résoudre.
- Associer à chaque sous problèmes une spécification :
 Les données nécessaires (données en entrées).
 Les données résultantes (données en sortie).
 La démarche à suivre pour arriver au résultat en partant d’un ensemble de
données.
- Elaboration d’un algorithme.
Illustration du fonctionnement d’un ordinateur :
Figure 1.1 : fonctionnement d’un ordinateur.

5.2 Structure d’un algorithme
1.1.4 Structure
ALGORITHME nom_de_l’algorithme
CONSTANTES {Définition des constantes}
TYPE {Définition de types}
VARIABLES {Déclaration de variables}
DEBUT
{Suite d’instructions}
FIN
ALGORITHME afficher
DEBUT
Ecrire("La valeur de 5*5 est ", 5*5)
FIN
Cet algorithme permet d'afficher sur l'écran la phrase suivante :

« La valeur de 5*5 est 25 ».
1.1.5 Exemple
1.1.5.1Enoncé
On veut écrire l’algorithme qui permet de saisir 3 notes d’un étudiant dans trois
matières, étant donnés les coefficients respectifs 2, 3 et 1.
1.1.5.2Résolution
A partir de l’énoncé du problème, nous recherchons la solution par une démarche en 2
phases.
- On doit comprendre comment le résoudre manuellement,
- Définir ce qu’on a besoin comme données, quelles est la démarche à suivre
(formules de calcul) pour arriver aux résultats.
Pour notre problème, nous connaissons les coefficients et la formule de calcul (Ni*Ci /
Ci), nous avons besoins des notes de chaque matière dans l’ordre, et enfin nous
pouvons communiquer le résultat à l’utilisateur.

ALGORITHME MOYENNE
CONSTANTES
C1=2
C2=3
C3=1
VARIABLES
N1, N2, N3: REEL
MOY : REEL
DEBUT
{Affichage message : Invitation de l'utilisateur à introduire des données}
ECRIRE(" Donner trois valeurs réelles ")
{Saisie des notes}
LIRE(N1, N2, N3)
{Calcul de la moyenne}
MOY (N1*C1+N2*C2+N3*C3) / (C1+C2+C3)
{Affichage du résultat sur l’écran}
ECRIRE(" La moyenne est = ", MOY)
FIN
Remarque :
Le texte entre les accolades est purement explicatif, il sert à rendre l’algorithme plus
lisible.
1.1.6 Corps d’un algorithme
(1) Partie Saisie (Périphériques d’entrées MC)

(2) Partie Traitement (UC)
(3) Partie Affichage (MC Périphériques de Sortie)
Exemple
Ecrire un algorithme qui fait la somme de deux entiers.
ALGORITHME Somme
VARIABLES Ent1,Ent2,S : Entiers
DEBUT
ECRIRE("donner un 1 er entier ") {Ecran}
(1)
LIRE(Ent1) {Clavier MC)
ECRIRE("donner un 2éme entier ")

(2)
LIRE(Ent2)

S=Ent1+Ent2 { UC }
(3)
ECRIRE("La Somme de " ,Ent1 ,"+" ,Ent2 ,"=" ,S) { Ecran}
FIN.
5.3 Introduction à la programmation
1.1.7 Définition
Le programmeur ne peut pas donner à l’ordinateur des ordres rédigés en langage humain
car l’ordinateur ne connaît que son langage propre : on l’appelle langage machine ou
binaire (0,1).
La traduction du langage humain en langage compréhensible par l’ordinateur s’appelle
programmation.
Langage naturel
Langage de programmation compilation ou
Langage binaire interprétation.
Le langage machine constitué de 0 et 1 est d’une utilisation fastidieuse (difficile) c’est

pourquoi les informaticiens ont créé un langage plus accessible à l’homme. Ce langage
dit langage de programmation est l’intermédiaire entre le langage humain et le langage
machine.
La traduction de ce langage en langage machine dite compilation ou interprétation est
faite par l’ordinateur lui-même à l’aide d’un programme compilateur ou interpréteur.
1.1.8 Les langages de programmation

Les langages de programmation peuvent se placer en différentes familles selon leurs
degré d’indépendance vis à vis du langage machine (compilé ou interprété).
1.1.8.1Classification selon le degré d’indépendance
→ Le langage binaire.
Degré de → Le langage assembleur.
→ Le langage évolué exp : (C, Pascal, Java, Ada, Bas,
dépendance
Fortran…).
→ Les langages de 4ème génération L4G exp : (visuel basic,
delphi, visual Fox pro…)

1.1.8.2Les langages compilés

La traduction de ces langages en langage machine est faite par des programmes compilé
appelé compilateur.
Un langage est dite compilé si à partir d’un programme déjà écrit dans ce langage on
génère un autre programme compréhensible par la machine après avoir corrigé toutes
les erreurs. Le premier programme est dit programme source et le second est dit
programme exécutable.
 Exemple
 C/C++ : programmation système et scientifique
 Cobal : gestion
 Fortran : calcul
 Pascal : enseignement…
1.1.8.3Les langages interprétés

La traduction de ces langages en langage machine et faite par des programmes appelés
interpréteurs.
Un langage est dit interprété si la traduction en langage machine se fait au moment de
l’exécution instruction par instruction.
 Exemple
Basic
LISP L’intelligence artificielle
Prolog
Java
MATLAB
Perl…
 Remarque
Un programme compilé est plus rapide en exécution qu’un programme interprété.

Chapitre 2 : LANGAGE DE PROGRAMM ATION C
Objectif : Motivation au langage c.
Plan du cours :
1. Introduction
2. Avantages de langage C
3. Environnement et bibliothèque de fonction
3.1 Environnement
3.1.1 Se positionner dans l’ordinateur
3.1.2 Utilitaire d’exécution
3.2 Bibliothèques de fonctions
4. Conclusion

2.1 Introduction
Dans les dernières années, aucun langage de programmation n'a pu se vanter d'une
croissance en popularité comparable à celle de C, le langage C n'est pas un nouveau-né
dans le monde informatique, mais qu'il trouve ses sources en 1972 par Denis Ritchie
avec un objectif précis : Ecrire un système d’exploitation (UNIX).
2.2 Avantages de langages C
Les avantages de ce langage se résument en neuf (9) points :

(1) universel : Ce n'est pas orienté vers un domaine d'applications spéciales,
(2) compact : C est basé sur un noyau de fonctions et d'opérateurs limité, qui
permet la formulation d'expressions simples, mais efficaces.
(3) moderne : C est un langage structuré, déclaratif et récursif ; il offre des
structures de contrôle et de déclaration
(4) 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 (p.ex. : la gestion
de la mémoire).
(5) 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.
(6) indépendant de la machine : bien que C soit un langage près de la machine,
il peut être utilisé sur n'importe quel système en possession d'un compilateur
C. Au début C était surtout le langage des systèmes travaillant sous UNIX,
aujourd'hui C est devenu le langage de programmation standard dans le
domaine des micro-ordinateurs.
(7) portable : En respectant le standard ANSI-C, il est possible d'utiliser le même
programme sur tout autre système (autre hardware, autre système
d'exploitation), simplement en le recompilant.
(8) extensible : C ne se compose pas seulement des fonctions standards ; le
langage est animé par des bibliothèques de fonctions privées ou livrées par de
nombreuses maisons de développement.

2.3 Environnement et bibliothèques de fonctions
2.3.1 Environnement
2.3.1.1 Se positionner dans l’ordinateur

L'ordinateur est une machine complexe organisée avec plusieurs niveaux d'intervention
superposés et solidaires entre eux. On parle de hiérarchie d'abstraction, des niveaux ou
encore de machines virtuelles. Chaque niveau s'appuie sur le niveau précédent pour en
réduire la complication et ajouter des modalités de commandes afin d'obtenir des
opérations de niveau supérieur, plus complexes. Nous pouvons le schématiser de la façon
suivante :
2.3.1.2 Niveaux - abstractions

6 Programmes applicatifs
5 Langage de programmation <- langage C, nous sommes ici
4 Langage assembleur
3 Noyau du système d’exploitation
2 Langage machine
1 Microprogramme
0 Logique numérique
0 : Logique numérique, circuits électroniques de l’ordinateur, portes logiques (ET, OU)

univers binaire 0/1.
1 : Microprogramme, premier niveau de langage, tous les ordinateurs ne le possèdent
pas (des séquences d’étapes utilisées par le niveau 2 du langage machine).
2 : Langage machine : à ce niveau, ajouter 2 nombres, déplacer des données d’un
emplacement vers un autre, déterminer si un nombre est égal à 0 sont des instructions
élémentaires suffisantes pour exécuter n’importe quel programme ou application des
niveaux plus élevés !
3 : Noyau système exploitation : ordonnancer et allouer les ressources d’un ordinateur
aux différents programmes s’exécutant sur la machine. Il peut être programmé dans un
langage de programmation de haut niveau qui a été traduit en langage machine, c'est-à-
dire compilé. Rappelons que Le langage C a été créé initialement pour écrire le système
d’exploitation UNIX.

En plus du noyau le système d’exploitation complet comprend des programmes

applicatifs (niveau 6), le plus souvent un rôle d’interface (gestion des fichiers, gestion
des fenêtres etc.)
4 : Le langage d’assemblage est une représentation symbolique des instructions
rencontrées aux niveaux inférieurs. Un programme en langage d’assemblage est converti
en instructions de niveau inférieur par un traducteur appelé un assembleur
5 : Les langages de hauts niveaux grâce auxquels les applications peuvent être écrites
plus facilement qu’en langage assembleur. Il existe des milliers de langages à ce niveau
(les plus connus, pascal, Cobol, Fortan, Lisp, Basic, C, C++, java, …).
Ils font eux-mêmes l’objet d’une classification en strates C, C++, JAVA,
JAVASCRIPT… par exemple).
6 : Les applications ou collections de programmes dans des domaines multiples et
variés.
2.3.2 Utilitaires d’exécution
2.3.2.1 Pré-processeur
Le pré-processeur ou pré-compilateur est un utilitaire qui traite le fichier source avant
de le compiler. C’est un manipulateur de chaînes de caractères. Il retire les parties de
commentaires et prend en compte les lignes du texte source ayant un # en première
colonne pour créer le texte que le compilateur analysera.
Le symbole # peut être utilisé pour :
 l’inclusion de fichiers : #include <fichier.h> ;
 la définition d’alias et de macro-expressions : #define Vrai 1; #define carré(x)
x*x.
2.3.2.2 Compilateur
Le compilateur lit ce que génère le pré-processeur et crée les lignes d’assembleur
correspondantes. Il lit le texte source une seule fois du début du fichier à la fin. Cette
lecture conditionne les contrôles qu’il peut faire, et explique pourquoi toute variable ou
fonction doit être déclarée avant d’être utilisée.
Le compilateur C permet :
 La génération des instructions machine qui permettent de manipuler des éléments
binaires ou des groupes d’éléments binaires. Il peut donc réaliser des masques
pour sélectionner des groupes de bits, ou encore faire des décalages de bits à
l’intérieur de mots machine.

 La réalisation des manipulations algébriques (addition, multiplication, etc.) de

groupes d’octets qui représentent des valeurs entières ou des valeurs décimales.
 La manipulation des caractères en considérant qu’un caractère est représenté par
un octet à partir du code ASCII.
Le compilateur C ne permet pas par contre de tout faire, ainsi pour réaliser des
opérations compliquées, le programmeur doit écrire ses propres fonctions ou faire appel
aux fonctions prédéfinies et standardisées de la bibliothèque du langage C.
2.3.2.3 Optimiseur du code

L’optimiseur de code élimine les parties du code assembleur qui ne sont pas utiles. Il
remplace des séquences d’instructions par des instructions plus sophistiquées et propres
au processeur. Cette opération donne un code plus compact et plus rapide. Ensuite, il
optimise les sauts.
2.3.2.4 Assembleur
L’assembleur prend le code généré par le compilateur, éventuellement modifié par
l’optimiseur, et génère un fichier en format relogeable (binaire). Ce fichier possède des
références à certains sous programmes ou emplacements sur le disque qui seront pris en
charge par l’éditeur de liens.
2.3.2.5 Editeur de lien

L’éditeur de liens prend le ou les fichiers en format relogeable et les associe pour créer
un module chargeable pour l’exécution. Il se sert de bibliothèques pour résoudre les
références.
2.3.3 Bibliothèques de fonctions

D’autre part la pratique en C exige l'utilisation de bibliothèques de fonctions. Pour
pouvoir les utiliser, il faut inclure des fichiers en-tête (header files - extension .H) dans
nos programmes.
L'instruction #include insère les fichiers en-tête indiqués comme arguments dans le
texte du programme au moment de la compilation.
Lors de la programmation nous travaillons donc avec différents types de fichiers qui sont
identifiés par leurs extensions :
*.C fichiers source
*.OBJ fichiers compilés (versions objet)
fichiers compilés et liés (versions
*.EXE
exécutables)

*.LIB bibliothèques de fonctions précompilées

*.H fichiers en-tête (header files)
Exemple : Fonctions arithmétiques

Nous allons écrire un programme qui fait appel à des fonctions mathématiques et des
fonctions graphiques prédéfinies. Pour pouvoir utiliser ces fonctions, le programme a
besoin des bibliothèques :
MATHS.LIB
GRAPHICS.LIB
Nous devons donc inclure les fichiers en-tête correspondants dans le code source de
notre programme à l'aide des instructions :
#include <math.h>
#include <graphics.h>
Après la compilation, les fonctions précompilées des bibliothèques seront ajoutées à
notre programme pour former une version exécutable du programme :
LANGAGES
COMMANDE C EXPLICATION
ALGORITHMIQUE
exp(X) fonction exponentielle eX
log(X) logarithme naturel ln(X), X>0
log10(X) logarithme à base 10 log 10(X), X>0
pow(X,Y) X exposant Y XY
sqrt(X) racine carrée de X pour X>0
fabs(X) valeur absolue de X |X|
floor(X) arrondir en moins int(X)
ceil(X) arrondir en plus
reste rationnel de X/Y (même

fmod(X,Y) pour X différent de 0
signe que X)
sin(X) cos(X) tan(X) sinus, cosinus, tangente de X
asin(X) acos(X)
arcsin(X), arccos(X), arctan(X)
atan(X)

sinh(X) cosh(X) sinus, cosinus, tangente

tanh(X) hyperboliques de X
Tableau 2.1 : Les commandes C.
Les bibliothèques les plus utilisées sont :

Bibliothèque Description
<complex.h> Manipuler les nombres complexes
<ctype.h> Manipuler des caractères
<errno.h> Gestion des erreurs
<math.h> Fonctions mathématiques
<setjmp.h> Instructions goto
<signal.h> Contrôler les signaux
<stdio.h> Fonctions d’entrée sortie
<stdlib.h> Exécuter diverses opérations dont la conversion, la génération
de nombres pseudo-aléatoires, l'allocation de mémoire, le
contrôle de processus, la gestion de l'environnement et des
signaux, la recherche et le tri.
<string.h> Manipuler les chaînes de caractères
<time.h> Fonctions de date et heure
Tableau 2.2 : Bibliothèques de fonctions.

Figure 2.1 : Bibliothèques de fonctions et compilation.

2.4 Conclusion
Le langage C est un langage structuré, compilé et portable qui a été développé

conjointement au système d’exploitation UNIX en 1972 puis normalisé en 1989.
Pour générer des programmes exécutables, C utilise les utilitaires suivants : le
préprocesseur, le compilateur, l’optimiseur de code, l’assembleur et l’éditeur de liens.
Le langage C offre des fonctions prédéfinies regroupées dans des bibliothèques qu’il faut
inclure dans les programmes.


Chapitre 3 : LIRE ET ÉCRIRE DES DONNÉES
Objectif : Connaître les différentes fonctions d’entrée / sortie pour assurer la

communication de la machine avec le monde extérieur.
Plan du cours :
1. Écriture formatée de données
2. Lecture formatée de données
3. Écriture d'un caractère
4. Lecture d'un caractère
5. Exercice de récapitulation
6. Conclusion

5.4 Écriture formatée de données
3.1.1 printf()
La fonction printf est utilisée pour transférer du texte, des valeurs de variables ou des
résultats d'expressions vers le fichier de sortie standard (par défaut l'écran).
3.1.2 Ecriture formatée en langage algorithmique

L’instruction d’écriture : communication Programme Utilisateur
écrire <Expression1>,<Expression2>, ...
3.1.2.1 Exemple
Qu’obtient t-on à l’écran après l’exécution des instructions suivantes :

x¬ 4
Ville¬ ”Tunis”
Ecrire(x)
Ecrire(x*x)
Ecrire(”Ville”)
Ecrire(”Ville = ”,Ville)
3.1.2.2 Solution
4
16
Ville
Ville = Tunis
3.1.3 Ecriture formatée en C

printf("<format>",<Expr1>,<Expr2>, ... )
"<format>" : format de représentation
variables et expressions dont les valeurs sont à
<Expr1>,... :
représenter
3.1.3.1 Exemple 1
La suite d'instructions :
int A = 1234;
int B = 567;
printf("% i fois % i est % li\n", A, B, (long)A*B);

Va afficher sur l'écran : 1234 fois 567 est 699678
Les arguments de printf sont :

- la partie format "% i fois % i est % li"
- la variable A
- la variable B
- l'expression (long) A*B
er
Le 1 spécificateur (% i) indique que la valeur de A sera imprimée comme entier
relatif==>1234
Le 2e spécificateur (% i) indique que la valeur de B sera imprimée comme entier relatif
==> 567
Le 3e spécificateur (% li) indique que la valeur de (long)A*B sera imprimée comme
entier relatif long ==> 699678
3.1.3.2 Exemple 2
char B = 'A';
printf("Le caractère % c a le code % i !\n", B, B);
Va afficher sur l'écran : Le caractère A a le code 65 !
La valeur de B est donc affichée sous deux formats différents :
% c comme caractère : A
% i comme entier relatif : 65
3.1.4 Spécificateurs de format pour printf

SYMBOLE TYPE IMPRESSION COM ME
%d ou
int entier relatif
%i
%u int entier naturel (unsigned)
%o int entier exprimé en octal
%x int entier exprimé en hexadécimal
%c int caractère
%f double rationnel en notation décimale
%e double rationnel en notation scientifique

%s char* chaîne de caractères
Tableau 3.1 : spécificateurs de format pour printf.
5.5 Lecture formatée de données
3.1.5 scanf()
La fonction scanf est la fonction symétrique à printf; elle nous offre pratiquement les
mêmes conversions que printf, mais en sens inverse.
Lecture formatée en langage algorithmique
L’instruction de lecture : communication Utilisateur Programme
lire <NomVariable1>,<NomVariable2>, ...
3.1.6 Lecture formatée en C

scanf("<format>",<AdrVar1>,<AdrVar2>, ...)
"<format>" : format de lecture des données

adresses des variables auxquelles les données seront
<AdrVar1>,... :
attribuées
 La fonction scanf reçoit ses données à partir du fichier d'entrée standard stdin
(par défaut le clavier).
 La chaîne de format détermine comment les données reçues doivent être
interprétées.
 Les données reçues correctement sont mémorisées successivement aux adresses
indiquées par <AdrVar1>,... .
 L'adresse d'une variable est indiquée par le nom de la variable précédé du signe
&.
Exemple
int JOUR, MOIS, ANNEE;
scanf("% i % i % i", &JOUR, &MOIS, &ANNEE);
Lit trois entiers relatifs, séparés par des espaces, tabulations ou interlignes. Les valeurs
sont attribuées respectivement aux trois variables JOUR, MOIS et ANNEE.
* scanf retourne comme résultat le nombre de données correctement reçues (type int).

3.1.7 Spécificateurs de format pour scanf

SYMBOLE LECTURE D'UN(E) TYPE
% d ou % i entier relatif int*
%u entier naturel (unsigned) int*
%o entier exprimé en octal int*
%b entier exprimé en hexadécimal int*
%c caractère char*
%s chaîne de caractères char*
%f ou rationnel en notation décimale ou exponentielle

float*
%e (scientifique)
Tableau 3.2 : spécificateurs de format pour printf.
5.6 Écriture d'un caractère
La commande putchar('a'); transfère le caractère a vers le fichier standard de sortie

stdout. Les arguments de la fonction putchar sont ou bien des caractères (c.-à-d. des
nombres entiers entre 0 et 255).
Les arguments de putchar sont par définition du type int et toutes les valeurs traitées
par putchar (même celles du type char) sont d'abord converties en int.
5.7 Lecture d'un caractère
Une fonction plus souvent utilisée que putchar est la fonction getchar, qui lit le
prochain caractère du fichier d'entrée standard stdin.
 Type du résultat
Les valeurs retournées par getchar sont des caractères (0 - 255) le type résultat de
getchar est int. En général, getchar est utilisé dans une affectation :
int C;
C = getchar();
 Remarque

<conio> contient une fonction du nom getch qui fournit immédiatement le prochain
caractère entré au clavier.
5.8 Exercices de récapitulation
3.1.8 Exercice 1
3.1.8.1 Énoncé
Ecrire un programme qui lit un caractère au clavier et affiche le caractère ainsi que son
code numérique en employant getchar et printf,
3.1.8.2 Solution
En employant getchar et printf,
#include <stdio.h>
main()
{
int C;
printf("Introduire un caractère suivi de 'Enter'\n");
C = getchar();
printf("Le caractère % c a le code ASCII % d\n", C, C);
return 0;
}
3.1.9 Exercice 2
3.1.9.1 Énoncé
Calculer et afficher la somme S de deux nombres entier (A, B).
3.1.9.2 Solution
#include <stdio.h>
void main()
{
int a, b, s;
printf("Ce programme calcule la somme de 2 nombres.\n");

printf("Entrez la valeur de a : ");

scanf("% d", &a);
printf("Entrez la valeur de b : ");
scanf("% d", &b);
s = a + b;
printf("% d",s);
3.1.10 Interprétation
- La bibliothèque Stdio.h contient les deux fonctions printf et scanf
- Printf : c’est la fonction qui permet l’affichage sur l’écran
- Scanf : c’est la fonction qui permet la saisie des données
- %d signifie qu’on va saisir un entier si on veut saisir un réel on utilise %f
5.9 Conclusion
Un programme lit les données à travers les fonctions d’entrées et affiche les résultats
en utilisant les fonctions de sorties.
Les fonctions d’entrée sont :
- scanf : lecture formatée
- gets : lire une chaîne de caractères
- getch ou getchar : lire un caractère
Les fonctions de sorties sont :
- printf : affichage formaté
- puts : afficher une chaîne de caractères
- putchar : afficher un caractère

Chapitre 4 : LA STRUCTURE ALTERNATIVE
Objectif : Construire des programmes comportant des traitements conditionnels.
Plan du cours :
1. La structure if - else
2. La structure if - else if - ... - else
3. Les opérateurs conditionnels
4. Structure de choix multiples
5. Conclusion

5.10 La structure if – else
4.1.1 La structure alternative en langage algorithmique
4.1.1.1 Syntaxe générale
Si <condition> Alors
<Séquence d’instructions 1>
Sinon
<Séquence d’instructions 2>
Fin Si
4.1.1.2 Principe de fonctionnement

* Si l'<expression logique> a la valeur logique vrai, alors le <bloc d'instructions 1> est
exécuté.
* Si l'<expression logique> a la valeur logique faux, alors le <bloc d'instructions 2> est
exécuté.
Figure 4.1 : Schéma d’exécution d’une instruction conditionnelle alternative .

4.1.1.3 Exemple 1
Ecrire un algorithme qui calcule et affiche la valeur absolue d’un entier quelconque lu au
clavier.
Solution
Algorithme Val_Abs
Variables
x, va : Entier
Début
Ecrire (”Entrer un entier : ”) Lire(x)
Si (x >= 0) Alors
Va  x
Sinon
Va  -x
FinSi
Ecrire (”|”,x, ”| = ”,va)
Fin.
4.1.1.4 Exemple 2
Ecrire un algorithme qui lit un entier et affiche ensuite s’il est pair ou impair.
Solution
Algorithme pair_impair
Variables
x : Entier
Début
Ecrire(”Entrer un entier : ”) L ire(x)
Si (x Mod 2 = 0) Alors
Ecrire(”c’est un entier pair”)
Sinon
Ecrire(”c’est un entier impair”)
FinSi
Fin.
4.1.2 La structure alternative en C
if ( <expression> )
<bloc d'instructions 1>
else
<bloc d'instructions 2>

* Si l'<expression> fournit une valeur différente de zéro, alors le <bloc d'instructions 1>
est exécutée.
* Si l'<expression> fournit la valeur zéro, alors le <bloc d'instructions 2> est exécuté.
La partie <expression> peut désigner :
 une variable d'un type numérique,
 une expression fournissant un résultat numérique.
La partie <bloc d'instructions> peut désigner :
 un (vrai) bloc d'instructions compris entre accolades,
 une seule instruction terminée par un point-virgule.
Exemple 1
if (a > b)
max = a;
else
max = b;
5.11 La structure if - else if - ... - else
En combinant plusieurs structures if - else en une expression nous obtenons une

structure qui est très courante pour prendre des décisions entre plusieurs alternatives :
if ( <expr1> ) si ( <expr1> ) alors

<bloc1> <bloc1>
else if (<expr2>) Si non
<bloc2> si (<expr2>)alors
else if (<expr3>) <bloc2>
<bloc3> Sinon
else if (<exprN>) si (<expr3>)alors
<blocN> <bloc3>
else <blocN+1> Si non
si (<exprN>) alors
<blocN>
Si non <blocN+1>
Les expressions <expr1> ... <exprN> sont évaluées du haut vers le bas jusqu'à ce que
l'une d'elles soit différente de zéro.

Le bloc d'instructions y lié est alors exécuté et le traitement de la commande est

terminé.
 Exemple
#include <stdio.h>
main()
{
int A,B;
printf("Entrez deux nombres entiers :");
scanf("% i % i", &A, &B);
if (A > B)
printf("% i est plus grand que % i\n", A, B);
else if (A < B)
printf("% i est plus petit que % i\n", A, B);
else
printf("% i est égal à % i\n", A, B);
return 0;
}
La dernière partie else traite le cas où aucune des conditions n'a été remplie. Elle est
optionnelle, mais elle peut être utilisée très confortablement pour détecter des erreurs.
5.12 Les opérateurs conditionnels
4.1.3 Définition
Le langage C possède une paire d'opérateurs un peu exotiques qui peut être utilisée
comme alternative à if - else et qui a l'avantage de pouvoir être intégrée dans une
expression.
4.1.4 Les opérateurs conditionnels

<expr1> ? <expr2> : <expr3>
* Si <expr1> fournit une valeur différente de zéro, alors la valeur de <expr2> est
fournie comme résultat.
* Si <expr1> fournit la valeur zéro, alors la valeur de <expr3> est fournie comme
résultat.

4.1.5 Exemple
La suite d'instructions
if (A>B)
MAX=A;
else
MAX=B;
peut être remplacée par :
MAX = (A > B) ? A : B;
5.13 Structure de choix multiple
Cette forme est utilisée pour faire un choix parmi plusieurs possibilités ce choix
correspond à un traitement qui dépend de la valeur d’un sélecteur.
4.1.6 Structure de choix multiple en langage algorithmique
4.1.6.1 Syntaxe général
Selon <sélecteur> Faire

Liste de valeurs 1 : <Séquence d’instructions 1>
Liste de valeurs 2 : <Séquence d’instructions 2>
…
Liste de valeurs n : <Séquence d’instructions n>
Sinon
<Autre Séquence d’instructions>
Fin Selon.

La séquence d’instructions numéro i sera exécutée si la valeur du sélecteur appartient à
la ième liste de valeurs.
Le sélecteur est une variable ou une expression de type scalaire (le résultat est un entier
ou un caractère).
4.1.6.3 Exemples
 Exemple 1
Ecrire un algorithme qui permet de lire un numéro compris entre 1 et 12 et d’afficher le
nom du mois correspondant.

Si le numéro entré est en dehors de cet intervalle, un message d’erreur doit être affiché.
 Solution
Algorithme mois
Variables
n : Entier
Début
Ecrire(”Entrer le numéro du mois : ”) Lire(n)
Selon n Faire
1 : Ecrire(”janvier”)
2 : Ecrire(”février”)
…
12 : Ecrire(”décembre”)
Sinon
Ecrire(”numéro de mois erroné... ”)
FinSelon
Fin.
 Exemple 2 : simulation d’une calculatrice à 4 opérations
Solution
Algorithme calculatrice
Variables
val1, val2 : Réel
opération : Caractère
Début
Ecrire(”Première opérande : ”) L ire(val1)
Ecrire(”Opération : ”) Lire(opération)
Ecrire(”Deuxième opérande : ”) Lire(val2)
Selon opération Faire
”+” : Ecrire(”Résultat = ”, val1 + val2)
”-” : Ecrire(”Résultat = ”, val1 - val2)
”*” : Ecrire(”Résultat = ”, val1 * val2)
”/” : Si (b # 0) Alors
Ecrire(”Résultat = ”, val1/val2)
Fin.

4.1.7 Structure de choix multiple en C
4.1.7.1 Structure
switch ( expression)
{ case valeur 1 : traitement 1; break;
case valeurs 2: traitement 2; break;
….
case valeur n : traitement n; break ;
default: traitement d ;
}
 Remarque
(1) Expression doit être de type entiers, caractère ou type énuméré, elle ne peut pas
être de type réel ou chaîne de caractère.
(2) Traitement 1, traitement 2….peuvent être des instructions ou des blocs
d’instructions.
4.1.7.2 Exemples
 Exemple 1
switch( x)
{case 1:
jour = ‘’lundi ‘’;
break;
case 2:
jour = ‘‘ Mardi ‘’;
break;
case 3:
jour = ‘‘ Mercredi ‘’;
break;
case 4:
jour = ‘’ Jeudi ‘’;
break;
case 5:
jour = ‘’ vendredi ‘’;
break;
case 6:

jour = ‘‘ Samedi ‘’;

break;
case 7:
jour = ‘’ Dimanche ‘’;
break;
default:
printf("Erreur");
}
 Exemple 2
#include <stdio.h>
main()
{
char c;
printf("Entrer la 1 ere lettre de la saison ");

scanf("% c", &c)
switch ( c)
{
case ‘E‘:
printf (‘‘Ete‘‘ ) ;
case ‘A‘:
printf (‘‘Automne‘‘ ) ;
case ‘H‘:
printf (‘‘Hiver‘‘ ) ;
case ‘P‘:
printf (‘‘Printemps‘‘ ) ;
default:

printf("saison introuvable");
}
return 0;
}
5.14 Conclusion
La structure if permet d’exécuter un traitement selon la valeur d’une condition.

Si le traitement contient plusieurs instructions, il faut le mettre entre deux accolades.
Il existe trois structures conditionnelles :
- SI  IF
- SI NON SI  ELSE IF
- SWITCH  SELON

Chapitre 5 : LA STRUCTURE REPETITIVE
Objectif : Maitriser la définition, l’utilisation et le choix des structures répétitives
Plan du cours
1. La structure : for
2. La structure : do - while
3. La structure : while
4. Les instructions de
débranchements
5. Branchement inconditionnel
6. Exercice : comment faire le choix
de la structure répétitive ?
7. Conclusion

5.1 La structure for
5.1.1 Définition
La structure POUR en langage algorithmique est utilisée pour faciliter la

programmation de boucles de comptage. La structure for en C est plus générale et
beaucoup plus puissante.
5.1.2 La structure pour en langage algorithmique
Pour compteur de valeur initiale A valeur finale Faire

<Séquence d’instructions>
Fin Pour.

Le compteur prend la valeur initiale au moment d’accès à la boucle puis, à chaque
parcours, il passe automatiquement à la valeur suivante dans son domaine jusqu’à
atteindre la valeur finale
Figure 5.1 : Schéma d’exécution d’une boucle « pour ».

5.1.2.3 Exemples
 Exemple 1
Pour i de 1 à 5 Faire
Ecrire(i*10)
FinPour
Cette boucle affiche respectivement les nombres 10, 20, 30, 40 et 50.
 Exemple 2
Ecrire un algorithme qui lit un entier positif n puis affiche tous ses diviseurs.
Solution
Algorithme Diviseurs (* version pour *)
Variables
n, i : Entier
Début
Ecrire(”Entrer un entier positif : ”) L ire(n)
Pour i de 1 à n Faire
Si (n Mod i = 0) Alors
Ecrire(i)
FinSi
FinPour
Fin.
5.1.3 La structure for en C
For ( <expr1> ; <expr2> ; <expr3> )

<bloc d'instructions>
<expr1> est évaluée une fois avant le passage de la boucle.

Elle est utilisée pour initialiser les données de la boucle.
<expr2> est évaluée avant chaque passage de la boucle. Elle est utilisée pour décider si
la boucle est répétée ou non.

<expr3> est évaluée à la fin de chaque passage de la boucle. Elle est utilisée pour
réinitialiser les données de la boucle.
Le plus souvent, for est utilisé comme boucle de comptage :
for ( <init.> ; <cond. répétition> ; <compteur> )
5.1.3.3 Exemples
 Exemple 1
int I;
for (I=0 ; I<=20 ; I++)
printf("Le carré de % d est % d \n", I, I*I);
En pratique, les parties <expr1> et <expr2> contiennent souvent plusieurs initialisations
ou réinitialisations, séparées par des virgules.
 Exemple 2
int n, s;
for (s=0, n=1 ; n<101 ; n++)
tot+=n;
printf("La somme des nombres de 1 à 100 est % d\n", s);
5.2 La structure do – while
5.1.1 La structure Répéter …jusqu’ a, en langage algorithmique
Répéter
Jusqu’à <condition>

La séquence d’instructions est exécutée une première fois, puis l’exécution se répète
jusqu’à ce que la condition de sortie soit vérifiée. Une boucle « répéter » s’exécute
toujours au moins une fois

Figure 5.2 : Schéma d’exécution d’une boucle « répéter »
5.1.1.3 Exemples
 Exemple 1
i 1
Répéter
Ecrire(i*10)
ii+1
Jusqu’a (i > 5)
 Exemple 2
Algorithme Diviseurs (* version répéter *)
Variables
n, i : Entier
Début
Ecrire(”Entrer un entier positif : ”) L ire(n)
i1
Répéter
Ecrire(i)
FinSi

i i + 1
Jusqu’à (i > n)
Fin.
5.1.2 La structure do - while en C

La structure do - while est semblable à la structure while, avec la différence suivante :
* while évalue la condition avant d'exécuter le bloc d'instructions,
* do - while évalue la condition après avoir exécuté le bloc d'instructions. Ainsi
le bloc d'instructions est exécuté au moins une fois.
do
{
bloc d'instructions
}
while ( <expression> ) ;
Le <bloc d'instructions> est exécuté au moins une fois et aussi longtemps que
l'<expression> fournit une valeur différente de zéro.
do - while est comparable à la structure répéter … jusqu’à du langage algorithmique.
5.1.2.2 Exemples
 Exemple 1
Un programme qui calcule la racine carree
#include <stdio.h>
#include <math.h>
main()
{
float N;
do
{
printf("Entrer un nombre (>= 0) : ");
scanf("% f", &N)
}
while (N < 0);

printf("La racine carrée de % .2f est % .2f\n", N, sqrt(N));

return 0;
}
5.3 La structure while
5.1.3 Définition
La structure while correspond tout à fait à la structure tant que du langage
algorithmique.
5.1.4 La structure tant que en langage algorithmique
TantQue <condition> Faire

Fin TantQue.

- Tant que l'<expression logique> fournit la valeur vraie, le <bloc d'instructions>
est exécutée.
- Si l'<expression logique> fournit la valeur faux, l'exécution continue avec
l'instruction qui suit ftant.
- Le <bloc d'instructions> est exécuté zéro ou plusieurs fois.
Figure 5.3 : Schéma d’exécution d’une boucle « tantque »

5.1.4.3 Exemples
 Exemple 1
i1
TantQue (i<=5) Faire
Ecrire(i*10)
i i+1
FinTQ
 Exemple 2
Algorithme Diviseurs (* version tantque *)

Variables
n, i : Entier
Début
Ecrire(”Entrer un entier positif : ”) Lire(n)
i 1
TantQue (i <= n) Faire
Ecrire(i)
FinSi
i i + 1
FinTQ
Fin.
5.1.5 La structure while en C
while ( <expression> )

- Tant que l'<expression> fournit une valeur différente de zéro, le <bloc
d'instructions> est exécutée.

- Si l'<expression> fournit la valeur zéro, l'exécution continue avec l'instruction qui

suit le bloc d'instructions.
- Le <bloc d'instructions> est exécuté zéro ou plusieurs
La partie <expression> peut désigner :
- Une variable d'un type numérique,
- Une expression fournissant un résultat numérique.
La partie <bloc d'instructions> peut désigner :
 Un (vrai) bloc d'instructions compris entre accolades,
 Une seule instruction terminée par un point-virgule.
5.1.5.3 Exemples
Soit un programme qui calcule la factorielle
/* Pour N=0, le résultat sera automatiquement 0!=1 */
I=1;
FACT=1;
while (I<=N)
{
FACT*=I;
I++;
}
printf ("%d! = %.0f\n", N, FACT);
5.4 Les instructions de débranchement
5.1.6 Instruction break (Interrompre)

Une fois lancée cette instruction stoppe immédiatement toutes itérations ou switch en
cours. Elle est limitée à un seul niveau d'imbrication.
Exemple résultat de l’exécution
#include <stdio.h> Affichage à l’écran :
void main(void) Message 0
{int i=0; /* On initialise i à 0 */ Message 1
for(/* Déjà initialisée */;i<10;i++) Message 2
{ Message 3
if (i>5) break; Message 4
printf("Message %d\n",i); Message 5
}
}

5.1.7 L'instruction 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 résultat de l’exécution

#include <stdio.h> Affichage à l’écran :
void main(void) Message 0
{ int i=0; /* On initialise i à 0 */ Message 1
Message 2
for(/* Déjà initialisée */;i<10;i++) Message 3
{ Message 4
if (i==5) continue; Message 6
printf("Message %d\n",i); Message 7
} Message 8
} Message 9
5.5 Branchement inconditionnel
L'instruction goto a besoin d'un paramètre pour lui indiquer le point de reprise du
programme. Ce point est appelé un label.
La syntaxe est la suivante :
{.....
{.....
goto truc;
.....
}
.....
truc:
.....
}
Exemple
#include <stdio.h>
void main(void)
{int i=0; /* On initialise i à 0 */

for(/* Déjà initialisée */;i<10;i++)

{
if (i==5) goto suite;
printf("Message %d\n",i);
}
suite: /* Le reste du programme */

}
5.6 Exercice : comment faire le choix de la structure répétitive ?
5.1.8 Énoncé
Ecrivez un programme qui lit N nombres entiers au clavier et qui affiche leur somme,
leur produit et leur moyenne. Choisissez un type approprié pour les valeurs à afficher. Le
nombre N est à entrer au clavier. Résolvez ce problème,
a) en utilisant while,
b) en utilisant do - while,
c) en utilisant for.
d) Laquelle des trois variantes est la plus naturelle pour ce problème ?
5.1.9 Solution
a) en utilisant while,
#include <stdio.h>
main()
{
int N; /* nombre de données */
int NOMB; /* nombre courant */
int I; /* compteur */
long SOM; /* la somme des nombres entrés */
double PROD; /* le produit des nombres entrés */
printf("Nombre de données : ");

scanf("% d", &N);
SOM=0;

PROD=1;
I=1;
while(I<=N)
{
printf("% d. nombre : ", I);
scanf("% d", &NOMB);
SOM += NOMB;
PROD *= NOMB;
I++;
}
printf("La somme des %d nombres est %ld \n", N, SOM);

printf("Le produit des %d nombres est %.0f\n", N, PROD);
printf("La moyenne des %d nombres est %.4f\n", N, (float)SOM/N);
return 0;
}
b) en utilisant do - while,
Remplacez le bloc de traitement (en gras) de (a) par :
SOM=0;
PROD=1;
I=1;
do
{
printf("% d. nombre : ", I);
scanf("% d", &NOMB);
SOM += NOMB;
PROD *= NOMB;
I++;
}
while(I<=N);
c) en utilisant for.
Remplacez le bloc de traitement (en gras) de (a) par :

for (SOM=0, PROD=1, I=1 ; I<=N ; I++)

{
printf("%d. nombre : ", I);
scanf("%d", &NOMB);
SOM += NOMB;
PROD *= NOMB;
}
d) Laquelle des trois variantes est la plus naturelle pour ce problème ?

La structure for est la plus compacte et celle qui exprime le mieux l'idée de l'algorithme.
D'autre part, elle permet d'intégrer très confortablement l'initialisation et
l'incrémentation des variables dans la structure.
5.7 Conclusion
Une structure itérative permet de répéter un traitement plusieurs fois.

Il existe trois structures itératives :
- for  Pour
- while  Tant que …Faire
- do…while  Répéter … Jusqu’a
break : permet de sortir de la boucle for, while, do ... while.
Continue : permet de passer à l'itération suivante des boucles for, while, do ... while
goto : permet de faire un branchement inconditionnel

Chapitre 6 : LES TABLEAUX
Objectif :
Etre capable de manipuler les tableaux qui sont certainement les variables structurées
les plus populaires, disponibles dans tous les langages de programmation et servent à
résoudre une multitude de problèmes.
Plan du cours
1. Les tableaux à une dimension
1.1 Déclaration et mémorisation
1.2 Initialisation et réservation automatique
1.3 Affichage et affectation

2. Tableau a deux dimensions
2.1 Déclarations
2.2 Accès aux composantes
2.3 Affichage et affectation

3 Exercices de tri, insertion, recherche de valeurs

6.1 Les tableaux à une dimension
6.1.1 Déclaration et mémorisation
6.1.1.1 Déclaration
 Déclaration de tableaux en langage algorithmique
<TypeSimple> tableau <NomTableau>[<Dimension>]
 Déclaration de tableaux en C
<TypeSimple> <NomTableau>[<Dimension>];
Les noms des tableaux sont des identificateurs qui doivent correspondre aux
restrictions prédéfinies.
6.1.1.2 Exemples
Les déclarations suivantes en langage algorithmique,
Entier tableau A[25]

Réel tableau B[100]
Booléen tableau C[10]
Caractère tableau D[30]
Se laissent traduire en C par :

int A[25]; ou bien long A[25]; ou bien …
float B[100]; ou bien double B[100]; ou bien …
int C[10];
char D[30];
6.1.2 Initialisation et réservation automatique
6.1.2.1 Initialisation
Lors de la déclaration d'un tableau, on peut initialiser les composantes du tableau, en
indiquant la liste des valeurs respectives entre accolades.
 Exemples
int A[5] = {10, 20, 30, 40, 50};

float B[4] = {-1.05, 3.33, 87e-5, -12.3E4};
int C[10] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1};

6.1.2.2 Réservation automatique

Si la dimension n'est pas indiquée explicitement lors de l'initialisation, alors l'ordinateur
réserve automatiquement le nombre d'octets nécessaires.
 Exemple 1
int A[] = {10, 20, 30, 40, 50}; ==> réservation de 5*sizeof(int) octets (dans notre cas: 10
octets) ;
float B[] = {-1.05, 3.33, 87e-5, -12.3E4}; ==> réservation de 4*sizeof(float) octets (dans
notre cas: 16 octets) ;
int C[] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1}; ==> réservation de 10*sizeof(int) octets (dans notre
cas: 20 octets).
 Exemple 2
Short A[ ] ={1200, 2300, 3400, 4500, 5600} ;
A: 1200 2300 3400 4500 5600
Short A[5] ={1200, 2300, 3400} ;
A: 1200 2300 3400 0 0
 Remarque
Il faut évidemment veiller à ce que le nombre de valeurs dans la liste corresponde à la

dimension du tableau. Si la liste ne contient pas assez de valeurs pour toutes les
composantes, les composantes restantes sont initialisées par zéro.
6.1.3 Affichage et affectation
6.1.3.1 Définition
La structure for se prête particulièrement bien au travail avec les tableaux. La plupart
des applications se laissent implémenter par simple modification des exemples-types de
l'affichage et de l'affectation.
6.1.3.2 Affichage du contenu d'un tableau

Traduisons le programme AFFICHER du langage algorithmique en C :
programme AFFICHER

| entier tableau A[5]

| entier I (* Compteur *)
| pour I variant de 1 à 5 faire
| écrire A[I]
| fpour
fprogramme
main()
{
int A[5];
int I; /* Compteur */
for (I=0; I<5; I++)
printf("% d ", A[I]);
return 0;
printf("\n");
}
6.1.3.3 Affectation avec des valeurs provenant de l'extérieur

Soit le programme REMPLIR du langage algorithmique suivant :
programme REMPLIR
| entier tableau A[5]
| entier I (* Compteur *)
| lire A[I]
| fpour
fprogramme
sa traduction en c :
main()
{
int A[5];
int I; /* Compteur */
for (I=0; I<5; I++)
scanf("% d", &A[I]);
return 0;
}

6.1.3.4 Remarques
- Comme scanf a besoin des adresses des différentes composantes du tableau, il
faut faire précéder le terme A[I] par l'opérateur adresse '&'.
- La commande de lecture scanf doit être informée du type exact des données à
lire. (Ici : % d ou % i pour lire des valeurs du type int)
6.2 Tableau a deux dimensions
6.2.1 Déclarations
6.2.1.1 Déclaration de tableaux à deux dimensions en langage

algorithmique
<TypeSimple> tableau <NomTabl>[<DimLigne>,<DimCol>]
6.2.1.2 Déclaration de tableaux à deux dimensions en C
<TypeSimple> <NomTabl>[<DimLigne>][<DimCol>];
6.2.1.3 Exemple
Les déclarations suivantes en langage algorithmique,
entier tableau A[10,10]

réel tableau B[2,20]
booléen tableau C[3,3]
caractère tableau D[15,40]
Se laissent traduire en C par :
int A[10][10]; ou bien long A[10][10]; ou bien ...

float B[2][20]; ou bien double B[2][20]; ou bien ...
int C[3][3];
char
D[15][40];
6.2.2 Accès aux composantes
6.2.2.1 Accès à un tableau à deux dimensions en langage algorithmique

<NomTableau>[<Ligne>, <Colonne>]

6.2.2.2 Accès à un tableau à deux dimensions en C

<NomTableau>[<Ligne>][<Colonne>]
6.2.3 Affichage et affectation
6.2.3.1 Introduction
Lors du travail avec les tableaux à deux dimensions, nous utiliserons deux indices (I et
J), et la structure for, imbriquée, pour parcourir les lignes et les colonnes des tableaux.
6.2.3.2 Affichage du contenu d'un tableau à deux dimensions

Traduisons le programme AFFICHER du langage algorithmique en C :
programme AFFICHER
| entier tableau A[5,10]
| entier I,J
| (* Pour chaque ligne ... *)
| (* ... considérer chaque composante *)
| pour J variant de 1 à 10 faire
| écrire A[I,J]
| fpour
| (* Retour à la ligne *)
| écrire
| fpour
fprogramme
main()
{
int A[5][10];
int I,J;
/* Pour chaque ligne ... */
for (I=0; I<5; I++)
{
/* ... considérer chaque composante */
for (J=0; J<10; J++)
printf("% 7d", A[I][J]);

/* Retour à la ligne */
printf("\n");
}
return 0;
}
6.2.3.3 Affectation avec des valeurs provenant de l'extérieur

Traduisons le programme REMPLIR du langage algorithmique en C :
Programme REMPLIR
| entier tableau A[5,10]
| entier I, J
| (* Pour chaque ligne ... *)
| (* ... considérer chaque composante *)
| pour J variant de 1 à 10 faire
| lire A[I,J]
| fpour
| fpour
fprogramme
main()
{
int A[5][10];
int I,J;
/* Pour chaque ligne ... */
for (I=0; I<5; I++)
/* ... considérer chaque composante */
for (J=0; J<10; J++)
scanf("% d", &A[I][J]);
return 0;
}

6.3 Exercices de tri, insertion, recherche de valeurs
6.3.1 Enoncés
Exercice N°1 : Maximum et minimum des valeurs d'un tableau
Ecrire un programme qui détermine la plus grande et la plus petite valeur dans un
tableau d'entiers A. Afficher ensuite la valeur et la position du maximum et du
minimum. Si le tableau contient plusieurs maxima ou minima, le programme retiendra la
position du premier maximum ou minimum rencontré.
Exercice N°2 : Insérer une valeur dans un tableau trié
Un tableau A de dimension N+1 contient N valeurs entières triées par ordre croissant ;
la (N+1)ième valeur est indéfinie. Insérer une valeur VAL donnée au clavier dans le
tableau A de manière à obtenir un tableau de N+1 valeurs triées.
Exercice N° 3 : Recherche d'une valeur dans un tableau
Problème :
Rechercher dans un tableau d'entiers A une valeur VAL entrée au clavier. Afficher la
position de VAL si elle se trouve dans le tableau, sinon afficher un message
correspondant. La valeur POS qui est utilisée pour mémoriser la position de la valeur
dans le tableau, aura la valeur -1 aussi longtemps que VAL n'a pas été trouvée.
Implémenter deux versions :

a) La recherche séquentielle
Comparer successivement les valeurs du tableau avec la valeur donnée.
b) La recherche dichotomique ('recherche binaire', 'binary search')
Condition : Le tableau A doit être trié
Comparer le nombre recherché à la valeur au milieu du tableau,
 s'il y a égalité ou si le tableau est épuisé, arrêter le traitement avec un message
correspondant.
 si la valeur recherchée précède la valeur actuelle du tableau, continuer la
recherche dans le demi-tableau à gauche de la position actuelle.
 si la valeur recherchée suit la valeur actuelle du tableau, continuer la recherche
dans le demi-tableau à droite de la position actuelle.
Ecrire le programme pour le cas où le tableau A est trié par ordre croissant.

Question : Quel est l'avantage de la recherche dichotomique ? Expliquer brièvement.
Exercice N° 4 : Tri par sélection du maximum
Problème
Classer les éléments d'un tableau A par ordre décroissant.
Méthode
Parcourir le tableau de gauche à droite à l'aide de l'indice I. Pour chaque élément A[I]
du tableau, déterminer la position PMAX du (premier) maximum à droite de A[I] et
échanger A[I] et A[PMAX].
Exemple
Exercice N°5 : Tri par propagation (bubble sort)
Problème
Classer les éléments d'un tableau A par ordre croissant.
Méthode
En recommençant chaque fois au début du tableau, on effectue à plusieurs reprises le
traitement suivant : On propage, par permutations successives, le plus grand élément du
tableau vers la fin du tableau (comme une bulle qui remonte à la surface d'un liquide).

Exemple
Implémenter l'algorithme en considérant que :

- La partie du tableau (à droite) où il n'y a pas eu de permutations est triée.
- Si aucune permutation n'a eu lieu, le tableau est trié.
6.3.2 Solutions des exercices
Exercice N°1 : Maximum et minimum des valeurs d'un tableau
#include <stdio.h>
main()
{
/* Déclarations */
int A[50]; /* tableau donné */
int N; /* dimension */
int I; /* indice courant */
int MIN; /* position du minimum */
int MAX; /* position du maximum */
/* Saisie des données */
printf("Dimension du tableau (max.50) : ");

scanf("% d", &N );

for (I=0; I<N; I++)
{
printf("Elément % d : ", I);
}
/* Affichage du tableau */
printf("Tableau donné :\n");
for (I=0; I<N; I++)
printf("\n");
/* Recherche du maximum et du minimum */
MIN=0;
MAX=0;
for (I=0; I<N; I++)
{
if(A[I]>A[MAX]) MAX=I;
if(A[I]<A[MIN]) MIN=I;
}
/* Edition du résultat */
printf("Position du minimum : % d\n", MIN);
printf("Position du maximum : % d\n", MAX);
printf("Valeur du minimum : % d\n", A[MIN]);
printf("Valeur du maximum : % d\n", A[MAX]);
return 0;
Exercice N°2 : Insérer une valeur dans un tableau trié
#include <stdio.h>
main()
{
/* Déclarations */
int VAL; /* valeur à insérer */

printf("Dimension N du tableau initial (max.50) : ");

scanf("% d", &N );

for (I=0; I<N; I++)
{
}
printf("Elément à insérer : ");
scanf("% d", &VAL );
printf("Tableau donné : \n");
for (I=0; I<N; I++)
printf("\n");
/* Déplacer les éléments plus grands que */
/* VAL d'une position vers l'arrière. */
for (I=N ; (I>0)&&(A[I-1]>VAL) ; I--)
A[I]=A[I-1];
/* VAL est copié à la position du dernier */
/* élément déplacé. */
A[I]=VAL;
/* Nouvelle dimension du tableau ! */
N++;
/* Edition des résultats */
printf("Tableau résultat :\n");
for (I=0; I<N; I++)
printf("\n");
return 0;
}
Exercice N°3 : Recherche d'une valeur dans un tableau
a) La recherche séquentielle
Comparer successivement les valeurs du tableau avec la valeur donnée.
#include <stdio.h>
main()
{

/* Déclarations */
int VAL; /* valeur à rechercher */
int POS; /* position de la valeur */

scanf("% d", &N );
for (I=0; I<N; I++)
{
}
printf("Elément à rechercher : ");
for (I=0; I<N; I++)
printf("\n");
/* Recherche de la position de la valeur */
POS = -1;
for (I=0 ; (I<N)&&(POS==-1) ; I++)
if (A[I]==VAL)
POS=I;
if (POS==-1)
printf("La valeur recherchée ne se trouve pas "
"dans le tableau.\n");
else
printf("La valeur % d se trouve à la position % d. \n",
VAL, POS);
return 0;
}

b) La recherche dichotomique ('recherche binaire', 'binary search')
#include <stdio.h>
main()
{
/* Déclarations */
int VAL; /* valeur à rechercher */
int POS; /* position de la valeur */
int INF, MIL, SUP; /* limites du champ de recherche */

scanf("% d", &N );
for (I=0; I<N; I++)
{
}
printf("Elément à rechercher : ");
for (I=0; I<N; I++)
printf("\n");
/* Initialisation des limites du domaine de recherche */
INF=0;
SUP=N-1;
/* Recherche de la position de la valeur */
POS=-1;
while ((INF<=SUP) && (POS==-1))
{
MIL=(SUP+INF)/2;
if (VAL < A[MIL])

SUP=MIL-1;
else if (VAL > A[MIL])
INF=MIL+1;
else
POS=MIL;
}
if (POS==-1)
printf("La valeur recherchée ne se trouve pas "
"dans le tableau.\n");
else
printf("La valeur % d se trouve à la position % d. \n",
VAL, POS);
return 0;
}
Question : Quel est l'avantage de la recherche dichotomique ?
Dans le pire des cas d'une recherche séquentielle, il faut traverser tout le tableau avant
de trouver la valeur ou avant d'être sûr qu'une valeur ne se trouve pas dans le tableau.
Lors de la recherche dichotomique, on élimine la moitié des éléments du tableau à
chaque exécution de la boucle. Ainsi, la recherche se termine beaucoup plus rapidement.
La recherche dichotomique devient extrêmement avantageuse pour la recherche dans de
grands tableaux (triés) : L'avantage de la recherche dichotomique par rapport à la
recherche séquentielle monte alors exponentiellement avec la grandeur du tableau à
trier.
Exemple
Lors de la recherche dans un tableau de 1024 éléments :
 le pire des cas pour la recherche séquentielle peut entraîner 1024 exécutions de la
boucle.
 le pire des cas pour la recherche dichotomique peut entraîner 10 exécutions de la
boucle.
Lors de la recherche dans un tableau de 1 048 576 éléments :
 le pire des cas pour la recherche séquentielle peut entraîner 1 048 576 exécutions
de la boucle.
 le pire des cas pour la recherche dichotomique peut entraîner 20 exécutions de la
boucle.

Exercice N°4 : Tri par sélection du maximum
#include <stdio.h>
main()
{
/* Déclarations */
int I; /* rang à partir duquel A n'est pas trié */
int J; /* indice courant */
int AIDE; /* pour la permutation */
int PMAX; /* indique la position de l'élément */
/* maximal à droite de A[I] */

scanf("% d", &N );
for (J=0; J<N; J++)
{
printf("Elément % d : ", J);
scanf("% d", &A[J]);
}
for (J=0; J<N; J++)
printf("% d ", A[J]);
printf("\n");
/* Tri du tableau par sélection directe du maximum. */

for (I=0; I<N-1; I++)
{
/* Recherche du maximum à droite de A[I] */

PMAX=I;
for (J=I+1; J<N; J++)
if (A[J]>A[PMAX]) PMAX=J;
/* Echange de A[I] avec le maximum */
AIDE=A[I];
A[I]=A[PMAX];
A[PMAX]=AIDE;
}
printf("Tableau trié :\n");
for (J=0; J<N; J++)
printf("\n");
return 0;
}
Exercice N°5 : Tri par propagation (bubble sort)

#include <stdio.h>
main()
{
/* Déclarations */
int I; /* rang à partir duquel A est trié */
int J; /* indice courant */
int AIDE; /* pour la permutation */
int FIN; /* position où la dernière permutation a eu lieu. */
/* permet de ne pas trier un sous-ensemble déjà trié. */

scanf("% d", &N );
for (J=0; J<N; J++)
{
printf("Elément % d : ", J);
scanf("% d", &A[J]);

}
for (J=0; J<N; J++)
printf("\n");
/* Tri du tableau par propagation de l'élément maximal. */
for (I=N-1 ; I>0 ; I=FIN)
{
FIN=0;
for (J=0; J<I; J++)
if (A[J]>A[J+1])
{
FIN=J;
AIDE=A[J];
A[J]=A[J+1];
A[J+1]=AIDE;
}
}
printf("Tableau trié :\n");
for (J=0; J<N; J++)
printf("\n");
return 0;
}

Chapitre 7 : LES STRUCTURES
Objectif : Maitriser la définition et l’utilisation des structures en langage C.
Plan du cours
1. Notion de structure
2. Déclaration et initialisation de structure
3. Operations sur les structures
4. Tableaux de structures

7.1 Notion de structure
Il est habituel en programmation d'avoir besoin d'un mécanisme permettant de grouper

un certain nombre de variables de types différents au sein d'une même entité. On
travaille par exemple sur des personnes, et on voudrait regrouper une variable de type
Chaine de caractères pour le nom, une variable de type entier pour le numéro
d'employée, etc…
La réponse à ce besoin est le concept d'enregistrement : un enregistrement est un
ensemble d'éléments de types différents repérés par un nom.
Les éléments d'un enregistrement sont appelés des champs.
Le langage C possède le concept d'enregistrement avec :
Algorithme Langage C
Enregistrement Structure
champ d'un enregistrement membre d'une structure
7.2 Déclaration et initialisation de structure
7.2.1 Déclaration d’une structure

Il y a plusieurs méthodes possibles pour déclarer des structures.
7.2.1.1 Première méthode
La déclaration :
struct Etudiant
{
char nom[20];
char prénom[20];
int no_carte;
};
Déclaré l'identificateur Etudiants comme étant le nom d'un type de structure composée
de trois membres, dont le premier est un tableau de 20 caractères nommé nom, le

second un tableau de 20 caractères nommé prénom, et le dernier un entier nommé no

carte. On peut ensuite utiliser ce type structure pour déclarer des variables, de la
manière suivante :
struct Etudiant E1,E2;

qui déclare deux variables de type struct Etudiant de noms E1 et E2;
7.2.1.2 Deuxième méthode
On peut déclarer des variables de type structure sans utiliser d'étiquette de structure,
par exemple :
struct
{
char nom[20];
char prénom[20];
int no_carte;
} E1,E2;
Déclaré deux variables de noms E1 et E2 comme étant deux structures de trois
membres, mais elle ne donne pas de nom au type de la structure. L'inconvénient de
cette méthode est qu'il sera par la suite impossible de déclarer une autre variable du
même type. Si plus loin on écrit :
struct
{
char nom[20];
char prénom[20];
int no_carte ;
} E3;
Il sera impossible en particulier d'écrire E3 = E1;.
7.2.1.3 Troisième méthode
On peut combiner déclaration d'étiquette de structure et déclaration de variables,

comme ceci :
struct Etudiant
{
char nom[20];
char prenom[20];
int no_carte;
} E1,E2;

Ici, on pourra utiliser ultérieurement le nom struct Etudiant pour déclarer d'autres
variables :
struct Etudiant ET1, ET2, ET3; qui seront du même type que E1 et E2.
De ces trois méthodes c'est la première qui est recommandée, car elle permet de bien
séparer la définition du type structure de ses utilisations.
7.2.2 Initialisation d'une structure

Une structure peut être initialisée par une liste d'expressions constantes comme des
initialisations de tableau. Exemple :
struct Etudient E= {"mohamed amine", "hajji", 0983};
7.3 Operations sur les structures
7.3.1 Accès aux membres des structures

Pour désigner un membre d'une structure, il faut utiliser l'opérateur de sélection de
membre qui se note . (point). Par exemple, si E1 et E2 sont deux variables de type
struct Etudiant, on désignera le membre nom de E1 par E1.nom et on désignera le
membre no_carte de E2 par E2.no_carte. Les membres ainsi désignés se comportent
comme N’importe quelle variable et par exemple, pour accéder au premier caractère du
nom de
E2, on écrira : E2.nom[0].
7.3.2 Affectation de structures

On peut affecter une structure a une variable structure de même type, grâce à
l'opérateur D’affectation :
struct Etudiant E1,E2
...
E1 = E2;
7.3.3 Comparaison de structures

Aucune comparaison n'est possible sur les structures, même pas les opérateurs == et
!=.
7.4 Tableaux de structures
Une déclaration de tableau de structures se fait selon le même modèle que la

déclaration d'un tableau dont les éléments sont de type simple. Supposons que l'on ait

déjà déclaré la struct personne, si on veut déclarer un tableau de 100 structures de ce

type, on écrira :
struct personne tabp[100];
Pour référencer le nom de la personne qui a l'index i dans tabp on écrira : tabp[i].nom.
7.5 Exercice
7.5.1 Enoncé
1. Déclarer les structures suivantes
Point : abscisse, ordonné
date : jour , mois anneés
employé : nom , prénom , age ,salaire
2. Ecrire un programme qui permet de déclarer remplir afficher un tableau de 100

structure de type commande sachant q une commande est caractériser par nom, article
nombre et prix.
7.5.2 Solution
2.
#include <stdio.h>
int main()
{
struct commande
{
char nom[80];
char article[80];
int nombre,prix;
};
#define nb_com 100
struct commande tab_com[nb_com]; /* tableau des commandes */
int i; /* index dans tab_com */
int ilast; /* dernier index valide dans tab_com apr_es remplissage */

/* boucle de lecture des commandes */

i = 0;
while(i < nb_com )
{
scanf(fi,"% s % s % d % d", tab_com[i].nom, tab_com[i].article, &tab_com[i].nombre,

&tab_com[i].prix)
i++;
if (i >= nb_com)
printf("le tableau tab_com est sous-dimentionn_e\n");
else
/* ----------------------------------- */
ilast = i - 1;
for (i = 0; i <= ilast; i++)
printf("% s % s % d % d\n", tab_com[i].nom, tab_com[i].article,
tab_com[i].nombre, tab_com[i].prix);

Chapitre 8 : LES CHAÎNES DE CARACTÈRES
INTRODUCTION
Il n'existe pas de type spécial chaîne ou string en C. Une chaîne de caractères est traitée
comme un tableau de caractères a une dimension
OBJECTIF
Connaitre les notations, les fonctions et les règles générales pour le traitement des
chaines de caractères.
Plan du cours :
1. Les chaines de caractères
1.1 Déclaration et mémorisation
1.2 Les chaînes de caractères constantes
1.3 Initialisation de chaînes de caractères
1.4 Accès aux éléments d'une chaîne
2. Les bibliothèques de fonctions de C pour le traitement de
chaînes de caractères
2.1 Les fonctions de <stdio.h>
2.2 Les fonctions de <string>
2.3 Les fonctions de <ctype>
3. Tableaux de chaînes de caractères
3.1 Déclaration, initialisation et mémorisation :
3.2 Accès aux chaînes :
3.3 Affectation
3.4 Algorithmes qui traitent les caractères et chaines de
caractères
4. Solution et exercices d application

8.1 Les chaines de caractères

8.1.1 Déclaration et mémorisation
8.1.1.1 Déclaration
 Déclaration de chaînes de caractères en langage algorithmique :

chaîne <NomVariable>
 Déclaration de chaînes de caractères en C

char <NomVariable> [<Longueur>];
 Exemples
char NOM [20];

char PRENOM [20];
char PHRASE [300];
8.1.1.2 Espace à réserver

Lors de la déclaration, nous devons indiquer l'espace à réserver en mémoire pour le
stockage de la chaîne.
La représentation interne d'une chaîne de caractères est terminée par le symbole '\0'
(NUL). Ainsi, pour un texte de n caractères, nous devons prévoir n+1 octets.
8.1.2 Les chaînes de caractères constantes

* Les chaînes de caractères constantes sont indiquées entre guillemets. La chaîne de
caractères vide est alors : " "
* Dans les chaînes de caractères, nous pouvons utiliser toutes les séquences
d'échappement définies comme caractères constants :
"Ce \ntexte \nsera réparti sur 3 lignes."
* Le symbole " peut être représenté à l'intérieur d'une chaîne par la séquence
d'échappement \" :
"Affichage de \"guillemets\" \n"
* Le symbole ' peut être représenté à l'intérieur d'une liste de caractères par la
séquence d'échappement \' :
{'L','\'','a','s','t','u','c','e','\0'}.

8.1.3 Initialisation de chaînes de caractères

En général, les tableaux sont initialisés par l'indication de la liste des éléments du
tableau entre accolades :
char CHAINE[] = {'H','e','l','l','o','\0'};
Pour le cas spécial des tableaux de caractères, nous pouvons utiliser une initialisation
plus confortable en indiquant simplement une chaîne de caractère constante :
char CHAINE[] = "Hello";
 Exercice d’application
Enoncé
Lesquelles des chaînes suivantes sont initialisées correctement ? Corrigez les
déclarations fausses et indiquez pour chaque chaîne de caractères le nombre d'octets qui
sera réservé en mémoire.
a) char a[] = "un\ndeux\ntrois\n";
b) char b[12] = "un deux trois";
c) char c[] = 'abcdefg';
d) char d[10] = 'x';
e) char e[5] = "cinq";
f) char f[] = "Cette " "phrase" "est coupée";
g) char g[2] = {'a', '\0'};
h) char h[4] = {'a', 'b', 'c'};
i) char i[4] = "'o'";
Solution
a) char a[ ] = "un\ndeux\ntrois\n";
Déclaration correcte
Espace : 15 octets
b) char b[12] = "un deux trois";
Déclaration incorrecte: la chaîne d'initialisation dépasse le bloc de mémoire réservé.
Correction : char b[14] = "un deux trois";
ou mieux : char b[] = "un deux trois";
Espace : 14 octets
c) char c[] = 'abcdefg';

Déclaration incorrecte : Les symboles '' encadrent des caractères ; pour initialiser avec
une chaîne de caractères, il faut utiliser les guillemets (ou indiquer une liste de
caractères).
Correction : char c[] = "abcdefg";
Espace : 8 octets
d) char d[10] = 'x';
Déclaration incorrecte: Il faut utiliser une liste de caractères ou une chaîne pour
l'initialisation
Correction: char d[10] = {'x', '\0'}
ou mieux: char d[10] = "x";
Espace: 2 octets
e) char e[5] = "cinq";
Espace: 5 octets
f) char f[] = "Cette " "phrase" "est coupée";
Espace: 24 octets
g) char g[2] = {'a', '\0'};
Espace: 2 octets
h) char h[4] = {'a', 'b', 'c'};
Déclaration incorrecte: Dans une liste de caractères, il faut aussi indiquer le symbole de
fin de chaîne.
Correction: char h[4] = {'a', 'b', 'c', '\0'};
Espace: 4 octets
i) char i[4] = "'o'";
Déclaration correcte, mais d'une chaîne contenant les caractères '\'', 'o', '\'' et '\0'.
Espace: 4 octets.
8.1.4 Accès aux éléments d'une chaîne

L'accès à un élément d'une chaîne de caractères se fait de la même façon que l'accès à
un élément d'un tableau. En déclarant une chaîne par :
char A[6];

8.2 Les bibliothèques de fonctions de C pour le traitement de chaînes de

caractères
8.2.1 Les fonctions de <stdio.h>

 A côté des fonctions printf et scanf que nous connaissons déjà, nous y trouvons
les deux fonctions puts et gets, spécialement conçues pour l'écriture et la lecture
de chaînes de caractères.
 Pour l’affichage de chaînes de caractères on utilise :
printf avec le spécificateur de format % s permet d'intégrer une chaîne de
caractères dans une phrase.
Exemple 1
Char NOM = "hello, world";
printf(":% s:", NOM); >- :hello, world:
puts est idéale pour écrire une chaîne constante ou le contenu d'une variable dans une
ligne isolée.
Syntaxe : puts( <Chaîne> )

Effet : puts écrit la chaîne de caractères désignée par <Chaîne> sur stdout et provoque
un retour à la ligne. En pratique, puts(TXT); est équivalent à printf("% s\n",TXT);
Exemple 2
char TEXTE[] = "Voici une première ligne.";

puts(TEXTE);
Lecture de chaînes de caractères
scanf avec le spécificateur % s permet de lire un mot isolé à l'intérieur d'une suite de
données du même ou d'un autre type.
Exemple 1
char LIEU[25];
int JOUR, MOIS, ANNEE ;
printf("Entrez lieu et date de naissance : \n");
scanf("% s % d % d % d", LIEU, &JOU R, &MOIS, &ANNEE);
gets est idéal pour lire une ou plusieurs lignes de texte (p.ex. des phrases) terminées par
un retour à la ligne.

Syntaxe : gets( <Chaîne> )

gets lit une ligne de de caractères de stdin et la copie à l'adresse indiquée par
<Chaîne>.
Le retour à la ligne final est remplacé par le symbole de fin de chaîne '\0'.
Exemple 2
int MAXI = 1000;

char LIGNE[MAXI];
gets(LIGNE);
8.2.2 Les fonctions de <string>

Dans le tableau suivant, <n> représente un nombre du type int. Les symboles <s> et
<t> peuvent être remplacés par :
* une chaîne de caractères constante
* le nom d'une variable déclarée comme tableau de char
* un pointeur sur char (voir chapitre 9).
 Fonctions pour le traitement de chaînes de caractères

fournit la longueur de la chaîne sans compter le
strlen(<s>)
'\0' final
strcpy(<s>, <t>) copie <t> vers <s>
strcat(<s>, <t>) ajoute <t> à la fin de <s>
compare <s> et <t> lexicographiquement et
strcmp(<s>, <t>)
fournit un résultat:
si <s> précède
négatif
<t>
si <s> est égal à
zéro
<t>
positif si <s> suit <t>
strncpy(<s>, <t>, copie au plus <n> caractères de <t> vers <s>

<n>)
strncat(<s>, <t>, ajoute au plus <n> caractères de <t> à la fin de
<n>) <s>

 Conversion de chaînes de caractères en nombres

atoi(<s>) retourne la valeur numérique représentée par <s> comme int
atol(<s>) retourne la valeur numérique représentée par <s> comme long
retourne la valeur numérique représentée par <s> comme double
atof(<s>)
(!)
8.2.3 Les fonctions de <ctype>
Fonctions de classification et de conversion
Les fonctions de classification suivantes fournissent un résultat du type int différent de

zéro, si la condition respective est remplie, sinon zéro.
La fonction : retourne une valeur différente de zéro,

isupper(<c>) si <c> est une majuscule ('A'...'Z')
islower(<c>) si <c> est une minuscule ('a'...'z')
si <c> est un chiffre décimal
isdigit(<c>)
('0'...'9')
isalpha(<c>) si islower(<c>) ou isupper(<c>)
isalnum(<c>) si isalpha(<c>) ou isdigit(<c>)
isxdigit(<c>) si <c> est un chiffre hexadécimal
('0'...'9' ou 'A'...'F' ou 'a'...'f')
isspace(<c>) si <c> est un signe d'espacement
8.3 Tableaux de chaînes de caractères
8.3.1 Règle générale

Il est nécessaire de créer un tableau de chaînes de caractères, pour alléger les
déclarations des variables et simplifie l'accès aux différents mots (ou phrases).
8.3.2 Déclaration, initialisation et mémorisation

Un tableau de chaînes de caractères correspond à un tableau à deux dimensions du type
char, où chaque ligne contient une chaîne de caractères.
Déclaration

La déclaration char JOUR[7][9]; réserve l'espace en mémoire pour 7 mots contenant 9

caractères pace en mémoire pour 7 mots contenant 9 caractères (dont 8 caractères
significatifs).
Figure 8.1 : exemple d’un tableau de chaines de caractères.
8.3.3 Accès aux chaînes

Il est possible d'accéder aux différentes chaînes de caractères d'un tableau, en
indiquant simplement la ligne correspondante.
Exemple
L'exécution des trois instructions suivantes :
char JOUR[7][9]= {"lundi", "mardi", "mercredi",
"jeudi", "vendredi",
"samedi", "dimanche"};
int I = 2;
printf("Aujourd'hui, c'est % s !\n", JOUR[I]);
Affichera la phrase : Aujourd'hui, c'est mercredi !
8.3.4 Affectation
L'attribution d'une chaîne de caractères à une composante d'un tableau de chaînes se
fait en général à l'aide de la fonction strcpy:
Exemple
La commande strcpy(JOUR[4], "Friday");
Changera le contenu de la 5e composante du tableau JOUR de "vendredi" en "Friday".
Accès direct aux différents caractères qui composent les mots du tableau.
Exemple
L'instruction
for(I=0; I<7; I++)

printf("% c ", JOUR[I][0]);
Va afficher les premières lettres des jours de la semaine :

l m m j v s d
8.4 Algorithmes qui traitent des caractères et des chaînes de caractères
8.4.1 Fonctions standards sur les caractères

Fonction Rôle Exemple
i  Asc(‘’A’’)
Asc(c) Retourne le code ASCII du caractère c.
i contiendra 65
c Car(65)
Car(i) Retourne le caractère dont le code ASCII est égal à i.
 i contiendra A
c  Succ(‘’c’’)
Succ(c) Retourne le successeur de caractère c.
 c contiendra ‘’d’’
c  Pred(‘’y’’)
Pred(c) Retourne le prédécesseur de caractère c.
 c contiendra ‘’x’’
c  Majus(‘’t’’)
Majus(c) Retourne le majuscule de caractère c.
 c contiendra ‘’T’’
Tableau 8.1 : Fonctions standards sur les caractères.
8.4.2 Procédures standards sur les chaines de caractères

chn  ‘’fatma kaabi’’
Enlève N caractères de chaîne) à
Efface(Chaîne, P, N) efface(chn, 6, 7)
partir de la position P donnée.
chn contiendra ‘’fatma’’
Ch1  ‘’D’’
Insère la chaîne Ch1 dans la chaîne Ch2  ‘’AA’’
Insert(Ch1, Ch2, P)
Ch2 à partir de la position P. Insert(ch1, ch2, 2)
 ch2 contiendra ‘’ADA’’
n = 333 convch(n, chn)
Converti le nombre Nbr en une
Convch(Nbr, Ch)  chn contiendra la chaîne
chaîne de caractères Ch.
‘’333’’
Tableau 8.2 : Procédures standards sur les chaines de caractères.

8.4.3 Fonction standards sur les chaines de caractères

chn  ‘’Turbo Pascal’’
Long(Chaîne) Retourne la longueur de la chaîne. n  Long(chn)
n contiendra 12
Ch1  ‘’Turbo Pascal’’
Copie N caractères de chaîne à
Copie(Chaîne, P, N) Ch2  Copy(Ch1, 7, 6)
partir de la position P donnée.
Ch2 contiendra ‘’Pascal’’
Ch1  ‘’as’’
Retourne la position de la première
Ch2  ‘’Turbo Pascal’’
Convch(Nbr, Ch) occurrence de la chaîne Ch1 dans
n  position(Ch1, Ch2)
la chaîne Ch2.
 n contiendra 8
Tableau 8.3 : Fonctions standards sur les chaines de caractères.
8.5 Exercices d’applications
Exercice N°1
Ecrire un programme qui lit une ligne de texte (ne dépassant pas 200 caractères) la
mémorise dans une variable TXT et affiche ensuite :
a) la longueur L de la chaîne.
b) le nombre de 'e' contenus dans le texte.
c) toute la phrase à rebours, sans changer le contenu de la variable TXT.
d) toute la phrase à rebours, après avoir inversé l'ordre des caractères dans TXT:
Solution
#include <stdio.h>
main()
{
/* Déclarations */
char TXT[201]; /* chaîne donnée */
int I,J; /* indices courants */
int L; /* longueur de la chaîne */
int C; /* compteur des lettres 'e' */
int AIDE; /* pour l'échange des caractères */
printf("Entrez une ligne de texte (max.200 caractères) :\n");

gets(TXT); /* L'utilisation de scanf est impossible pour */

/* lire une phrase contenant un nombre variable de mots. */
/* a) Compter les caractères */

/* La marque de fin de chaîne '\0' est */
/* utilisée comme condition d'arrêt. */
for (L=0; TXT[L]; L++)
;
printf("Le texte est composé de % d caractères.\n",L);
/* b) Compter les lettres 'e' dans le texte */

C=0;
for (I=0; TXT[I]; I++)
if (TXT[I]=='e') C++;
printf("Le texte contient % d lettres \'e\'.\n",C);
/* c) Afficher la phrase à l'envers */

for (I=L-1; I>=0; I--)
putchar(TXT[I]); /* ou printf("% c",TXT[I]); */
putchar('\n'); /* ou printf("\n"); */
/* d) Inverser l'ordre des caractères */

for (I=0,J=L-1 ; I<J ; I++,J--)
{
AIDE=TXT[I];
TXT[I]=TXT[J];
TXT[J]=AIDE;
}
puts(TXT); /* ou printf("% s\n",TXT); */
return 0;
}
Exercice N°2
Ecrire un programme qui demande l'introduction du nom et du prénom de l'utilisateur

et qui affiche alors la longueur totale du nom sans compter les espaces. Employer la
fonction strlen.

Exemple
Introduisez votre nom et votre prénom :

Mickey Mouse
Bonjour Mickey Mouse !
Votre nom est composé de 11 lettres.
Solution
#include <stdio.h>
#include <string.h>
main()
{
char NOM[40], PRENOM[40];
printf("Introduisez votre nom et votre prénom: \n");
scanf("% s % s", NOM, PRENOM);
printf("\nBonjour % s % s !\n", NOM, PRENOM);
printf("Votre nom est composé de % d lettres.\n",
strlen(NOM) + strlen(PRENOM));
/* ou bien
printf("Votre nom est composé de % d lettres.\n",
strlen(strcat(NOM,PRENOM)));
*/
return 0;
}
Exercice N°3
Ecrire un programme qui lit deux chaînes de caractères CH1 et CH2 et qui copie la
première moitié de CH1 et la première moitié de CH2 dans une troisième chaîne CH3.
Afficher le résultat.
a) Utiliser les fonctions spéciales de <string>.
b) Utiliser uniquement les fonctions gets et puts.
c) Utiliser les fonctions spéciales de <string>.
Solution
#include <stdio.h>

#include <string.h>
main()
{
/* Déclarations */
char CH1[100], CH2[100]; /* chaînes données */
char CH3[100]=""; /* chaîne résultat */
printf("Introduisez la première chaîne de caractères : ");
gets(CH1);
printf("Introduisez la deuxième chaîne de caractères : ");
gets(CH2);
/* Traitements */
strncpy(CH3, CH1, strlen(CH1)/2);
strncat(CH3, CH2, strlen(CH2)/2);
/* Affichage du résultat */
printf("Un demi \"% s\" plus un demi \"% s\" donne \"% s\"\n",
CH1, CH2, CH3);
return 0;
}
b) Utiliser uniquement les fonctions gets et puts.
#include <stdio.h>
main()
{
/* Déclarations */
char CH1[100], CH2[100]; /* chaînes données */
char CH3[100]=""; /* chaîne résultat */
int L1,L2; /* longueurs de CH1 et CH2 */
int I; /* indice courant dans CH1 et CH2 */
int J; /* indice courant dans CH3 */

puts("Introduisez la première chaîne de caractères : ");
gets(CH1);
puts("Introduisez la deuxième chaîne de caractères : ");
gets(CH2);

/* Détermination les longueurs de CH1 et CH2 */

for (L1=0; CH1[L1]; L1++) ;
for (L2=0; CH2[L2]; L2++) ;
/* Copier la première moitié de CH1 vers CH3 */
for (I=0 ; I<(L1/2) ; I++)
CH3[I]=CH1[I];
/* Copier la première moitié de CH2 vers CH3 */
J=I;
for (I=0 ; I<(L2/2) ; I++)
{
CH3[J]=CH2[I];
J++;
}
/* Terminer la chaîne CH3 */
CH3[J]='\0';
/* Affichage du résultat */
puts("Chaîne résultat : ");
puts(CH3);
return

Quelques sujets d’examens

République tunisienne
Ministère de l’enseignement supérieur de la recherche scientifique et de technologie
DGET_ Institut Supérieur des Etudes Technologiques de KAIROUAN

Département Génie Electrique

Devoir de synthèse du 04/01/2011

Proposé par : Mmes. F. Kaabi & M. Hmizi
U E ECUE Groupes Niveau Durée Crédits Coeff.
Informatique Algorithmique et programmation GE L1_S1 1 heure 30 2 3
(N.B : Il est rappelé aux candidats que la qualité de la rédaction et la clarté des raisonnements, entreront pour
une part importante dans l'appréciation des copies).
Barème approximatif de notation : {[4pts] ; [6pts] ; [10pts]}.
Partie A :
1. Citer les étapes de résolution d’un problème ?

2. Quel est le rôle d’un compilateur ?
3. Quelle est la différence entre fonction et procédure ? Justifiez votre réponse à
l’aide d’un exemple.
Partie B :
Exercice N°1 :
Une date est représentée sous la forme d'une chaîne de 8 caractères.

Par exemple : "22/02/99".
Ecrire un programme en C qui permet, à partir d'une date au format français
"JJ/MM/AA", de calculer la même date au format américain "MM/JJ/AA". Ce
programme doit se servir d’une procédure permutation.
Exercice N°2 :
Ecrire un algorithme et sa traduction en c qui permet de :

1. Saisir un entier N avec 5 ≤N < 20.
2. Remplir un tableau T avec N entiers de 3 chiffres.

3. Trier le tableau T dans l’ordre croissant suivant le nombre de dizaines de ses

éléments.
4. Afficher le tableau T après le tri.
Exemple :
Pour N = 7
T avant le tri : 123 456 975 460 900 830 214
T après le tri : 900 214 123 830 456 460 975
Remarque : Pour trier le tableau, utiliser une méthode de tri de votre choix.
Bon travail


Références bibliographiques
Livres et supports pédagogiques
[1] Cormen, Leiserson et Rivest ; Introduction à l'algorithmique : Cours et exercices, Dunod, 2002.
[2] Guy Cousineau et Michel Mauny, Approche fonctionnelle de la programmation, Sciences
international.
[3] Hafedh El Ayech, Cahier de TD en Langage de Programmation C, Institut Supérieur de Gestion IAG.
[4] Bernard Cassagne, Support de cours Introduction au langage C (ANSI/C), Laboratoire clips
Université Grenoble.
[5] Issaa Maloug, Support de travaux pratique programmation C, ISET Mahdia.
[6] Afifa Ghlifa Zgerni, Support de court algorithme et structure de données II.
[7] Olfa Hamrouni, Support de cours algorithmique, ISET jerba.
Sites web
[1] www.technologuepro.com /cours informatique/algorithmique.

[2] www.technologuepro.com /cours informatique/programmation C.
[3] www.misfu.com/cours/tutoriel /algorithmique
[4] tutoriel langage de programmation C Auteur Fred Faber cours exercices et solutions.


Cours Structuré 1 VF

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 Structuré 1 VF

Transféré par

Droits d'auteur :

Formats disponibles

Support de cours

Par Fatma KAABI HAJJI

Année universitaire : 2014/2015

Mme. Fatma KAABI HAJJI Page 2

Table des matières

Chapitre 1 : INTRODUCTION GENERALE ................................................................. 13

Chapitre 2 : LANGAGE DE PROGRAM MATION C ..................................................... 19

Chapitre 3 : LIRE ET ÉCRIRE DES DONNÉES ........................................................... 29

Mme. Fatma KAABI HAJJI Page 3

3.4 Lecture d'un caractère ...................................................................................... 33

Chapitre 4 : LA STRUCTURE ALTERNATIVE ............................................................ 36

Chapitre 5 : LA STRUCTURE REPETITIVE ................................................................ 46

Mme. Fatma KAABI HAJJI Page 4

Chapitre 6 : LES TABLEAUX ...................................................................................... 59

Chapitre 7 : LES STRUCTURES ................................................................................. 77

Chapitre 8 : LES CHAÎNES DE CARACTÈRES ............................................................ 83

Mme. Fatma KAABI HAJJI Page 5

8.3.4 Affectation ................................................................................................... 90

Quelques sujets d’examens .......................................................................................... 97

Références bibliographiques ....................................................................................... 101

Mme. Fatma KAABI HAJJI Page 6

Mme. Fatma KAABI HAJJI Page 7

Le langage C a été créé en 1972 par Denis Ritchie avec un objectif

La plupart des chapitres proposent des exercices d’applications avec

Mme. Fatma KAABI HAJJI Page 8

Liste des figures

Figure 1.1 : Fonctionnement d’un ordinateur. 14

Mme. Fatma KAABI HAJJI Page 9

Liste des tableaux

TABLEAU 2.1 : LES COMMANDES C. 25

Mme. Fatma KAABI HAJJI Page 10

Mme. Fatma KAABI HAJJI Page 11

Mme. Fatma KAABI HAJJI Page 12

Chapitre 1 : INTRODUCTION GENERALE

Objectif : Connaitre le but du cours d’algorithme et programmation.

1. Qu’est-ce qu’une application

Mme. Fatma KAABI HAJJI Page 13

5.1 Introduction générale

1.1.1 Qu’est-ce qu’une application informatique

1.1.2 Lien entre algorithme et programme

On appelle un algorithme toute suite d’étapes si élémentaires et simple à exécuter.

1.1.3 Les étapes de résolution d’un problème

Illustration du fonctionnement d’un ordinateur :

Figure 1.1 : fonctionnement d’un ordinateur.

Mme. Fatma KAABI HAJJI Page 14

5.2 Structure d’un algorithme

Cet algorithme permet d'afficher sur l'écran la phrase suivante :

Mme. Fatma KAABI HAJJI Page 15

1.1.6 Corps d’un algorithme

(1) Partie Saisie (Périphériques d’entrées MC)

ECRIRE("donner un 2éme entier ")

Mme. Fatma KAABI HAJJI Page 16

5.3 Introduction à la programmation

Le langage machine constitué de 0 et 1 est d’une utilisation fastidieuse (difficile) c’est

1.1.8 Les langages de programmation

1.1.8.1Classification selon le degré d’indépendance

Mme. Fatma KAABI HAJJI Page 17

1.1.8.2Les langages compilés

1.1.8.3Les langages interprétés

Mme. Fatma KAABI HAJJI Page 18

Chapitre 2 : LANGAGE DE PROGRAMM ATION C

Objectif : Motivation au langage c.

Mme. Fatma KAABI HAJJI Page 19