INITIALISATION A L’ALGOITHMIQUE

ANNÉE ACADEMIQUE : 2019-2020

ALGORITHMIQUE
ET LANGAGE

SUPPORT DE COURS

BTS TECHNOLOGIQUE (IDA, SEI, RIT etc.)

ENSEIGNANT : Dr. PINATIBI (CEL : 79715429)

1
INTRODUCTION
Vous savez ordinateur, mais connaissez-vous les mécanismes utilisés ? Etes-vous
vraiment sûr que le résultat affiché soit juste ? Combien de temps devrez-vous attendre
la fin du calcul ? N’y a-t-il pas un moyen de l’obtenir plus vite ? Que vous soyez
ingénieur, mathématicien, physicien, statisticien et surtout informaticien, toutes ces
questions vous vous les posez. Si vous êtes étudiant, elles surgiront très rapidement.
Étudier l’algorithmique, c’est apporter des réponses à vos questions. Cette science est
le cœur de l’informatique, pour tous ceux qui doivent ou devront faire travailler un
ordinateur, il est essentiel de comprendre ses principes fondamentaux et de connaître
ses éléments de base. Une voiture de formule un (1) ne se conduit pas comme une
voiture à pédales. De même un ordinateur ne s’utilise pas comme un boulier.
L’algorithmique est le permis de conduire de l’informatique. Sans elle, il n’est pas
concevable d’exploiter sans risque un ordinateur. Il faut noter que même si par abus
l’on enseigne aux étudiants en informatique que le système d’exploitation est le
programme de base de l’ordinateur, la réalité est tout autre. En effet, dès la maison de
construction il y’a un premier programme qui permet d’identifier le constructeur d’un
ordinateur et de gérer les principales composantes de l’unité centrale. C’est le BIOS
(Basic Input Output Système) entant que programme, il est basé sur la logique
algorithmique. Comme nous pouvons le constater les programmes informatiques sont
au début de l’ordinateur, car ce sont eux qui permettent au matériel de fonctionner. Il
est donc indispensable pour tout individu en contact avec l’ordinateur, encore plus pour
les informaticiens débutants de comprendre la logique algorithmique. Face à
l’importance de cette « Science » les questions suivantes s’avèrent nécessaires,
Qu’est-ce que l’algorithmique ?, qu’elles sont les principes de base de
l’algorithmique ?, comment écrire un algorithme ? Nous essayerons de donner des
réponses à ces différentes préoccupations à travers ce document.

2
1 Définition

L’algorithmique peut être définie comme un ensemble de méthodes permettant de

résoudre de manière automatique (ordinateurs, smartphones, guichets automatiques
etc.) un problème. Elle est définie également comme un ensemble de méthodes qui
en un nombre fini d’étapes et dans un ordre bien défini permettent de transformer des
données d’entrée ou INPUT en données de sortie ou OUTPUT grâce à des traitements
particuliers. Le mot “algorithme” vient du mathématicien et astronome perse
Muhammad ibn al-Khawarizmi, le père de l'algèbre, qui formalisa au IXe siècle la
notion d'algorithme. La logique algorithmique peut être illustrée à l’aide du diagramme
ci-dessous :

Données d’entrée Algorithme Données de sortie ou

ou INPUT OUTPUT

Figure 1 : Illustration de la logique algorithmique

1.1 Langage de Description d’Algorithme (LDA)

Il est nécessaire de disposer d'un langage qui soit non lié à l'implémentation. Ceci
permet une description plus précise des structures de données ainsi qu'une rédaction
de l'algorithme plus souple et plus lisible. Le langage EXALGO est un exemple de ce
qui peut être utilisé et qui sera utilisé dans ce cours. Il est composé de chaînes, de
mots réservés, de signes opératoires et de signes de ponctuation.

1.1.1 Mots réservées

Les mots réservés du LDA sont nombreux, les plus utilisés sont les suivants :
-Lire : ce mot clé permet d’enregistrer des données dans une variable à l’aide du
clavier de l’ordinateur.
-Ecrire ou Afficher : Ce mot clé permet d’afficher un résultat ou une information à
l’écran de l’ordinateur.
-Algorithme : Ce mot clé précède le nom d’un algorithme ;
- Var : Ce mot clé permet de déclarer une variable ;
- fonction : Ce mot clé permet de déclarer une fonction ;

3
- Procedure : Ce mot clé permet de déclarer une procédure ;
- Const : Ce mot clé permet de déclarer une constante ;
- Debut : Ce mot clé précède le début du corps d’un algorithme ;
- Fin. : Ce mot clé met fin au corps de l’algorithme.
NB : Les mots réservés peuvent s’écrire aussi bien en minuscule qu’en majuscule.

1.1.2 Signes opératoires

Les signes opératoires utilisés en algorithmiques sont la plupart des signes utilisés en
arithmétique ce sont :

- (+ ) : Pour l’addition ;
- ( - ) : Pour la soustraction ;
- ( * ) : Pour la multiplication ;
- ( / ): Pour la division ;
- (< ): Pour la comparaison d’infériorité absolue ;
- (<=) : Comparaison d’infériorité non absolue ;
- (> ) : Comparaison de supériorité absolue ;
- (>=) : Comparaison de supériorité non absolue ;
- ( = ) : Comparaison d’égalité ;
- OU : L’opérateur ou inclusif ;
- NON : L’opérateur de négation ;
- ET : L’opérateur ou exclusif ;
- (← ) : L’opérateur d’affectation;
- ( // ou { } ) : Pour écrire des commentaires dans l’algorithme.

1.2 Etapes d’écriture et formalisme d’un algorithme

1.2.1 Etapes d’écriture d’un algorithme
Un algorithme peut se concevoir et s’implémenter en quatre étapes principales qui
sont l’analyse du problème, la description des objets (données d’entrée et de sortie),
la description des étapes et l’écriture de l’algorithme.

1.2.1.1 Analyse du problème

Cette étape consiste à lire attentivement le problème à résoudre à l’aide de
l’algorithme. Ainsi, le concepteur de l’algorithme sera amené à se poser certaines

4
questions qui sont : que demande le problème ? Qu’elles sont les informations
données par le sujet ? Qu’elle moyens ou méthodes sont disponibles pour résoudre
ce genre de problème? Qu’elle type de résultats fournira la résolution de ce problème
? Comme il faut le remarquer, l’analyse du problème permet de comprendre en détaille
le problème poser et les moyens disponibles à sa résolution.

1.2.1.2 Description des objets

L’étape de la description des objets permet de recenser les données fournies par le
problème en deux catégories, données d’entrée et de sortie. Il sera question ensuite
de donnée un nom ou identifiant, un type et une description ou utilisation à chaque
donnée se trouvant dans chaque catégorie. Il faut noter que dans le cas où le problème
nomme les différents objets qu’il fournit, le concepteur de l’algorithme peut conserver
ces noms.

1.2.1.3 Description des étapes

Cette étape consiste à énumérer de manière exhaustive les différentes actions à
exécutées sur les objets décrits plus haut dans l’ordre chronologique. Il faut noter que
Un algorithme doit avoir un nombre fini d’étapes (actions), se terminer après un
nombre fini d’opérations et fournir un résultat.

1.2.1.4 Ecriture de l’algorithme

L’écriture de l’algorithme permet de traduire les étapes décrites précédemment à l’aide
du LDA afin de les transformer en algorithme. Elle commence par le mot clé
ALGORITHME ou ALGO qui désigne le nom de l’algorithme, contient les mots clés
VAR, CONST, etc. pour la déclaration des objets et se termine par le bloc DEBUT et
FIN., pour le corps de l’algorithme.

Il faut noter qu’après l’écriture de l’algorithme, il sera question de le traduire dans un

langage de programmation. Cette étape se fera dans la partie langage de
programmation.

1.2.2 Formalisme ou syntaxe générale d’un algorithme

Les algorithmes sont constitués de manière générale des éléments que sont l’entête
de l’algorithme, la partie déclaration de l’algorithme et le corps de l’algorithme.
5
1.2.2.1 L’entête de l’algorithme

Cette partie de l’algorithme permet de donner les informations sur le nom ou identifiant
de l’algorithme. Il faut noter que le nom de l’algorithme est généralement en relation
avec le problème que permet de résoudre ce dernier, cependant ce n’est pas une
obligation de donner un nom en relation avec le sujet de l’algorithme. Le nom d’un
algorithme doit seulement être conforme aux conditions d’écriture de l’identifiant d’une
variables (nous verrons ces conditions dans la suite de ce cours). L’entête d’un
algorithme commence toujours par le mot clé ALGORITHME OU ALGO.

1.2.2.2 La partie déclaration d’un algorithme

C’est au niveau de la partie déclaration de l’algorithme que sont décrits de manière

détaillée les objets énumérés au niveau de l’étape de description des objets. La
déclaration des objets se fait toujours selon le sigle ECTVPF, entendez par cet
acronyme Etiquette, Constante, Type, Variable, Procédure et Fonction. Cependant de
manière générale les éléments qui sont récurrents dans la partie déclaration sont les
variables déclarées à l’aide du mot clé VAR et les constantes déclarées à l’aide du
mot clé CONST.

1.2.2.3 Le corps de l’algorithme

Le corps de l’algorithme regroupe les différentes étapes décrites au cours de la partie

description des étapes selon l’ordre dans lequel elles ont été énumérées. Il faut noter
que les étapes sont constituées d’action à réaliser, ces actions sont un ensemble
d’instruction permettant de produire des résultats. Il faut noter également que même
si ce n’est pas une obligation il est préférable que les instructions se terminent par un
point-virgule (;). Le corps de l’algorithme se concentre dans le bloc délimité par les
mots clés DEBUT et FIN.

La syntaxe générale d’un algorithme peut se présentée comme suit :

6
Algo exemple ; /*Entête de l’algorithme*/
/* La partie déclaration de l’algorithme */
/* Les constantes nécessitent une valeur dès leur déclaration */
Const var1←20 : entier ;
Const var2←"bonjour!" : chaîne ;
/* les variables proprement dites */
Var var3, var4 : réels ;
Var var5 : chaîne ;
Début /* corps de l’algorithme */
/* instructions */ ;
Fin.
1.2.3 Variables

Les variables sont des emplacements de la mémoire dans lesquels sont ou peuvent-
être stockées des informations. Une variable est constituée d’un nom ou
identificateur, d’une valeur et d’un type.

1.2.3.1 Nom ou identificateur

Il permet à l’ordinateur de localiser la variable dans sa mémoire. Un identificateur ne

comporte aucun espace ou caractère spécial et ne peut pas être un mot clé. C’est une
suite de lettres ou de digit accolés, commençant par une lettre.

On appelle lettre un caractère de 'a'..'z' ou 'A'..'Z' ou '_'.

On appelle digit un caractère de '0'..'9'.

Exemples

x, y1, jour, mois, annee, NbCouleurs, longueur_ligne.

7
Remarques
1 Il n'y a pas de différence entre minuscules et majuscules.
2 On n'a pas le droit de mettre d'accents, ni de caractères de ponctuation.
3 Un identificateur doit être différent des mots clés (début, fin, écrire etc.)

On se sert des identificateurs pour : le nom du programme, les noms de variables, les
noms de constantes, les noms de types.

1.2.3.2 Valeur d’une variable

Elle désigne l’information (souvent un nombre) que la variable contient ;

1.2.3.3 Type d’une variable

Le type caractérise l’ensemble des valeurs que peut prendre la variable ;

L’ensemble des variables est stocké dans la mémoire de l’ordinateur. Il faut noter qu’il
existe plusieurs catégorie de variables les variables prédéfinies ou variables de base
qui sont reconnues par les différents copulateurs de programmes, les variables créer
par les programmeurs (types énumérés etc.).

1.2.3.4 Types de base ou types prédéfinis

1.2.3.4.1 Type entier : Integer (Langage Pascal)

Ce sont des entiers signé en complément à deux sur 16 ou 32 bits, selon la machine
et le compilateur : 16 pour Turbo Pascal, 32 pour Delphi. C’est un sous-ensemble
de Z.

Sur 16 bits, les valeurs varient entre −32 768 et + 32 767.

Sur 32 bits, les valeurs varient entre −2 147 483 648 et + 2 147 483 647.
 Opérateurs sur les entiers :

+ : pour l’addition ;
– : pour la soustraction;
* : pour la multiplication ;
/ : Pour la division ;
x div y : dividende de la division entière de x par y ;
x mod y reste de la division entière, avec y non nul ;
8
= : Comparaison d’égalité ;
< : Comparaison d’infériorité ;
<= : Comparaison d’infériorité ou d’égalité ;
> : Comparaison de supériorité ;
>= : Comparaison de supériorité ou d’égalité ;
<> : Différence ;
Remarques
 Attention, les opérateurs /, div et mod, produisent une erreur à l'exécution si y
est nul.
 Lorsqu'une valeur (ou un résultat intermédiaire) dépasse les bornes au cours
de l'exécution, on a une erreur appelée débordement arithmétique.

1.2.3.4.2 Type réel : real (Langage Pascal)

Le type réels en algorithmique représentent un sous-ensemble de D. Leur domaine de
définition dépend de la machine et du compilateur utilisés. On code un réel avec une
certaine précision, et les opérations fournissent une valeur approchée du résultat dit
« juste ». Il faut donc se méfier.
 Opérateurs sur les réels :

+ : pour l’addition ;
– : pour la soustraction;
* : pour la multiplication ;
/ : Pour la division ;
= : Comparaison d’égalité ;
< : Comparaison d’infériorité ;
<= : Comparaison d’infériorité ou d’égalité ;
> : Comparaison de supériorité ;
>= : Comparaison de supériorité ou d’égalité ;
<> : Différence ;
1.2.3.4.3 Type caractères : char (Langage Pascal)
Ce sont les jeux des caractères comportant les lettres, les digits, l'espace, les
ponctuations, Etc. le type caractère est codé sur un octet non signée.

9
  Opérateurs sur les caractères :
= : Comparaison d’égalité ;
< : Comparaison d’infériorité ;
<= : Comparaison d’infériorité ou d’égalité ;
> : Comparaison de supériorité ;
>= : Comparaison de supériorité ou d’égalité ;
<> : Différence ;

1.2.3.4.4 Type Booléens : boolean (Langage Pascal)

C’est un type utilisé pour les expressions logiques. Il comprend deux valeurs possibles
: false (faux) et true (vrai).

 Opérateurs sur les booléens

Les opérations usuelles sont ET, OU et NON qui sont données dans les tables de
vérité.

1.3 Premier algorithme

Exemple

Ecrire un algorithme qui permet de calculer et d’afficher à l’écran l’intérêt I et la valeur

acquise V par un capital initial C placé à un taux d’intérêt i pendant un an et
préalablement saisie au clavier.

Solution
 Analyse du problème

Dans ce problème nous avons comme données d’entrée le capital C et i.

Les données de sortie sont la valeur acquise V et l’intérêt I.

 Description des objets

Variables d’entrée

C : Le capital placé : réel

i : Le taux d’intérêt : réel

10
Variables de sortie

I : Intérêt produit par la somme placée : réel

V : Valeur acquise par la somme placée : réel

 Description des actions

1- Afficher la demande de lecture des données d’entrée

Afficher (‘Saisissez le capital C et le taux d’intérêt I S.V.P !’) ;
2- Lire les variables d’entrée
Lire (C, i) ;
3- Calculer l’intérêt et la valeur acquise
I ← C*i*n /100 ;
V← C+I ;
4- Afficher le résultat de l’algorithme
Afficher (‘La valeur acquise et l’intérêt produit par la somme C ont’, ‘ ’, V,’ ’, ‘et’, ‘ ’, I) ;
 Ecriture de l’algorithme
ALGORITHME Calcul ;
VAR C, I, V, i : réel ;
DEBUT
Afficher (‘Saisissez le capital C et le taux d’intérêt i S.V.P !’) ;
Lire (C, i) ;
I ← C*i*n /100 ;
V← C+I ;
Afficher (‘La valeur acquise et l’intérêt produit par C sont’, ‘ ’, V,’ ’, ‘et’, ‘ ’, I) ;
FIN.
1.4 Structures de contrôle

Il existe deux grands groupes de structures de contrôle les structures répétitives ou

boucles et les structures conditionnelles

1.4.1 Structures conditionnelles

Une structures conditionnelle permet d’exécuter ou non un bloc d’instructions selon le

résultat d’un test (choix binaire). Dans le cadre d’une structure conditionnelle nous

11
avons la structure conditionnelle complète, la structure conditionnelle incomplète, la
structure conditionnelle imbriquée et la structure conditionnelle par cas.

1.4.1.1 Structure conditionnelle complète

Cette structure conditionnelle donne lieu à deux possibilités selon une condition test.
Si la condition test est vérifiée l’action 1 est exécutée, si par contre elle ne l’est pas
l’action 2 est exécutée. La syntaxe de cette instruction est la suivante.

Si <condition> Alors
< action 1>
Sinon
< action 2> ;
Finsi ;

Si la condition 1 est vérifiée, alors on exécute l’instruction 1, sinon on exécute

l’instruction 2.

1.4.1.2 Structure conditionnelle incomplète

La structure conditionnelle incomplète donne lieu à une seule possibilité. Si la condition

test est vérifié l’action est exécutée dans le cas contraire il y’a une sortie de la structure.
La syntaxe est la suivante.

Si <condition> Alors
< action1 > ;
Finsi ;

Si la condition est vérifiée, alors on exécute l’instruction 1 [sinon on ne fait rien]

1.4.1.3 Structure conditionnelle imbriquée

Cette structure conditionnelle donne lieu à N+ 1 possibilités selon N condition test. Si

la condition test 1 est vérifiée l’action 1 est exécutée, sinon si la condition test 2 est

12
vérifiée l’action 2 est exécutée, sinon si la condition test 3 est vérifiée l’action 3 est
exécutée, …, si la condition test N est vérifiée l’action N est exécutée, sinon l’action
N+ 1 est exécutée. La syntaxe est la suivante.

si <condition1>
alors < action1 >
sinon si <condition2>
alors < action2 >
sinon si <condition3>
alors < action3>
sinon
< action4>
Finsi
Finsi
Finsi ;

1.4.1.4 Structure conditionnelle par cas : L’instruction Cas

L’instruction cas est utilisée pour éviter d’imbriquer un trop grand nombre de structures
conditionnelles (problèmes de lisibilité à partir de 3 / 4 niveaux). Elle permet donc
d’éviter certaines imbrications de conditionnelles donc de traiter directement des choix
qui ne sont plus binaires. Elle est réservée à des conditions bien précises (égalité
variable - constantes). Sa syntaxe est la suivante :

cas <variable> vaut

<Valeurs1> : <action1> ;
<Valeurs2> : < action2> ;
<ValeursN> : < action N>
autre <action autre>
Fincas ;

13
1.4.2 Structures répétitives ou boucles

Les structures répétitives permettent d’effectuer un traitement à plusieurs reprises.

Il existe trois principales structures répétitives ou boucles :
- la boucle TANT QUE

- la boucle REPETER (ou boucle JUSQU’À CE QUE)

- la boucle POUR (extension de la boucle TANT QUE)

1.4.2.1 La boucle TANT QUE

Cette boucle permet de répéter la même action ou un bloc d’actions tant que qu’une
condition test est vérifiée. Il faut noter que cette boucle peut ne jamais être exécutée,
si la condition n’est pas vérifiée pour la première itération. La syntaxe est la suivante.

Tantque <condition> faire

< actions >
FinTQ ;

TANT QUE la condition est vraie :

- on effectue l’instruction (ou le bloc d’instructions)
- on revient au début de la boucle
Lorsque la condition est fausse, on sort de la boucle.
1.4.2.2 boucle REPETER

Cette boucle permet de répéter la même action ou un bloc d’actions jusqu’à ce qu’une
condition soit vérifiée. Il faut noter que cette boucle est toujours exécutée au moins
une fois, avant que la condition limite ne soit vérifiée. La syntaxe est la suivante.

Répéter
< actions >
JusquÀ <condition>;

14
- on effectue l’instruction (ou le bloc d’instructions)

- on revient au début de la boucle

Jusqu’à ce que la condition soit fausse. Lorsque la condition est fausse, on sort de la
boucle.

1.4.2.3 boucle POUR

Il est fréquent que le nombre de répétitions soit connu à l'avance, et que l'on ait besoin
d'utiliser le numéro de l'itération afin d'effectuer des calculs ou des tests. Le
mécanisme permettant cela est la boucle Pour.

Pour VariableIndicatrice allant de val_min à val_max faire

< actions > ;

Finpour ;

1.5 Types de variables composées

Les types de variables composées utilisent soit plusieurs valeurs de même type ou
une combinaison de plusieurs types. Nous avons par exemples les types énumérés,
les tableaux, les enregistrements, les fichiers etc

1.5.1 Types énumérés

Il est fréquent en programmation que l'on ait à distinguer plusieurs cas, et que l'on
cherche à coder le cas à l'aide d'une variable. Ceci est très pratique mais dans un
programme un peu long cela devient rapidement difficile à comprendre, car il faut se
souvenir de la signification du code. D'où l'intérêt d'utiliser un type énumérée, qui
permet de donner un nom aux valeurs de code. Par exemple pour résoudre un
problème lié aux feux tricolore, il est possible au programmeur de créer de type
énuméré nommé feu dont la déclaration se fait comme suit.

Feux : (Rouge, Orange, Vert, Clignotant);

L’utilisation de ce type peut se faire à l’aide de l’algorithme ci-dessous :

15
ALGO feu_tri ;
VAR
Feux : (Rouge, Orange, Vert, Clignotant) ;
DEBUT
Si Feux = Rouge
Alors
Afficher (‘Arrêter’)
Sinon si Feux = Orange
Alors
Afficher (‘Ralentir’)
Sinon si Feux = Vert
Afficher (‘Passer’) ;
Fsi
Fsi
Fsi
FIN.
Remarque
-En écrivant cette ligne de déclaration, on déclare en même temps :
-la variable feux, de type énuméré (toujours codée sur un entier),
-et les constantes nommées Rouge, Orange, Vert et Clignotant.
-A ces constantes sont attribuées les valeurs 0, 1, 2, 3 (la première constante prend
Toujours la valeur 0).
-On ne peut pas choisir ces valeurs soi-même et ces identificateurs ne doivent
pas déjà exister.
-L'intérêt n'est pas de connaître ces valeurs, mais d'avoir des noms explicites.

1.5.2 Types tableau

Un tableau est une structure de données regroupant un ensemble de variables de

même type et est une table d'association à clé unique. Afin d'éviter de multiplier le
nombre des variables, on regroupe les données dans un tableau.

16
 Exemple de tableau d’entiers de dimension 8, indicé de 1 à 8

5 0 2 19 -5 2 1 8
T[1] T[2] T[3] T[4] T[5] T[6] T[7] T[8]
Remarque
-le nombre d'éléments de la table (dimension ou taille) est constant,
-l'accès aux éléments s'effectue directement par la clé,
-les valeurs minimum et maximum des clés sont des constantes.
La variable T précédente est de type tableau d’entiers indicé de 1 (valeurs minimum
des clés) à 8 (valeurs maximum des clés).
On accède aux valeurs du tableau par T [1], T [2], …, T [8] (valeurs prise par la clé).
L’indice doit être une expression entière (constante, variable, calcul).
La déclaration d’une variable de type tableau se réalise comme suit :

Nom_tableau=tableau [Min_indice..Max_indice] de type_predefini ;

Pour le tableau précédent on n’écrira

T= [1..8] d’entiers ;
Ce qui signifie que
-les éléments ont pour type le type_prédéfini

-les indices des éléments vont de Min_indice à Max_indice, avec

Min_indice<Max_indice,

-La taille du tableau est donc (Max_indice - Min_indice+1).

-Pour accéder à un élément d'un tableau T d'indice i, on écrit T [i].

Notation : Soit Min_indice<i<j<Max_indice, on notera T [i..j] la séquence des

Éléments de T (T[i], T [i+1],..., T[j]).

17
1.5.2.1 Initialisation d'un tableau

ALGO init_tableau ;
Tab = tableau [Min_indice..Max_indice] d’entiers ;
i : entier ;
Début
Pour i de Min_indice à Max_indice faire
Tab[i] ← 0 ;
Fpour ;
Fin.
Cet algorithme permet d’avoir un tableau dont tous les éléments sont égaux à zéro.

1.5.2.2 Taille d'un tableau

T= tableau [Min_indice. .Max_indice] : entier ;

D : entier ;
Début
D = (Min_indice - Max_indice +1)
Afficher (‘La taille du tableau T est‘, ‘ ’, D) ;
Fin.
Cet algorithme permet d’avoir la dimension d’un tableau.
1.5.2.3 Echange d'éléments
ALGO ech_tableau ;
T= tableau [Min_indice..Max_indice] : entier ;
Val indice1, indice2 : entier ;
Var E : T ;
Début
E = T [indice1] ;
T [indice1]=T [indice2] ;
T [indice2]= E ;
Fin.

18
Cet algorithme permet d’échanger des éléments d’indice différents dans un tableau
1.5.2.4 Copie de tableau
ALGO copie_tableau ;
T1 = tableau [Min_indice..Max_indice] : entier ;
T2 = tableau [Min_indice..Max_indice] : entier ;
Val indiceT1_1, indiceT1_2, indiceT2 : entier ;
Var i : entier ;
Début
Si (indiceT2 + indiceT1_2 - indiceT1_1) > Max_indice alors
Afficher (‘faux’)
Sinon
Pour i allant de indice T1_1 à indice T1_2 faire
T2 [indiceT2] = T1 [i];
indiceT2 = indiceT2 + 1;
Finpour
Afficher (‘vrai’) ;
Finsi
Fin.
Cet algorithme permet de copier les éléments du tableau T2 dans le tableau T1.
1.5.2.5 Somme des éléments d’un tableau
ALGO som_tab ;
T= tableau [Min_indice..Max_indice] : entier ;
Var s, i : entier;
Début
s←0 ;
Pour i allant de Min_indice à Max_indice faire
s= s + T[i]
Finpour
Afficher (s) ;
Fin.

19
Cet algorithme permet de faire la somme des éléments du tableau T
1.5.2.6 Recherche d'un élément
T= tableau [Min_indice..Max_indice] : entier ;
Val e : entier;
Var i : entier;
Début
Pour i allant de Min_indice à Max_indice faire
Si T[i] ==e alors
Afficher (i)
Finpour
Afficher (T[i]) ;
Fin.
Cet algorithme permet de recherche un élément précis d’un tableau

1.5.3 Matrices
Une matrice M de dimension n x m est un tableau de dimension n dont chaque
élément est un tableau de dimension m. On peut donc déclarer la matrice sous la
forme suivante.

Nom_matrice = tableau [1..n] de tableau [1..m] de type_predefini ;

1.5.3.1 Initialisation
ALGO init_tableau ;
Tab = tableau [1..n] de tableau [1..m] d’entiers ;
Var i, j : entier ;
Début
Pour i allant de 1 à n faire
Pour j allant de 1 à m faire
Tab [i, j]=0
Finpour
Finpour
Fin.

20
Cet algorithme permet de recherche un élément précis d’un tableau
1.5.3.2 Somme de deux matrices
ALGO som_mat ;
M1 = tableau [1..n] de tableau [1..m] de réels ;
M2 = tableau [1..n] de tableau [1..m] de réels ;
Var i, j : entier;
Var M : tableau [1..n] de tableau [1..m] de réels;
Début
Pour i allant de 1 à n faire
Pour j allant de 1 à m faire
M [i, j]=M1 [i, j] +M2 [i, j] ;
Finpour
Finpour
Fin.
Cet algorithme permet de recherche un élément précis d’un tableau
1.6 Tri d’un tableau
1.6.1 Tri sélection

Ce tri est basé sur l'algorithme de recherche du minimum. On adapte cet algorithme
pour pouvoir effectuer la recherche dans un sous-tableau. On a le déroulement ici

 Recherche du minimum
ALGO minimum ;
T= tableau [1..N] d'entiers ;
Val i, Imin, Imax : entier ;
Var sauv : entier ;

Debut
sauv = Imin ;
Pour i allant de Imin+1 à Imax faire
Si T[i] <T[sauv] alors
Sauv = i ;
Finsi
Finpour
Afficher (i) ;
Fin.

21
Cet algorithme permet de recherche le plus petit élément d’un tableau
ALGO Tri_selection ;

T= tableau [1..N] d'entiers ;

Val i, j : entier ;
Var sauv : entier ;
Var E : T ;

Debut

/* Recherche du minimum */

Pour i allant de 1 à N-1 faire

Pour j allant de 1 à N-1 faire
Si T[j] <T [j+1] alors
/* échanger */
E= T[j] ;
T[j] = T [j+1] ;
T [j+1]= E ;
sauv = j ;
Finsi
Finpour
Finpour
Fin.

Cet algorithme permet de trier un tableau de N entiers.

1.6.2 Tri insertion et tri à bulle

Soit T un tableau d'entiers triés d'indice variant entre i et j. Soit E un entier

quelconque, alors on a l'une des propriétés suivantes :

- E ≤ T[i]
- il existe un unique entier k dans [i..j-1] tel que T[k] < E ≤T [k+1]
- E>T[j]

On déduit de cette propriété deux algorithmes permettant de trier un tableau.

1.6.2.1 Tri insertion

ALGO Tri_ insertion ;

T= tableau [1..N] d'entiers ;

Var i, j, cle : entier;

22
Début

/* Recherche du minimum */

Pour i allant de 2 à N faire

cle = T[i] ;
j= i-1;
Tant que j >0 et T[j]> cle faire

/* échanger */

T [j+1]=T[j];
j = j-1;
Fintantque
T [j+1] = cle;
Finpour
Fin.
Cet algorithme permet de trier un tableau de N entiers.
1.6.2.2 Tri à bulle
ALGO Tri_ bulle ;
T= tableau [1..N] d'entiers ;
Var i, j, cle : entier ;

Début
/* Recherche du minimum */
Pour i allant de 1 à N-1 faire
Pour j allant de N à i+1 par pas de -1 faire
Si T[j] <T [j-1] alors
/* échanger */
Cle = T[j]
T[j] = T [j-1]
T [j-1] = Cle
Finsi
Finpour
Finpour
Fin.
Cet algorithme permet de trier un tableau de N entiers.
1.7 Structures ou enregistrement
Il s'agit simplement de regrouper des variables V1, V2, . . . de différents types T1,
T2, . . . dans une variable < à tiroirs >. La syntaxe de déclaration est la suivante :

23
 Nom_du_type = structure
nom_champs_1 : type1 ;
nom_champs_2 : type2 ;
.......
Nom_champs_k : typek ;

Finstructure ;

Ceci signifie que lorsqu'une variable est déclarée de ce type, elle référence k variables
en même temps. Soit V une variable dont le type est une structure, on désigne un des
champs par V. suivi du nom du champ. Voici quelques exemples de structures

Exemple1
Une date de naissance est un exemple de structure. On peut écrire :

DateDeNaissance = structure
JourDeNaissance : entier ;
MoisDeNaissance : entier ;
AnnéeDeNaissance : entier ;
Finstructure ;
On peut définir une structure composée du sexe et de la date de naissance

Individu = structure
Sexe : booléen ;
Date : DateDeNaissance ;
Finstructure ;
Alors I. Sexe sera un booléen et I.date.jourDeNaissance sera un entier. Ainsi les

Instructions suivantes ont un sens :

I.date.jour = 12 ;
I.sexe=false ;
 Affectation de valeurs à un enregistrement

ALGO enregistrer ;
Personne_t = structure
Taille : réel ;
Cheveux : caractère ;
Yeux : caractère ;
Finstructure ;

VAR
bob, luc : Personne_t ;
24
Début
/* enregistrement des valeurs dans Personne_t */

bob.taille = 180 ;
bob.cheveux = Brun ;
bob.yeux = Noir ;

/* Copie des valeurs de la variable bob à l’intérieur de la variable luc */

luc = bob ;

Fin.

Remarque

La seule opération globale sur un enregistrement est : recopier le contenu de

l’enregistrement E1 dans E2 en écrivant : E2 = E1;
Ceci est équivalent (et plus efficace) que de copier champ à champ ; en plus on ne
risque pas d'oublier un champ.
Il y a une condition : les 2 variables doivent être exactement du même type.

Intérêt de ce type

Il permet de structurer très proprement des informations qui vont ensemble, de les
recopier facilement et de les passer en paramètres à des procédures (on y reviendra).

1.8 Procédures et fonction

1.8.1 Procédures

Une procédure est un sous-programme. Ecrire des procédures permet de découper

un programme en plusieurs morceaux. Chaque procédure définit une nouvelle
instruction, que l'on peut appeler en tout endroit du programme. On peut ainsi réutiliser
le code d'un sous-programme. Une procédure est déclarée à l’aide du mot clé
Procédure

1.8.1.1 Procédure sans paramètres

Il s’agit simplement de donner un nom à un groupe d’instructions. Ensuite,

l’appel de ce nom à divers endroits du programme provoque à chaque fois
l’exécution de ce groupe d’instructions.

25
 Exemple
ALGO exemple1;
VAR x , y, t : entier ;

{Déclaration de la procédure Echange_xy}

PROCEDURE Echange_xy;
Début
{Corps de la procédure}
t := x; x := y; y := t;
Fin ;
Début
{Programme principal}
x := 3; y := 4;
Afficher (x, ’ ’, y);
Echange_xy; {1er appel de la procédure}
Afficher (x, ’ ’, y);
Echange_xy; {2eme appel de la procédure}
Afficher (x, ’ ’, y);
Fin.

Remarques

- Le nom de la procédure est un identificateur.

- On déclare toute procédure avant le DEBUT du programme principal.

1.8.1.2 Appels

On peut très bien appeler une procédure P1 depuis une procédure P2, mais il faut
que la procédure P1 ait été déclarée avant la procédure P2.

Exemple

ALGO exemple2 ;

VAR x, y, t : entier ;

PROCEDURE Affiche_xy ;
Début
Afficher (x, ' ', y) ;
Fin ;

26
PROCEDURE Echange_xy ;

Débit
t=x;x=y;y=t;
Affiche_xy ;
Fin ;

Débit
x = 3 ; y= 4 ;
Affiche_xy ;
Echange_xy ;
Echange_xy ;
Fin.

Remarque

On peut aussi appeler une procédure depuis elle-même : c'est la récursivité

1.8.1.3 Variables locales

Les objets du programme qui ne sont utiles que dans la procédure peuvent être
définis dans les déclarations locales de la procédure.
Exemple

ALGO exemple3;
VAR x, y : entier ;
PROCEDURE Echange_xy ;
VAR t : entier ; {Déclaration locale}
Débit
t := x; x := y; y := t;
Fin ;
Debit
{ ... }
Fin.

- Une variable déclarée localement n'existe que pendant l'exécution de la

procédure et ne sert qu’à cette procédure.
- Le programme principal n'a jamais accès à une variable locale de procédure.
- Une procédure n'a jamais accès à une variable locale d'une autre procédure.

1.8.1.4 Portée des variables

Les variables déclarées dans le VAR du programme principal sont appelées variables
globales. Elles existent pendant toute la durée du programme et sont accessible de

27
partout. Une variable locale à une procédure P, portant le même nom x qu'une variable
globale, masque la variable globale pendant l'exécution de P.
Exemple
ALGO exemple4;
VAR x : entier ;
PROCEDURE Toto;
VAR x : entier ;
Débit
x = 4;
Afficher ('toto x = ', x);
Fin ;
Débit
x = 2;
Afficher ('glob x = ', x);
Toto ;
Afficher ('glob x = ', x);
Fin.

Ce programme affiche
glob x = 2
toto x = 4
glob x = 2

1.8.1.5 Paramétrage d’une procédure

Dans le cadre d’une procédure paramétrée les paramètres sont fixés dans le nom de
la procédure.

ALGO exemple6 ;

VAR a, b, c, d : réel ;

PROCEDURE Produit (x, y : réel ; var z : réel) ; {paramètres}

Débit
z = x * y;
Fin ;

Débit
Afficher ('a b ? ') ; Lire (a, b) ;
Produit (a, b, c) ; {passage de}
Produit (a-1, b+1, d) ; {paramètres}
Afficher ('c = ', c, ' d = ', d) ;
Fin.

28
1.8.2 Fonction

Une fonction est une procédure particulière retournant ou non une valeur d’un type
donné par l'instruction simple (Afficher (Expression)). Une fonction s'utilise dans le
calcul d'une expression ou comme instruction simple. A la différence des procédures
les fonctions sont d’un type bien déterminé. Elle est déclarée à l’aide du mot clé
Fonction
 Ecriture de la fonction

Fonction NomDeFonction (ListeParamètres) : Typerésultat ;

//déclarations des variables locales autres que les paramètres début

Début
// Partie instruction qui contient l'appel à Afficher ()
Fin.
FinFonction ;

 liste des paramètres

Les paramètres sont passés

- par référence ref, on écrit ref ListeVariable : NomDeType

- par valeur val, on écrit val ListeVariable : NomDeType

Le type du résultat est vide si la fonction ne renvoie pas de résultat.

Exemple : La fonction factorielle est une fonction de type entier

Fonction Facto (n : Entier) : Entier ;

Début
Si n = 1 alors
Afficher (‘1 ‘)
Sinon
Afficher Facto (n - 1) * n
Finsi ;
Fin.

Fonction Facto (n : Entier)

29
Début
Si n = 1 alors
Renvoyer 1
Sinon
n - 1) * n
Fin Fonction Facto (n :
Si n = 1 alors
Renvoyer 1
Sinon

Renvoyer Facto (n - 1) * n
Fin

30
2.1 Langage de Programmation et programme informatique

2.1.1 Langage de Programmation

Un langage de programmation permet à un humain d'écrire un code pouvant être

analysé par une machine puis transformé en un programme informatique.

2.1.2 Programme informatique

Un programme informatique est une suite d'opérations prédéterminées pouvant

être exécutées par une machine.

2.1.3 Langages de programmation

Pascal, SQL, HTML (première), C, JAVA, CAML, Javascript, PHP (deuxième

année), C++, Assembleur (troisième année) sont probablement les principaux

langages de programmation à connaitre pour un informaticien et à apprendre lors
d'un cursus informatique, mais:
- Le langage C est relativement technique et plus difficile à aborder lorsque les
bases de l'algorithmique ne sont pas connues.
- C++ et JAVA sont des langages objet, faisant appel à un paradigme de
programmation plus avancé.

2.2 Langage Pascal

Le langage PASCAL est celui qui dispose de la syntaxe la plus claire et la plus proche
du langage dit "algorithmique", même s'il est bien moins puissant que le langage C. Il
a été mis au point par le Professeur Niklaus Wirth dans les années 1970 dans un
but pédagogique et est en constante évolution depuis. Tous les algorithmes que nous
mettrons au point cette année pourront être écrits directement en PASCAL.

2.2.1 Variables et constantes

Une variable est un identificateur associant un nom à une valeur ou un objet. Le nom
d'une variable ne doit comporter que des lettres non accentuées, des chiffres (sauf
en première position) et des tirets bas (tiret de huit). Il ne peut comporter d'espaces,
de signes de ponctuation, de signes arithmétiques ou de caractères spéciaux.

31
En PASCAL, on ne tient pas compte de la casse (majuscules / minuscules). Ce n'est
pas le cas dans la plupart des autres langages de programmation. Une constante est
une valeur définie au début du programme et qui reste inchangée durant toute son
exécution.

2.2.2 Instructions de base

2.2.2.1 Affectation

Une affectation est une opération (instruction) permettant d'attribuer une valeur à
une variable. En PASCAL, elle est symbolisée par le signe :=
L'identifiant de la variable est à gauche du signe d'affectation. La valeur ou plus
généralement l'expression est à droite du signe d'affectation.
Exemple

x := 5
y2 := y + 2 * z
i := i + 1
x prend la valeur 5 (au symbole x est désormais associée la valeur 5, jusqu'à ce
que cette variable soit modifiée)
y + 2z donne y2 (l'expression y + 2*z est évaluée et sa valeur est "rangée" dans la
variable de nom y2)
i prend pour valeur i+1 (i est actualisée : on ajoute 1 à la précédente valeur
contenue dans la variable i)

2.2.2.2 Instruction basique de lecture

L'instruction basique de lecture interrompt le programme, attend que l'utilisateur entre

une valeur au clavier et stocke la valeur en mémoire dans la variable désignée en
paramètres.

En PASCAL : mot-clé readln suivi de la ou les variables entre parenthèses.

Exemple

readln (x)
readln (nom, prenom, age)

32
2.2.2.3 Instruction basique de d'écriture

L'instruction basique d'écriture affiche le contenu de l'expression en paramètre. Une

expression peut être une valeur, le contenu d'une variable, le résultat d'un calcul, ou
la concaténation de plusieurs expressions.

En PASCAL : mot-clé write suivi de l'expression entre parenthèses, ou des

expressions séparées par des virgules. Une chaine de caractère doit être délimitée
par des apostrophes. Remplacer write par writeln permet de passer à la ligne après
l'affichage.

Exemple

writeln (19)
write ('Bonjour le monde!')
write (age)
writeln ('Je sais que 9*9 = ',9*9)
writeln ()

2.2.3 Structure des instructions de base

En PASCAL, les instructions sont séparées par un délimiteur : le point-virgule
Exemple

writeln ('Programme évolué de voyance par ordinateur') ;

write ('Déclinez l''identité de la personne (nom, prénom) : ') ;
readln (nom,prenom);
write ('Quel est son âge : ') ;
readln (age) ;
write ('En quelle année sommes-nous ? ') ;
readln (annee) ;
writeln (' en 2020, ', prenom,' ', nom,' aura ',2020 – annee + age,' ans') ;
2.2.4 Types de base en programmation
Un type définit les valeurs que peut prendre une donnée (en particulier une variable)
et les opérateurs qui peuvent lui être appliqués.

33
2.2.4.1 Type entier : Integer

Entiers : sous-ensemble de Z ; en PASCAL : integer

2.2.4.2 Type réel : real

Réels : sous-ensemble de D ; en PASCAL : real

2.2.4.3 Type booléen : boolean

- Booléens : deux valeurs possibles, vrai et faux ; en PASCAL : boolean (true /false)
- Caractères : lettres, chiffres, ponctuation… ; en PASCAL : char
En PASCAL, une valeur de type caractère doit être mentionnée entre apostrophes.
2.2.4.4 Opérateurs de calcul sur les types de base
2.2.4.4.1 Opérateurs de calcul sur les types de base
Les opérateurs de calcul disponibles pour les types de base :

- Entiers : + ; – ; * ; div ; mod

- Réels : +; –; *; /
- Booléens : and ; or ; not
2.2.4.4.2 Opérateurs de comparaison

- Entiers, réels, caractères : = ; <= ; < ; >= ; > ; <>

- Booléens : = ; <>
2.2.5 Structure d’un programme pascal
Un programme PASCAL débute par le mot-clé program suivi du nom du programme.
Ce nom ne doit plus être réutilisé dans la suite du programme.
Toutes les constantes utilisées dans le programme, et les variables utilisées dans le
programme principal doivent être déclarées auparavant. La déclaration des
constantes est initiée par le mot-clé const. La déclaration des variables est initiée par
le mot-clé var. Le type de chaque variable doit être précisé lors de la déclaration. Les
constantes ne sont pas typées. Le corps du programme principal débute par le mot-
clé begin et termine par end suivi d'un point.

34
EXEMPLE
program Calcul_TVA ;
var prixTTC, tauxTVA : real ;
begin
write ('Quel est le prix TTC ? ') ;
readln (prixTTC) ;
write ('Quel taux de TVA s'applique en % ? ') ;
readln (tauxTVA) ;
tauxTVA := tauxTVA / 100 ;
writeln ('Le prix HT est de ', (prixTTC * (1 – tauxTVA)):5:2) ;
writeln ('Le montant de la TVA est de ', (prixTTC * tauxTVA):5:2)
end.

Remarque

Dans les deux dernières instructions d’affichage la mention : 5:2 s’explique ainsi :
5 : Nombre minimal de caractères affichés (avec alignement à droite)
2 : Précision de l'arrondi (chiffres après la virgule)

2.2.6 Instructions conditionnelles

Les instructions d’affectation, de lecture et d’écriture sont des instructions

séquentielles. Une instruction conditionnelle permet d’exécuter ou non un bloc
d’instructions selon le résultat d’un test (choix binaire). Nous avons les instructions
conditionnelles complètes, les instructions conditionnelles incomplètes et les
instructions conditionnelles imbriquées.

2.2.6.1 Instructions conditionnelles complètes

if <condition> then <instruction1> Conditionnelle complète (if… then…else)

else <instruction2>
Si la condition est vérifiée, alors on exécute l’instruction 1, sinon on exécute
l’instruction 2
Un bloc d’instructions (suite d’instructions séparées par des points-virgules et
encadrées par begin et end) peut remplacer une simple instruction.

35
if <condition> then
begin
<instruction1> ; Bloc d’instructions
<instruction2>
end
else <instruction3>

2.2.6.2 Instructions conditionnelles incomplètes

if <condition> then <instruction1> Conditionnelle incomplète (if… then)

Si la condition est vérifiée, alors on exécute l’instruction 1 [sinon on ne fait rien]
2.2.6.3 Instructions conditionnelles imbriquées

Comme une conditionnelle est elle-même une instruction, il peut y avoir une ou
plusieurs conditionnelles à l’intérieur d’une conditionnelle. On parle de conditionnelles
imbriquées.

if <condition1> then

if <condition2> then <instruction1>

else <instruction2>

else <instruction3>

Remarque

En PASCAL, le point-virgule est un séparateur d’instructions. Il ne faut donc jamais

mettre un point-virgule juste devant le mot-clé else.

2.2.6.4 Instructions conditionnelles case…of

Il faut éviter d’imbriquer un trop grand nombre de instructions conditionnelles

(problèmes de lisibilité à partir de 3 / 4 niveaux. L’instruction case…of permet d’éviter
certaines imbrications de conditionnelles et permet de traiter directement des choix qui
ne sont plus binaires. Elle est réservée à des conditions bien précises (égalité variable
- constantes).

36
case <variable> of
<ensembleDeValeurs1> : <instruction1> ;
<ensembleDeValeurs2> : <instruction2> ;
…
<ensembleDeValeursN> : <instructionN>
else <instructionN+1>
end.

Remarque
- un ensemble de valeurs est une valeur constante, ou plusieurs valeurs
constantes séparées par des virgules
- le else est facultatif
- chaque instruction peut être un bloc d’instructions

2.2.7 Instructions répétitives ou boucles

Une boucle permet d’effectuer un traitement à plusieurs reprises.

Il existe plusieurs types de boucles :
- la boucle TANT QUE
- la boucle REPETER (ou boucle JUSQU’À CE QUE)
- la boucle POUR (extension de la boucle TANT QUE)

2.2.7.1 Boucle TANT QUE

TANT QUE la condition est vraie :

- on effectue l’instruction (ou le bloc d’instructions)
- on revient au début de la boucle
Lorsque la condition est fausse, on passe à l’instruction suivante.

while <condition> do <instruction>

37
Pour un boc d’instructions on a :

while <condition> do
begin
<instruction1> ;
<instruction2>
End
EXEMPLE
program tours_de_boucle ;
Var n : integer ;
begin
n := 0 ;
while n < 3 do
begin
writeln ('Un tour... ') ;
n := n + 1
end ;
writeln ('Fini !')
end.
Exercices :
1 – Quel est l’affichage produit par le programme tours_de_boucle ?
2 – Écrire l’algorithme d’Euclide en PASCAL (pgcd de deux nombres entiers)

2.2.7.2 Boucle TANT QUE

while <condition> do <traitement>

• La condition doit finir par devenir fausse (on répète le traitement tant que la
condition est vraie)

• Si la condition est fausse à la première exécution, le traitement n’est jamais réalisé.

2.2.7.3 Boucle RÉPÉTER

repeat <traitement> until <condition>

38
• En PASCAL, la boucle RÉPÉTER est de type RÉPÉTER…JUSQU’À

• La condition doit finir par devenir vraie (on répète le traitement jusqu’à ce que la
condition soit vraie, i.e. tant que la condition est fausse)
• Le traitement est réalisé au moins une fois, car le test est effectué après.
EXEMPLE
repeat
writeln(’saisir la note’);
readln(note)
until (note >= 0) and (note <= 20)
Remarque : pas de begin/end car le bloc d’instructions à répéter est déjà encadré
par repeat et until.

2.2.7.4 Boucle POUR (for)

La boucle POUR permet d’effectuer un traitement à plusieurs reprises en
incrémentant ou décrémentant automatiquement une variable entière.

for <nomVarBoucle> := <exprInf> to <exprSup> do

<traitement> Boucle POUR croissante

for <nomVarBoucle> := <exprSup> downto <exprInf> do

<traitement> Boucle POUR décroissante
• <nomVarBoucle> est une variable de type entier (integer) qui ne doit
théoriquement jamais être modifiée dans le traitement.
• <exprInf> et <exprSup> sont des expressions entières (variables,
constantes, résultats d‘un calcul).
• <traitement> est une instruction ou une suite d’instructions séparées
par begin / end.

39
EXEMPLE
sommeChiffres := 0;

for i := 1 to 9 do

sommeChiffres := sommeChiffres + i;
sommeChiffres := 0;
for i := 9 downto 1 do
sommeChiffres := sommeChiffres + i;
2.2.8 Variables de type tableaux
Un tableau est une structure de données regroupant un ensemble de variables de
même type.
2.2.8.1 Tableau à une dimension
Exemple de tableau d’entiers de dimension 8, indicé de 1 à 8

5 0 2 19 -5 2 1 8
T[1] T[2] T[3] T[4] T[5] T[6] T[7] T[8]
La variable T est de type tableau d’entiers indicé de 1 à 8.
On accède aux valeurs du tableau par T[1], T[2], …, T[8].
L’indice doit être une expression entière (constante, variable, calcul).

2.2.8.1.1 Déclaration d’une variable de type tableau à une dimension

Syntaxe : var <NomVar> : array [<const1>..<const2>] of <type> ;

Cette syntaxe est fonctionnelle mais déconseillée dans le cas général. Lors de
l’utilisation de types structurés comme des tableaux, il est préférable de commencer
par définir le type lui-même (par exemple : type tableau d’entiers indicé de 1 à 8). On
pourra alors utiliser plusieurs variables correspondant à ce même type.

2.2.8.1.2 Utilisation d’une variable type tableau à une dimension

Chaque T[i] se comporte comme une variable classique.

T [i+1]:=5
readln (T [3])
writeln (’La ’, Xème valeur est ’, T[x])
if T[T [1] +T [2]] = T [1] + T [2] then writeln (’coup de chance’)

40
Les instructions de lecture, écriture peuvent s’appliquer à chacun des éléments mais
pas au tableau tout entier.

readln(T) writeln(T)
Il faut saisir ou afficher les éléments un par un, en utilisant une boucle.
EXEMPLE
program reaffichage;
const Nmax =100 ; {limite de taille du tableau}
type Tent = array [1..Nmax] of integer ; {déclaration du type Tent}
var T : Tent ; {le tableau}
n : integer; {nombre d’éléments à saisir}
i : integer; {indice pour parcourir le tableau}
begin
write (’Combien de valeurs (<’, Nmax,’) ? ’);
readln(n);
i :=1;
while i<=n do
begin
write (’Donner le ’, i,’eme element: ’);
readln(T[i]) ;
i:=i+1
end
writeln (’Vous venez de saisir les valeurs suivantes : ’);
i:=1;
while i<=n do
begin
write (T[i],’ ’);
i:=i+1
end
end

41
2.2.8.2 Type tableaux à deux dimensions
2.2.8.2.1 Déclaration d’un tableau à deux dimensions
Syntaxe : var <NomVar> : array [<const1>..<const2>, [<const3>..<const4>] of <type> ;

EXEMPLE
program saisie_matrice;
const Lmax=100; Cmax=100;
type matrice = array[1..Lmax, 1..Cmax] of real;
var M : matrice ;
n1, n2 : integer;
i, j : integer;
begin
write (’Combien de lignes (<’, Lmax,’) ? ’);
readln (n1);
write (’Combien de colonnes (<’, Cmax,’) ? ’);
readln (n2);
i:=1;
while i<=n1 do
begin
j:=1;
while j<=n2 do
begin
write (’Donner l’’element [’, i,’,’, j,’] : ’) ;
readln (M [i, j]);
j:=j+1
end;
i:=i+1
end.
EXERCICE
Ecrit un programme pascal permettant d’initialiser une matrice de dimension 7x8
A l’aide de la boucle For…do et repeat. Until

42
2.2.9 Déclaration d’un type structuré

Syntaxe : type <NomType> = <typeStructuré>;

type TabEntier = array [1..8] of integer;
var T1, T2 : TabEntier ;
2.2.10 Type enregistrements
Il s'agit simplement de regrouper des variables V1, V2, . . . de différents types T1,
T2, . . . dans une variable < à tiroirs >.

Syntaxe

Record
V1 : T1;
V2 : T2;
{ ... }
End ;
Soit r une variable de ce type ; on accède aux différents champs de r par r.V1,
r.V2, . . .

EXEMPLE
personne_t = Record
taille : taille_t;
cheveux : cheveux_t ;
yeux : yeux_t ;
End ;
VAR
taille : taille_t;
cheveux : cheveux_t;
yeux : yeux_t;
bob, luc : personne_t;
BEGIN
bob.taille := 180;
bob.cheveux := Brun;
bob.yeux := Noir;
luc := bob;
END.

Remarque

La seule opération globale sur un enregistrement est : recopier le contenu de r2 dans

r1 en écrivant : r2 := r1;

43
2.2.11 Type Chaines de caractères

Une chaine de caractère (en anglais : string) est un type structuré similaire à un
tableau de caractères, et représentant une suite de caractères. Il est prédéfini dans la
plupart des langages de programmation et associé à des fonctions spécifiques qui
permettent de les manipuler plus simplement.
Déclaration :
var <NomVar> : string
La taille n’est pas précisée
(valeur par défaut : 255 caractères)

var <NomVar> : string[<const2>]

La taille maximale de la chaine est précisée

Le nombre de caractères d’une chaine est accessible via la fonction length
(<NomVar>). Elle représente sa taille utile. D’autres fonctions permettant de
manipuler les chaines seront vues plus tard.
Contrairement aux tableaux, les chaines de caractères peuvent être lues et affichées.

EXEMPLE
program exemple_chaines;
var s, nom : string;
tel : string [10];
begin
write (’Comment vous appelez-vous ?’);
readln (nom);
s := ’Bonjour’;
writeln (s,’ ’, nom);

writeln (’L’’initiale de votre nom est ’, nom [1]);

writeln (’Votre nom est composé de ’, length (nom),’ lettres’)

writeln (’Entrez votre numéro de téléphone’);

readln (tel);

{…}
end.
2.2.11.1 Opérations de base sur les caractères
Concaténation : ‘Bon’ + ‘jour’ -> ‘Bonjour’

Comparaison : ‘Un’ < ‘Deux’ -> false

44
 Tous les opérateurs de comparaison habituels sont disponibles : < ; > ; <= ; >=
; = ; <>
2.3 Sous-programmes

Un langage possède un nombre d’instructions limitées. La plupart des problèmes sont

compliqués à résoudre et nécessitent d’être décomposés en Sous-problèmes. Un
sous-programme est un bloc d’instructions séparé du bloc principal permettant de
résoudre un sous-problème. On peut appeler un sous-programme dans le programme
principal ou dans un autre sous-programme.

2.3.1 Déclaration d’un sous-programme

En PASCAL, la déclaration d’un sous-programme comprend :

• sa catégorie (fonction ou procédure)
• son nom
• ses paramètres formels
Elle est suivie par la déclaration de ses variables locales et un bloc d’instructions.
Les variables locales déclarées dans un sous-programme ne sont pas visibles hors du
sous-programme.

2.3.2 Appel / exécution d’un sous-programme

Un sous-programme est exécuté par le programme principal ou un autre sous-

programme par appel de son nom et de ses paramètres effectifs.

2.3.3 Nature des paramètres d’un sous-programme

Une donnée est une valeur transmise au sous-programme et utilisée par celui-ci. Une
donnée n’est jamais modifiée par le sous-programme.
Un résultat est une valeur que le sous-programme transmet au programme ou sous-
programme qui l’appelle.
Une donnée modifiée est à la fois donnée et résultat. Il s’agit d’une donnée que le
sous-programme peut modifier dans le but d’être retransmise au programme qui
l’appelle. Les paramètres résultats et données modifiées sont des variables, non
initialisées (résultats) ou initialisées (données modifiées).

45
2.3.4 Catégories de sous-programme

Une fonction : sous-programme typé qui retourne un résultat à partir d’un certain
nombre de données (pas de données modifiées ni de paramètre résultat qui peut être
considéré comme la fonction elle-même).
Une procédure : sous-programme non typé qui utilise un nombre libre de données,
résultats et données modifiées, mais ne retourne pas à proprement parler un résultat.
2.4 Fonction
Une fonction calcule une valeur à partir de 0, 1 ou plusieurs données en paramètre.
2.4.1 Déclaration d’une fonction :

function nomFonction (donnee1 : type1 ; donnee2 : type2 ; … ;donneeN : typeN) : typeResultat;

var …; {déclaration des variables locales}

begin

… {bloc d’instructions}

end ;

Les paramètres sont uniquement des données, et le résultat n’est pas considéré
comme un paramètre.
Pour retourner un résultat, la fonction doit contenir au moins une instruction de type
NomFonction :=…;

En PASCAL, dans le bloc d’instruction de la fonction, le nom de la fonction s’utilise

comme une variable du type de la fonction.

2.4.2 Appel d’une fonction (dans un autre bloc d’instructions)

… nomFonction (val1, val2,…, valN)…;

Une fonction appelée doit être préalablement déclarée

• une fonction doit être appelée à l’intérieur d’une instruction (elle ne constitue pas une
instruction en tant que telle). Par exemple : x := mafonction (a, b, c) avec x du même
type que mafonction (p1, p2, p3) et le ième paramètre effectif même type que le ième
paramètre formel de la fonction.
Lors de l’appel, la fonction s’exécute avec comme paramètres (données) les valeurs
des paramètres effectifs.

46
Après exécution de la fonction, sa valeur calculée (résultat) remplace l’appel de la
fonction dans l’instruction où elle a été effectuée. L’appel d’une fonction correspond à
une expression dont on évalue la valeur.
EXEMPLE
program testmin ;

function min(x : integer ; y : integer) : integer ;

begin
if x<y then min:=x
else min:=y;
end ;

var a, b: integer;
begin
write(‘Entrer deux valeurs: ’) ;
readln(a);
readln(b);
writeln (‘Le min est : ’, min (a, b));
end.

REMARQUE
Sous-programmes : fonctions

• L’ordre des paramètres doit être bien respecté lors de l’appel de la fonction

• On ne modifie jamais les paramètres dans une fonction

• Il n’y a pas de lecture des données dans la fonction ; elles sont passées en

Paramètres

• Il n’y a pas à afficher le résultat dans la fonction

Attention à la distinction entre paramètres formels et paramètres effectifs

Paramètres formels lors de la déclaration :

f : N -> N
f(x) = x²
Paramètres effectifs lors de l’exécution :
f(3)
f(a) avec a=5
f(x) avec x=1

47
2.5 Procédure
Une procédure peut être considérée comme une fonction ne renvoyant pas de valeur.
En PASCAL, des paramètres peuvent être modifiés uniquement dans des procédures
(données modifiées et résultats). Une procédure peut également avoir des données
en paramètres, non modifiables.
L'appel à une procédure est une instruction en tant que telle.

2.5.1 Déclaration d’une procédure

procedure nomProc (param1 : type1; var param2 : type2 ; …) ;

var …; {déclaration des variables locales}

begin

… {bloc d’instructions}

End ;

Les paramètres peuvent être des données, des données modifiées ou des résultats.
Les données modifiées et résultats sont précédés par le mot-clé var.
Une procédure n'a pas de type associé. Il ne doit jamais y avoir d'instruction du
genre nomProc:=…;
2.5.2 Appel d’une procédure (dans un autre bloc d’instructions)

nomProc (val1, val2,…) ;

• une procédure appelée doit être préalablement déclarée

• les données en paramètres doivent être des expressions (valeur, variable, résultat
d'un calcul ou d'une fonction) correspondant aux types déclarés

• les données modifiées et résultats (var lors de la déclaration, mais pas lors de
l'appel) correspond obligatoirement à une variable correspondant au type déclaré

• l'ordre des paramètres doit être bien respecté lors de l'appel de la procédure

48
program testajoute ;

procedure ajoute (var x: integer; y: integer);

begin

x := x+y ;

end ;

var a, b : integer

begin
readln(a);
readln(b);
ajoute(a, b);
writeln(a, b);
end.
2.6 Sous-programmes : synthèse
La distinction entre une procédure et une fonction

• des données doivent être modifiées : PROCÉDURE

• des données vont être saisies ou modifiées : PROCÉDURE

• un ensemble de résultats va être produit : PROCÉDURE

• calculer un résultat à partir d'un ensemble de données : FONCTION

• pouvoir utiliser le sous-programme dans une expression : FONCTION

EXERCICE
On souhaite réaliser un programme calculant, à partir des relevés de températures sur
une semaine de deux villes, laquelle a la température moyenne la plus élevée.
-> Définir un type permettant de stocker les températures hebdomadaires d'une ville
-> Écrire un sous-programme calculant la moyenne des températures de la semaine
-> Écrire un sous-programme permettant la saisie des températures hebdomadaires
d'une ville
-> Écrire un sous-programme déterminant, parmi deux villes, celle qui a la température
moyenne la plus élevée
->Écrire le programme principal permettant de réaliser les traitements

49
50
3.1 Déclaration d’objets en C
3.1.1 Variables
Syntaxe :
type nom_variable ;
ou
type nom_variable=valeur ;
3.1.2 Constante
Syntaxe :
const type nom_constante= ;
3.1.3 Tableau
3.1.3.1 Tableau une dimension
Syntaxe :
type nom_tableau [taille_Tableau]= {val1, val2, val3,.., valn} ;
3.1.3.2 Matrice
type nom_tableau [nb_lignes][nb_colonnes]= { {val11val12,val13..val1n},
{val21val22val23..val2n},
{val31val32val33..val3n},
.
.
.
{valn1valn2valn3..valnn}
};
3.2 Pointeurs

Int*nom_pointeur=valeur_pointeur ; // Déclaration de pointeur sur entier

Nom_pointeur=&iTableau [0] ; // On point sur la première valeur du tableau
Nom_pointeur=&iTableau [nb_lignes] ; // On point sur la dernière valeur du tableau
*Nom_pointeur // Contenu de la variable pointeur ;

3.2 Instruction d’entrée sortie

3.3.1 Affichage à l’écran
printf ("texte à afficher\n")

51
3.3.1.1 Types d’affichage

%d affichage d’un entier décimal signé

%o affichage en octal
%x affichage en hexadécimal
%u affichage en non signé
%i affichage d’un entier signé
%c affichage d’un seul caractère
%s affichage d’un string
%e affichage en floating point avec exposant
%f affichage en floating point sans exposant
%g affichage comme f ou e suivant la valeur

3.3.2 Saisie au clavier

scanf ("%lettre alphabétique correspondant au type d’affichage», nom_variable)
3.4 Affectation
= Affectation MaData = 12 ;

3.5 Opérateurs

3.5.1 Opérateurs les plus usuels.

+ L’addition
- La soustraction
* La multiplication
/ La division
% Le modulo, reste de la division entière
& Opération logique AND
¦ Opération logique OR
^ Ou exclusif

3.5.2 Opérateurs de comparaison (relationnels)

== identique MaData == TempData ;

!= différent MaData != TempData ;
> Plus grand que MaData > TempData ;
>= Plus grand ou égal que MaData >= TempData ;
< Plus petit que MaData < TempData ;
<= Plus petit ou égal que MaData <= TempData ;

3.6 Structures de contrôle

3.6.1 Structures conditionnelles

52
3.6.1.1 Structure conditionnelle complète
if (condition1)
{
<action1> ;
}
else
{
<action2>;
}
3.6.1.2 Structure conditionnelle incomplète
if (condition1)
<action>;
3.6.1.3 Structure conditionnelle imbriquée
if (condition1)
{
<action1> ;
}
else
{
if (condition2)
{
<action2>;
}
else
{
<action3>;
}
}

53
3.6.1.4 Structure Case
switch(Variable)
{case <Valeur1>:<Action1> ; break;
case <Valeur2>:<Action2> ; break;
case <Valeur3>:<Action3> ; break;
.
.
.
case <ValeurN>:<ActionN> ; break;
default :<ActionN> ; break;
}
3.6.2 Boucles
3.6.2.1 While
while(Condition)
{
<actions> ;
}
3.6.2.2 do...while
do
{
<actions> ;
}
while (condition);
3.6.2.3 For..do
3.6.2.3.1 For..do (avec incrémentation)
for (Compteur=valeur1; Compteur=valeur2 ; Compteur++)
{
<actions>;
}

54
3.6.2.3.2 For..do (avec décrémentation)
for (Compteur=valeur1; Compteur=valeur2 ; Compteur--)
{
<actions>;
}
3.7 Caractères et chaînes de caractères
3.7.1 Déclaration d’un caractère
Syntaxe :
char nom_variable=’caractère’
3.7.1.1 Lecture d’un caractère au clavier
Nom_variable_char=getchar () ;
3.7.1.2 Affichage d’un caractère à l’écran
printf (″%c″, nom_variable) ;
3.7.2 Déclaration chaînes de caractères
Syntaxe :
char <nom_tableau> [<taille_tableau] ;
Exemple : char nom_variable_char [8] ; char nom_variable_char [5]=’Eric’ ;
char nom_variable_char[ ]=’Eric’ ;
NB : il faut noter qu’un déclarant une chaine de caractère en fixant la taille du tableau
de déclaration à (n),ce sont (n-1) qui seront effectivement affichés et un zéro final sera
affiché à la fin de la chaîne, il faut donc faire attention en fixant la taille de déclaration
d’une chaine de caractères.
3.7.2.1 Pointeur sur une chaine de caractères
char*nom_tableau[ ] ; // Tableau de chaines de caractères
3.7.2.2 Fonctions de gestion de caractères
3.7.2.2.1 Fonction gets ()

La fonction gets permet de lire une chaîne de caractères validée par la touche
ENTREE du clavier de l‘ordinateur.

55
EXEMPLE
Char line [81] ; /* 81 : taille arbitraire supposée suffisante
Une ligne écran = 80 caractères + 1 case
Pour le ‘\0’ de fin de chaîne */
printf («Saisissez une chaîne de caractère : \n ») ;
gets (line) ; /* La frappe de l’utilisateur sera enregistrée
dans line, on suppose qu’il ne frappera pas
plus de 80 caractères, sinon aïe aïe aïe */

3.7.2.2.2 Fonction strcat ()

La fonction strcat (<s>, <t>) ajoute la chaîne de caractères <t> à la fin de <s>
(on appelle cela une concaténation).

EXEMPLE
#include <stdio.h>
#include <string.h>
Int main () {
Le programme suivant affichera la chaîne « Bonjour Paul » à l’écran :
char chaine1 [20]= ″Bonjour ″ ;
Char chaine2 [20]= ″Paul ″ ;
strcat (chaine1, chaine2) ; /* ajoute chaine2 à la fin de chaine1 */
printf (« %s\n », chaine1) ;
return 0 ;
}

3.7.2.2.3 Fonction strncpy ()

La fonction strncpy (<s>, <t>, <n>) est presque similaire à strcpy mais copie au plus
<n> caractères de la chaîne <t> au début de <s>.

EXEMPLE
#include <stdio.h>
#include <string.h>
int main () {
char chaine1 [20]= ″Bonjour ″ ;
char chaine2 [20]= ″Edouard ″ ;
strncpy (chaine1, chaine2, 2) ; /* recopie 2 caractères de chaine2
à l’adresse de chaine1 */
printf (« %s\n », chaine1) ;
return 0 ;
}

3.7.2.2.4 Fonction strncat ()

La fonction strncat (<s>, <t>, <n>) ajoute au plus <n> caractères de la chaîne <t> à
la fin de <s>.

56
EXEMPLE
#include <stdio.h>
#include <string.h>
int main () {
char chaine1[20]= ″Bonjour ″ ;
char chaine2[20]= ″Edouard ″ ;
strncat(chaine1,chaine2,2) ; /* ajoute les 2 premiers caractères
de chaîne2 à la fin de chaine1 */
printf(« %s\n »,chaine1) ;
return 0 ;
}

3.7.2.2.5 Fonction strcmp ()

La fonction strcmp (<s>, <t>) compare les chaînes de caractères <s> et <t> de
manière lexicographique et fournit un résultat :

– nul (0) si <s> est égale à <t>

– négatif si <s> précède <t>. Par exemple, strcmp (« AAAA », »BBBB ») renverrait -1

– positif si <s> suit <t>. Par exemple, strcmp (« BBBB », »AAAA ») renverrait +1

3.7.2.2.6 Fonction strlen ()

La longueur d’une chaîne de caractères s’obtient par la fonction strlen (disponible au
travers de la bibliothèque string). Le 0 de fin de chaîne n’est pas compté dans cette
longueur.
EXEMPLE

#include <stdio.h>
#include <string.h>
int main () {
char ch [] = ″toto ″ ;
printf (« La longueur de %s est : %d », ch, strlen (ch)) ;
return 0 ;
}
Affichera : « La longueur de toto est : 4 » à l’écran.
3.7.2.2.6 Fonction strcpy ()
Pour initialiser une chaîne de caractères, il est possible d’utiliser la fonction strcpy.
Cette fonction nous impose une nouvelle fois d’ajouter le fichier d’en-tête string.h.

57
 EXEMPLE

#include <stdio.h>
#include <string.h>
int main (void) {
char line [80];
strcpy (line, «un exemple de chaine initialisée...") ;
printf ("%s\n", line);
return 0;
}
3.7.2.2.7 Fonction puts ()

La fonction puts permet d’afficher un tableau de chaînes de caractères.

EXEMPLE

void ecriture (char*cTableau [], int iNbMax)

{/*Déclaration du compteur*/
int iCompteur;
/*Affichage des éléments du tableau*/
for (iCompteur=0;iCompteur<iNbMax;iCompteur++)
{
puts (cTableau[iCompteur]);
}
};

3.7.2.3 Affichage d’une chaîne de caractères

Une chaîne de caractères s’affiche grâce à la commande printf et le format %s.

EXEMPLE

printf ("%s", chaine); // Affichera le contenu de chaine.

3.8 Les structures

Une structure est un objet composé de plusieurs champs qui sert à représenter un
objet réel ou un concept. Par exemple une voiture peut être représentée par les
renseignements suivants : la marque, la couleur, l’année, etc.
3.8.1 Définition d’une structure
Une structure peut être définie de plusieurs manières :
Syntaxe 1 :
struct nom_de_la_structure {

/* Définition de la structure */
} nom_du_type ;

58
Ceci fait, le nouveau type de données sera struct nom_du_type et une variable
pourra être déclarée ainsi :

struct nom_du_type nom_variable;

La répétition du mot-clé struct est rapidement ennuyeuse. la syntaxe suivante sera

donc souvent utilisée.

Syntaxe 2 :

typedef struct {
/* Définition de la structure */
} nom_du_type;

Cette fois-ci, le nouveau type de données s’appelle nom_du_type (la structure a été
créée et en même temps un synonyme a été défini avec typedef).

Une variable pourra être déclarée ainsi : nom_du_type nom_variable;

EXEMPLE

#define LONGUEUR 40
struct personne{
char nom [LONGUEUR];
char prenom [LONGUEUR];
int age;
};
struct personne p;

#define LONGUEUR 40
typedef struct {
char nom [LONGUEUR];
char prenom [LONGUEUR];
int age;
} personne;
personne p;

La seconde solution est plus simple et plus élégante à l’usage.

2.8.2 Accéder aux éléments d’une structure

L’accès aux éléments d’une structure, appelés aussi champ, se fait selon la syntaxe
: nom_de_variable.nom_du_champ

59
#include <stdio.h>
typedef struct {
char nom [40];
char prenom [20];
int age;
} personne;
int main () {
personne p ;
printf("Veuillez entrer le nom de la personne:");
scanf ("%s",p.nom);
printf ("Veuillez entrer le prénom de la personne:");
scanf ("%s", p.prenom);
printf ("Veuillez entrer l'âge de la personne:");
scanf ("%d", &p.age); /* ne pas oublier le & !!! */
printf ("Voici les caractéristiques de cette personne:\n");
printf ("nom=%s\n", p.nom);
printf ("prenom=%s\n", p.prenom);
printf ("age=%d\n", p.age);
return 0;
}

2.9 Fichiers

Tout ce qui est enregistré sur votre disque dur ou presque est un fichier, et porte un
nom. Il est possible de créer, de lire ou d’écrire dans des fichiers. Notez que certains
fichiers peuvent être protégés en lecture, en écriture ou les deux. Les fichiers seront
donc étudiés à travers l’analyse d’un programme
2.9.1 Analyse du programme
-Déclaration d’un pointeur de fichier
-FILE *Mon_pointeur_fichier ; // déclaration d’un pointeur sur un
// Enregistrement d'un fichier
-Ouverture d'un fichier, fonction fopen ( )

Le pointeur précédemment déclaré est associé à un fichier sur disque.

Mon_pointeur_fichier = fopen (nom_fichier_sur_disque, const char * mode);

NB :
const char * mode correspond au mode d’ouverture d’un fichier. Pour ouvrir le ficher
en écriture par exemple const char * mode prend la valeur w. ce qui donne la
déclaration ci-dessous :
-Mon_pointeur_fichier = fopen (nom_fichier_sur_disque, "w");

60
2.9.2 Mode d'ouverture d'un fichier

"r" read Ouvre un fichier texte en lecture seule.

(le fichier doit exister)
"w" write Crée ou efface le fichier texte pour l'écriture

"a" append Ouvre ou crée le fichier, pointe la fin de

fichier pour ajouter à la fin. (pas d'effacement)

"r+" read+ Ouverture de fichiers texte pour mise à jour

(lecture/écriture)

"w+" write+ Crée ou efface un fichier texte pour mise à jour

(Lecture/écriture)

"a+" append+ Ouvre ou crée un fichier texte et pointe la fin

pour la mise à jour (lecture/écriture)

2.9.3 Fermeture d'un fichier (fclose)

int fclose (Mon_pointeur_fichier) // function prototype
Matérialisation de la fin d’un fichier

feof (Mon_pointeur_fichier) // matérialise la fin d’un fichier

EXEMPLE
while (! feof (Mon_pointeur_fichier))
{
fscanf (Mon_pointeur_fichier, "%s ", nom_personne);
printf ("Nom : %s\n", nom_personne);
38. }

feof désigne l’abréviation de end of file. Donc cette ligne se traduit par : tant que l’on
n’atteint pas la fin du fichier désigné par Mon_pointeur_fichier

2.9.4 Entrée sortie d'un caractère

Les fonctions d'entrée/sortie permettent la conversion des caractères pendant

l'écriture ou la lecture du fichier.

2.9.5 Ecrire un caractère dans un fichier

fputc (int c, Mon_pointeur_fichier) // function prototype

2.9.6 Lire un caractère dans un fichier

fgetc (FILE * Mon_pointeur_fichier) // function prototype

61
2.9.7 Ecrire une chaîne de caractères (string) dans un fichier

fputs ("Hello", Mon_pointeur_fichier)

fprintf (Mon_pointeur_fichier, "%s\n", nom_chaîne_caractères);

La fonction fprintf n’est pas très différent d’un printf. La seule différence est qu’au lieu
d’être écrite sur l’écran, la chaîne nom_chaîne_caractères sera écrite dans le fichier
nom_fichier_sur_disque.

2.9.8 Lire une chaîne de caractères d'un fichier

char *fgets (char *ligne, int maxligne, FILE* Mon_pointeur_fichier)

La fonction fgets lit à partir du fichier au maximum maxligne -1 caractères et les

stocke dans la chaîne de caractères ligne. La lecture s’arrête sur \n qui est alors
inclus dans la chaîne. La chaîne est complétée par \0. La fonction renvoie NULL si la
fin de fichier est atteinte.
fscanf (Mon_pointeur_fichier, "%s ", nom_personne);

EXEMPLE
#include <stdio.h>
/* Définition de constante */
#define maxligne 100
char ligne [maxligne];
FILE *p_fichier;
int main ()
{
Mon_pointeur_fichier=fopen ("essai.txt","r");
while (! feof (Mon_pointeur_fichier))
{
fgets (ligne, maxligne, Mon_pointeur_fichier);
if (! feof (Mon_pointeur_fichier))
printf ("J'ai lu :%s\n", ligne);
}
fclose (Mon_pointeur_fichier);
return 0;
}

62
EXEMPLE GENERAL SUR LES FICHIERS
01. #include <stdio.h>
02. #include <stdlib.h>
03. int main () {
04. FILE *p_fichier; /* pointeur sur fichier*/
05. char nom_fichier [20], nom_personne [20];
06. int i, nbr_enregistrements;
07. /* 1ère étape : Création et remplissage du fichier */
08. printf ("Quel est le nom du fichier à créer ? ");
09. scanf ("%s", nom_fichier) ;
10.
11. /* w: write r: read a: append*/
12. p_fichier = fopen (nom_fichier, "w");
13. if (p_fichier == NULL) {
14. printf ("Erreur de création du fichier \n");
15. exit (-1); // Abandonner le programme
16. }
17.
18. printf ("Nombre de personnes à stocker ? : ");
19. scanf ("%d", &nbr_enregistrements);
20.
21. for (i = 0; i<nbr_enregistrements; i++) {
22. printf ("Entrez le nom de la personne : ");
23. scanf ("%s", nom_personne);
24. fprintf (p_fichier, "%s\n", nom_personne);
25. }
26. fclose(p_fichier);
27.
28. /* 2ème étape : Lecture et affichage du fichier */
29. p_fichier = fopen (nom_fichier,"r"); /* read */
30. if (p_fichier == NULL) {
31. printf ("\aErreur d'ouverture sur le fichier \n");
32. exit (-2); // Abandonner le programme
33. }
34.
35. while (!feof(p_fichier)) {
36. fscanf (p_fichier, "%s ", nom_personne);
37. printf ("Nom : %s\n", nom_personne);
38. }
39. fclose(p_fichier);
40.
41. return 0;
42. }
2.10 Allocation de mémoire
2.10.1 La directive préprocessor #include

Elle permet d’inclure un fichier dans un autre.

63
2.10.2 L’inclusion des header d’une librairie standard

est faite comme suit:

#include <stdio.h> // bibliothèque par défaut

// Nécessaire à la compilation d’un Programme en langage C
#include <stdlib.h>>// bibliothèque par défaut
// Nécessaire à la compilation d’un Programme en langage C

#include <string.h>>// bibliothèque à ajouter pour la compilation

// D’un Programme utilisant des chaînes de caractère en langage C

2.10.3 L’inclusion des header des fichiers utilisateur

Est faite comme suit : #include "MonHeader.h"

2.10.4 La directive préprocessor #define

Cette directive à deux fonctionnalités distinctes, la définition de symboles et la

définition de macro-instructions. Elle permet le remplacement d’un symbole par la
valeur qu’on a attribuée à ce symbole, cette attribution pouvant être une suite
quelconque de caractères. La directive #define permet d’attribuer un symbole à un string
quelconque. Ce string peut contenir une valeur numérique, une chaîne de caractères, une
instruction. Il remplace d’une suite de caractères complexe par un symbole simple.

EXEMPLE
#define HELLO "Bonjour monsieur Dupont, comment allez-vous\?"

printf (HELLO); // HELLO est remplacé par la valeur de son #define

Dans cet exemple le pré-compilateur va remplacer le symbole HELLO par la phrase

attribuée au symbole HELLO c’est à dire ("Bonjour monsieur ……..")
Si ce texte doit être affiché à plusieurs endroits dans le programme l’écriture sera simplifiée.

2.10 Les fonctions

Le langage C ne connaît pas la notion de procédure. Seule la notion de fonction existe.

Cette fonction peut avoir zéro ou plusieurs paramètres d’entrée, elle peut avoir zéro ou un
paramètre de retour. La fonction main est la première fonction obligatoire rencontrée par le
programme et appelée depuis le boot loader

64
2.10.1 Fonction sans paramètre

Une fonction sans paramètre d’entrée et sans paramètre de retour se déclare de la manière
suivante :
void MaFonction(void) ; // Fonction sans paramètre

{// void = vide

MaData++ ;

}
Remarque :

Le mot anglais void veut dire vide.

Le premier mot void indique qu’il n’y a pas de paramètre de retour.
MaFonction est le nom de la fonction.
Le 2ème mot (void) indique qu’il n’y a pas de paramètre d’entrée.

2.10.2 Fonction avec paramètres d’entrée

Une fonction avec des paramètres d’entrée et sans paramètre de retour se déclare
de la manière suivante :

void MaFonction (int MonParam1, float MonParam2)

{ //fonction avec 2 paramètres d’entrée

MonParam1++ ;

MonParam2 = MonParam2 + 100 ;

printf (" %3d %3.3f", MonParam1, MonParam2) ;

Cette fonction à deux paramètres d’entrée, le paramètre MonParam1 est un integer,

le paramètre MonParam2 est un flotting point.
Cette fonction incrémente le paramètre d’entrée param1, et ajoute100 au paramètre
d’entrée MonParam2, puis affiche le résultat.
2.10.3 Fonction avec un paramètre de retour.

Une fonction avec un paramètre de retour se déclare de la manière suivante :

65
int MaFonction (int MonParam1, int MonParam2)

{// reçoit un int et un float et retourne un integer

int MonIntLocal ;

MonIntLocal = MonParam1 + MonParam2;

return(MonIntLocal) ;

Cette fonction a un paramètre de retour qui est un integer.

2.11 L'allocation de mémoire dynamique malloc (stdlib.h)

La fonction malloc permet la réservation de la mémoire dynamique. Le paramètre est

la taille
Nécessaire

EXEMPLE

struct str // définition d'une structure

{

unsigned int data1; //

unsigned long data2; //

}; //

struct str MaStr ; // structure à mettre

// en allocation dynamique.
struct str * MaStrPtr; // pointeur sur la structure
MaStrPtr = malloc (sizeof (str)) // la mémoire dynamique est allouée
// le pointeur est initialisé.

66
67
 EXERCICES FACILES
EXERCICE 1
Écrire un programme qui saisit deux entiers et affiche leur produit. Modifie ensuite le
programme afin de saisir deux réels.
LANGAGE PASCAL LANGAGE C
program Integer_1 ; /* Inclusion de la bibliothèque standard */
/* Déclaration des deux entiers */ # include <stdio.h>
Var x1, x2, x3 : Integer ; /* programme principal */
BEGIN /* Affichage du produit des deux entiers */
/* Lecture du premier entier */ void main ()
READLN (x1) ; {/* Déclaration des deux entiers */
/* Lecture du deuxième entier */ int x1, x2 ;
READLN (x2) ; /* Lecture du premier entier */
/* Calcul du produit des deux entiers au clavier */ printf (" valeur du premier entier : ") ; scanf ("%d", & x1) ;
X3 := x1*x2 ; /* Lecture du deuxième entier */
/* Affichage du produit des deux entiers au clavier */ printf (" valeur du deuxième entier : ") ; scanf ("%d", & x2) ;
WRITELN (‘ le produit de’, ‘’, x1, ‘’, ‘et’, x2, ‘’, ‘est’,’’, x3) ; /* Affichage du produit des deux entiers au clavier */
END. printf (" produit de %d et %d = %d", x1, x2, x1*x2) ;

return 0;
}
LANGAGE C++

/* Inclusion de la bibliothèque standard */ NB

}
: Pour les nombres réels
#include++<iostream>
/* Inclusion de la bibliothèque standard */
using namespace std;
- LANGAGE PASCAL
int main ()  Remplacer Interger par
{ int X1, X2, X3 ;
Real
/* Lecture du premier entier */

cin >> X1 ;
- LANGAGE C
/* Lecture du deuxième entier */  Remplacer int par float
cin >> X2 ;
 Dans le scanf remplacer
/* calcul du produit des deux entiers */

X3=X1*X2 ;
"%d" par "%f"
/* Affichage du produit des deux entier */ - LANGAGE C++
cout << X3 << endl ;  Remplacer int par float
return 0;
}
68
 EXERCICE 2
Ecrire un programme permettant d’échanger deux entiers et de les afficher avant et après l’échange.

LANGAGE PASCAL LANGAGE C

LANGAGE
program CHANGE ; PASCAL

/* Déclaration des deux entiers et de la variable d’échange */ /* Inclusion de la bibliothèque standard */

Var x1, x2, Echange : Integer ; # include <stdio.h>

BEGIN /* Echange et affichage de deux entiers */

/* Lecture du premier entier */ void main ()

READLN (x1) ; {/* Déclaration des deux entiers */

/* Lecture du deuxième entier */ int x1, x2, Echange ;

READLN (x2) ; /* Lecture du premier entier */

/* Affichage du premier entier avant échange */ printf (" valeur du premier entier : ") ; scanf ("%d", & x1) ;

WRITELN (‘ le premier entier avant échange est x1 = ’, ‘’, x1) ; /* Lecture du deuxième entier */

/* Affichage du deuxième entier avant échange */ printf (" valeur du deuxième entier : ") ; scanf ("%d", & x2) ;

WRITELN (‘ le deuxième entier avant échange est x2 = ’, ‘’, x2) ; /* Affichage du premier entier avant échange */

/* Echange des deux entiers */ printf (" premier entier avant est x1= %d ", x1) ;

Echange := x1 ; x1:=x2 ; x2 :=Echange ; /* Affichage du deuxième entier avant échange */

/* Affichage des deux entiers après échange */ printf (" deuxième entier avant est x2= %d ", x2) ;

WRITELN (‘ après échange ’, ‘’, ‘x1 =’, ‘’, x1, ‘’, ‘et x2 =’, ‘’, x2) ; /* Echange des entiers */

END. Echange= x1 ; x1=x2 ; x2= Echange ;

} /* Affichage des entiers après échange */

printf (" après échange x1 et x2 sont : %d et %d ", x1, x2) ;

LANGAGE C++
/* Inclusion de la bibliothèque standard */
return 0;
#include <iostream>
}
/* Inclusion de la bibliothèque standard */
using namespace std;

int main ()
NB : L’algorithme de
{int x1, x2, Echange ; changement (inversement)
/* Lecture des entiers x1 et x2 */

cin >> x1 ; cin >> x2 ;

du contenue de deux
/* Affichage des entiers x1 et x2 avant échange */
variables est un classique
cout <<" x1=" << x1 << " "<< " x2=" << x2 endl ;

/* Echange des entiers */ dans l’enseignement de

Echange= x1 ; x1=x2 ; x2=Echange ;
l’algorithmique aux
/* Affichage des entiers après échange */

cout << " Après échange x1 et x2 sont : " << x1 << " et "<< x2<< endl; étudiants en sciences
return 0;
} 69 informatique.
 EXERCICE 3
Ecris un programme qui qui affiche le code ASCII des lettres et des chiffres sous la forme suivante :
Caractère = A code= 65 code hexa= 41 Caractère = 1 code= 49 code hexa= 31
Caractère = B code= 66 code hexa= 42 ……
…… Caractère = 9 code= 57 code hexa= 39

LANGAGE PASCAL LANGAGE C

program CHANGE ; /* Inclusion de la bibliothèque standard */
/* Déclaration d’un caractère */ # include <stdio.h>
Var cCompt : char ; /* programme principal */
BEGIN void main ()
{Boucle sur tous les caractères majuscules} {/* Déclaration d’un caractère */
for cCompt := ‘A’ to ‘Z’ do ; Char cC ;

{Afficher le code ASCII de chaque caractère} /* Boucle sur tous les caractères majuscules */

WRITELN (‘ cComt : ‘, ‘’,’code ASCII :’,’’, Ord (cCompt)) ; for (cC = ‘A’ ; cC<=’B’ ; cC++) ;

{Boucle sur tous les caractères numérique de 1 à 9} /* Afficher le code ASCII et hexa de chaque caractère */

for cCompt := ‘1’ to ‘9’ do ; printf ("%c code ascii %d code hexa %x\n", cC, cC, cC) ;

/* Boucle sur tous les caractères numériques de 1 à 9 */

{Afficher le code ASCII de chaque caractère}
for (cCompt = ‘1’ ; cCompt<=’9’ ; cCompt++) ;
WRITELN (‘ cCompt : ‘, ‘’,’code ASCII :’,’’, Ord (cCompt)) ;
/* Afficher le code ASCII et hexa de chaque caractère */
END.
printf ("%c code ascii %d code hexa %x\n", cC, cC, cC) ;

return 0;
}

70
 EXERCICE 4

Ecris un programme qui détermine si un entier est pair ou impair

LANGAGE PASCAL
LANGAGE C
program parityy ;
/* Inclusion de la bibliothèque standard */
{Déclaration de l’entier}
# include <stdio.h>
Var parity : Integer ;
/* programme principal */
BEGIN
void main ()
{Saisie de l’entier}
{/* Déclaration de l’entier */
WRITELN (‘Entrez un entier’ ) ; READLN (parity) ;
int parity ;
{Teste de la parité de l’entier}
/* Saisie de l’entier */
If parity mod 2 =0 then
printf (" Entrez un entier") ; scanf ("%d", parity) ;
WRITELN (‘Le nombre saisi est pair’)
/* Si le reste de la division par 2 est nul */
else
if (parity%2)
WRITELN (‘Le nombre saisi est impair’) ;
printf ("entier pair") ;
END.
LANGAGE C++ /* Si le reste de la division par 2 est non nul */

/* Inclusion de la bibliothèque standard */ else

#include <iostream> printf ("entier impair") ;
/* Inclusion de la bibliothèque standard */
using namespace std; return 0;
}
int main ()

{/* Déclaration de l’entier */

int parity ;

/* Saisie de l’entier */

cout << " Entrez un entier" << endl ; cin >> parity ;

/* Si le reste de la division par 2 est nul */

if (parity%2)

cout << "entier pair" << endl ;

/* Si le reste de la division par 2 est non nul */

else

cout << "entier impair" << endl ;

return 0;
}

71
 EXERCICE 5

Ecris un programme qui affiche le plus grand de trois entiers sais.

LANGAGE PASCAL LANGAGE C
program max ; /* Inclusion de la bibliothèque standard */
{Déclaration des trois entiers} # include <stdio.h>
Var iEntier1, iEntier2, iEntier3 : Integer ; /* programme principal */
{Déclaration du maximum des trois entiers} void main ()
Var max : Integer ; {/* Déclaration des trois entiers */
BEGIN int iEntier1, iEntier2, iEntier3 ;
{Saisie des trois entiers} {/* Déclaration du maximum des trois */
WRITELN (‘Entrez l’entier1’) ; READLN (iEntier1) ; int max ;
WRITELN (‘Entrez l’entier2’) ; READLN (iEntier2) ; /* Saisie des trois entiers */
WRITELN (‘Entrez l’entier3’) ; READLN (iEntier3) ;
printf (" Entrez l’entier1") ; scanf ("%d", &iEntier1) ;
{Rechercher le plus grand des trois entiers}
printf (" Entrez l’entier2") ; scanf ("%d", &iEntier2) ;
If iEntier1>= iEntier2 then max := iEntier1
printf (" Entrez l’entier3") ; scanf ("%d",& iEntier3) ;
else max := iEntier2 ;
/* Rechercher le plus grand des trois */
If iEntier1>= iEntier3 then max := iEntier1
if (iEntier1>= iEntier2) max= iEntier1 ;
else max := iEntier3 ;
else max= iEntier2 ;
{Affichage du plus grand}
if (iEntier1>= iEntier3) max= iEntier1 ;
WRITELN (‘Le plus grand des trois est :’, max) ;
else max= iEntier3 ;
END.
/* Affichage du plus grand */
LANGAGE C++ printf ("Le plus grand des trois est : %d", max)
return 0;
/* Inclusion de la bibliothèque standard */ }
#include <iostream>
/* Inclusion de la bibliothèque standard */
using namespace std;
int main ()
{/* Déclaration des trois entiers */
int iEntier1, iEntier2, iEntier3 ;
{/* Déclaration du maximum des trois */
int max ;
/* Saisie des trois entiers */
cout << " Entrez l’entier1" << endl ; cin >> iEntier1 ;
cout << " Entrez l’entier2" << endl ; cin >> iEntier2 ;
cout << " Entrez l’entier3" << endl ; cin >> iEntier3 ;
/* Rechercher le plus grand des trois */
if (iEntier1>= iEntier2) max= iEntier1 ;
else max= iEntier2 ;
if (iEntier1>= iEntier3) max= iEntier1 ;
else max= iEntier3 ;
/* Affichage du plus grand */
cout << "Le plus grand des trois est : "<< max << endl ;
return 0;
}

72
EXERCICE 6
Ecris un programme qui affiche le plus grand et le plus petit d’une suite d’entiers sait.
Les nombres saisis ne sont pas conservés en mémoire la suite se termine avec 0

LANGAGE PASCAL LANGAGE C

program gran_pti ; /* Inclusion de la bibliothèque standard */
{Déclaration trois entiers} # include <stdio.h>
Var iPlugrand, iPluptit, iSaisie : Integer ; /* programme principal */
{Déclaration du maximum des trois entiers} void main ()
BEGIN {/* Déclaration du plus petit et du plus grand */
{Saisie d’un entier} int iPlugrand, iPluptit, iSaisie : Integer ;
WRITELN (‘Entrez un entier’) ; READLN (iSaisie) ; /* Déclaration de la valeur saisie */
{Initialisation d’iPluptit et iPlugrand à iSaisie} int iSaisie ;
iPluptit =iPlugrand=iSaisie ; /* Saisie d’un entier */
{Tant que la valeur saisie est différente de zéro}
printf ("Entrez un entier ") ; scanf ("%d", &iSaisie) ;
while iSaisie <> 0 do
/* Tant que la valeur saisie est différente de zéro */
begin
while (iSaisie !=0)
{Si iPlugrand est plus petit qu’iSaisie}
{
if iPlugrand < iSaisie
/* Si iPlugrand est plus petit qu’iSaisie */
then iPlugrand= iSaisie
if (iPlugrand < iSaisie)
{Si iPluptit est plus grand qu’iSaisie}
iPlugrand = iSaisie ;
else if iPluptit > iSaisie
else
then iPluptit = iSaisie ;
/* Si iPluptit est plus grand qu’iSaisie */
{Faire une nouvelle saisie}
if (iPluptit > iSaisie)
WRITELN (‘Entrez un entier’) ; READLN (iSaisie) ;
iPluptit = iSaisie ;
end ;
/* Faire une nouvelle saisie */
{Affichage du plus grand et du plus petit}
printf ("Entrez un entier ") ; scanf ("%d", &iSaisie) ;
WRITELN (‘plus grand et plus petit sont :’,’’, iPlugrand,’’,
} /* Fin de la boucle tant que*/
iPluptit) ;
/* Affichage du plus grand et du plus petit */
END.
printf ("grand et petit : %d et %d ", iPlugrand, iPluptit) ;
LANGAGE C++ return 0;
/* Inclusion de la bibliothèque standard */ }
#include <iostream>
/* Inclusion de la bibliothèque standard */
using namespace std;
int main ()
{/* Déclaration du plus petit et du plus grand */
int iPlugrand, iPluptit, iSaisie : Integer ;
/* Déclaration de la valeur saisie */
int iSaisie ;
/* Saisie d’un entier */
cout << " Entrez un entier " endl ; cin >> iSaisie ;
/* Tant que la valeur saisie est différente de zéro */
while (iSaisie !=0)
{/* Si iPlugrand est plus petit qu’iSaisie */
if (iPlugrand < iSaisie)
iPlugrand = iSaisie ;
else
/* Si iPluptit est plus grand qu’iSaisie */
if (iPluptit > iSaisie)
iPluptit = iSaisie ;
/* Faire une nouvelle saisie */
cout << " Entrez un entier " endl ; cin >> iSaisie ;
} /* Fin de la boucle tant que*/
/* Affichage du plus grand et du plus petit */
cout << "grand et petit : %d et %d " << iPlugrand << iPluptit << endl ;
return 0;

73
 EXERCICE 7
Ecris un programme qui détermine tous les diviseurs d’un entier saisi plus grand que 1

LANGAGE PASCAL LANGAGE C

program gran_pti ; /* Inclusion de la bibliothèque standard */

{Déclaration de deux entiers} # include <stdio.h>
Var iSaisie, iDiviseur : Integer ; /* programme principal */
BEGIN void main ()
{Saisie d’un entier} {/* Déclaration de deux entiers */
WRITELN (‘Entrez un entier’) ; READLN (iSaisie) ; int iSaisie, iDiviseur ;
{Initialisation de iDiviseur à iSaisie} /* Saisie d’un entier */
iDiviseur =iSaisie ; printf ("Entrez un entier ") ; scanf ("%d", &iSaisie) ;
repeat /* Initialisation de iDiviseur à iSaisie */
{Si le reste est nul et le nombre saisi est supérieur à 1} iDiviseur =iSaisie ;
if iSaisie mod iDiviseur = 0 And iSaisie > 1 then do
{Afficher le diviseur} {/* Si le reste est nul et le nombre saisi est supérieur à
WRITELN (iDiviseur,’’, ‘est un diviseur de :’,’’, iSaisie) ; 1*/
{Décrémenter le diviseur} if iSaisie mod iDiviseur = 0 And iSaisie > 1
iDiviseur= iDiviseur-1 ; /* Afficher le diviseur * /
{Tant que le diviseur est supérieur à zéro} printf ("%d est le diviseur de %d", iDiviseur, iSaisie) ;
until (iDiviseur > 0) ; {Décrémenter le diviseur}
END. iDiviseur-- ;
}
LANGAGE C++ /* Tant que le diviseur est supérieur à zéro */
/* Inclusion de la bibliothèque standard */ while (iDiviseur > 0) ;
#include <iostream> return 0;
/* Inclusion de la bibliothèque standard */ }
using namespace std;
int main ()
{/* Déclaration de deux entiers */
int iSaisie, iDiviseur ;
/* Saisie d’un entier */
cout<< "Entrez un entier " << endl ; cin >> iSaisie ;
/* Initialisation de iDiviseur à iSaisie */
iDiviseur =iSaisie ;
do
{/* Si le reste est nul et le nombre saisi est supérieur à 1*/
if iSaisie mod iDiviseur = 0 And iSaisie > 1
/* Afficher le diviseur * /
cout << "le diviseur de : " << iSaisie << " est : " << iDiviseur << endl;
{Décrémenter le diviseur}
iDiviseur-- ;
}
/* Tant que le diviseur est supérieur à zéro */
while (iDiviseur > 0) ;
return 0;
}

74
 EXERCICE 8
Ecris un programme qui stimule une opération de division entière. Entre deux entiers positifs a et b saisis
au clavier. On divise le plus grand par le plus petit sans utiliser l’opérateur /. Affiche le quotient et le reste.

program quo_rest ; {LANGAGE PASCAL} /* Inclusion de la bibliothèque standard */ LANGAGE C

{Déclaration des deux entiers saisis} # include <stdio.h>
Var iSaisie1, Saisie2 : Integer ; /* programme principal */
{Déclaration du plus grand et du plus petit} void main ()
Var iPlusgrd, iPlusptit : Integer ; {
{Déclaration du quotient et de la sauvegarde} /*Saisie du 1e entier * /
Var Quotient, iSauve : Integer ; printf ("Entrez 1er entier") ; scanf ("%d", &iSaisie1) ;
BEGIN /*Saisie du 2e entier */
{Saisie du 1e entier} printf ("Entrez 2er entier") ; scanf ("%d", &iSaisie2) ;
WRITELN (‘Entrez 1er entier’) ; READLN (iSaisie1) ; /* Initialisation du quotient */
Saisie du 2e entier} Quotient=0 ;
WRITELN (‘Entrez 2er entier’) ; READLN (iSaisie2) ; /* Recherche du plus grand des deux entiers */
{Initialisation du quotient} If (iSaisie1>= Saisie2)
Quotient=0 ; {
{Recherche du plus grand des deux entiers} iPlusgrd= iSaisie1 ; iPlusptit= Saisie2 ; iSauve= iSaisie1 ;
If iSaisie1>= Saisie2 then }
iPlusgrd= iSaisie1 ; iPlusptit= Saisie2 ; iSauve= iSaisie1 else
else iPlusptit= iSaisie1 ; iPlusgrd= iSaisie2 ; iSauve= {
iSaisie2 ; iPlusptit= iSaisie1 ; iPlusgrd= iSaisie2 ; iSauve= iSaisie2 ;
{Tant que iPlusgrd est supérieur à iPlusptit} }
while (iPlusgrd>= iPlusptit) do /* Tant que iPlusgrd est supérieur à iPlusptit */
begin while (iPlusgrd>= iPlusptit)
{Incrémenter le quotient} {
Quotient= Quotient+1 ; /* Incrémenter le quotient */
{Soustraire le plus grand du plus petit} Quotient= Quotient+1 ;
iPlusgrd= iPlusgrd- iPlusptit ; /* Soustraire le plus grand du plus petit */
end ; {Fin de la boucle tant que} iPlusgrd= iPlusgrd- iPlusptit ;
{Afficher le quotient} } ; /* Fin de la boucle tant que */
WRITELN (‘Le quotient de la division de : ’,’’, iSauve,’’, /* Afficher le quotient */
‘par’,’’, iPlusptit,’’, ‘est’,’’, Quotient) ; printf ("Le quotient de la division de %d et %d = %d \n",
{Afficher le reste} iSauve, iPlusptit, Quotient) ;
WRITELN (‘Le reste de la division est : ’,’’, iPlusgrd) ; {Afficher le reste}
END. printf ("Le reste de la division est : \n", iPlusgrd) ;
return 0;
/* Inclusion de la bibliothèque standard */ LANGAGE C++ }
#include <iostream>
/* Inclusion de la bibliothèque standard */
using namespace std;
int main ()
{/ *Saisie du 1e entier et du 2e entier * /
cout << "Entrez 1er et 2e entier" << endl ; cin >> iSaisie1 ; cin >> iSaisie2 ;
Quotient=0 ; /* Initialisation du quotient */
/* Recherche du plus grand des deux entiers */
If (iSaisie1>= Saisie2)
{
iPlusgrd= iSaisie1 ; iPlusptit= Saisie2 ; iSauve= iSaisie1 ;
}
else
{
iPlusptit= iSaisie1 ; iPlusgrd= iSaisie2 ; iSauve= iSaisie2 ;
}
while (iPlusgrd>= iPlusptit) /* Tant que iPlusgrd est supérieur à iPlusptit */
{/* Incrémenter le quotient et Soustraire le plus grand du plus petit */
Quotient= Quotient+1 ; iPlusgrd= iPlusgrd-iPlusptit ;
} ; /* Fin de la boucle tant que */
/* Afficher le quotient et le quotient */
cout << " Le quotient de la division de : " << iSauve << " et " << iPlusptit << "
est " << Quotient << " le reste est : " << iPlusgrd << endl ;
return 0;
75
}
 EXERCICE 9
Ecris un programme qui se comporte comme une calculatrice c’est-à-dire exécutant la boucle sur :
-Lecture d’une ligne supposée contenir un entier, un opérateur et un entier (ex : 1+ 3). Les opérateurs sont
+, -,*, \ et %.
-Calcul de la valeur de l’expression
-Impression à l’écran.
-
LANGAGE PASCAL LANGAGE LANGAGE C
program CALCO ; /* Inclusion de la bibliothèque standard */
{Déclaration des constantes booléennes} # include <stdio.h>
const VRAI=1 ; /* programme principal */
const FAUX=0 ; void main ()
{Déclaration des opérante} {
Var iEntier1, iEntier2, Result : Integer ; /* Déclaration des constantes booléennes */
{Déclaration de l’opérateur} const VRAI=1 ;
Var cOperateur : string ; const FAUX=0 ;
{Déclaration d’un booléen d’impression du résultat} /* Déclaration des opérante */
Var iAutorisaImp : Integer ; int iEntier1, iEntier2, Result ;
BEGIN /* Déclaration de l’opérateur */
{Boucle pour l’opération} char cOperateur ;
while VRAI /* Déclaration d’un booléen d’impression du résultat */
begin int iAutorisaImp ;
{Saisie des opérandes : Ex : 3 + 2 = 5} {Boucle pour l’opération}
READLN (iEntier1, cOperateur, iEntier2) ; while (1)
{Initialisation de l’autorisation d’impression} {
iAutorisaImp= VRAI ; /* Saisie de l’opération : Ex : 3 + 2 = 5 */
{Teste sur l’opérateur} scanf ("%d %c %d", & iEntier1, &cOperateur, &iEntier2) ;
case cOperateur of /* Initialisation de l’autorisation d’impression */
‘+’ : Result= iEntier1+ iEntier2 ; iAutorisaImp= VRAI ;
‘-’ : Result= iEntier1- iEntier2 ; /* Teste sur l’opérateur */
‘*’ : Result= iEntier1* iEntier2 ; switch (cOperateur)
‘/’ : {Si l’entier deux est nul} {case ‘+’ : Result= iEntier1+ iEntier2 ; break ;
if iEntier2=0 then case ‘-’ : Result= iEntier1- iEntier2 ; break ;
WRITELN (‘Le diviseur est nul ’) case ‘*’ : Result= iEntier1* iEntier2 ; break ;
{Affecter faux à l’impression} case ‘/’ :
iAutorisaImp = FAUX if iEntier2=0
else { / * Si l’entier deux est nul * /
Result = iEntier1 / iEntier2 ; WRITELN (‘Le diviseur est nul ’) ;
‘mod’ : iEntier1 mod iEntier2 ; / * Affecter faux à l’impression * /
else WRITELN (‘L’opérateur n’est pas correct ’) ; iAutorisaImp = FAUX ;
end ; }
{Tester la possibilité d’impression} / * Si l’entier deux est non nul * /
if iAutorisaImp =VRAI then else Result = iEntier1 / iEntier2 ; break ;
{Afficher le calcul} case ‘%’ : Result= iEntier1 % iEntier2 ; break ;
WRITELN (‘Le résultat de la division est : ’,’’, Result) ; default : {printf ("L’opérateur %d est incorrect’ : \n",
END. cOperateur) ;
}
} / * Fin de la boucle switch * /
;
/ * Si on peut imprimer le résultat, on l’imprime * /
if (iAutorisaImp == VRAI) printf ("Le résultat est %d : \n",
Result) ;
} / * Fin de la boucle while * /
return 0;
}

76
 EXERCICES SUR LES VARIABLES COMPOSÉES

EXERCICE 10
Ecris un programme qui permet de déclarer et d’initialiser un tableau d’entier de 10, dont certaines valeurs
sont nulles. Le programme doit parcourir le tableau et imprimer les indexes des valeurs nulles (sans utiliser
utiliser une variable de type entier).

LANGAGE PASCAL C LANGAGE LANGAGE C

program tab_NUL ; /* Inclusion de la bibliothèque standard */
{Déclaration du tableau de 10 entiers} # include <stdio.h>
const Max=10 ; /* programme principal */
Tabint = array [1..Max] of Integer ; void main ()
{Déclaration des variables indice} {
Var i, j : Integer ; /* Déclaration du tableau de 10 entiers */
BEGIN const int MAX=10;
{Initialisation du tableau} int Tabint [MAX]={9,5,0,7,0,9,19,8,7,0} ;
for i := 1 to 10 do /* Déclaration de pointeur sur les entiers*/
begin Int*DebTab=NULL ;
{Saisir un entier au clavier} Int*FinTab=NULL ;
WRITELN (‘entrez un entier s.v.p’) ; Int*cCompt=NULL ;
READLN (Tabint[i]) ; /* pointer su le début et la fin du tableau */
end ; * DebTab= &Tabint [0] ;
for i := 1 to 10 do * FinTab= &Tabint [MAX-1] ;
begin /* Boucler sur les indexes du tableau */
if Tabint[i]=0 then for (cCompt= DebTab ; cCompt<= FinTab ; cCompt++)
j=1 ; {/ * Rechercher les valeurs nulles* /
WRITELN (‘ L’indice de la’, j,’ème’,’’,’valeur nulle est’,’’, if (*cCompt==0) printf ("l’élément nulle est d’indice %d
i) ; %d, cCompt- DebTab) ;
end ; }
END. return 0;
}
LANGAGE LANGAGE C++
/* Inclusion de la bibliothèque standard */
#include <iostream>
/* Inclusion de la bibliothèque standard */
using namespace std;
int main ()
{/* Déclaration des variable et du tableau de 10 entiers */
const int MAX (10) ;
int Tabint [MAX] ;
int i ;
/* Initialisation du tableau */
for (i=0 ; i <= 9 ; i++)
{
cout << "entrez un entier s.v.p"<< endl ; cin >> Tabint [i] ;
}
/* Déclaration de pointeur sur les entiers*/
Int*DebTab=NULL ; Int*FinTab=NULL ; Int*cCompt=NULL ;
/* pointer su le début et la fin du tableau */
*DebTab= &Tabint [0] ; *FinTab= &Tabint [MAX-1] ;
/* Boucler sur les indexes du tableau */
for (cCompt= DebTab ; cCompt<= FinTab ; cCompt++)
{/ * Rechercher les valeurs nulles* /
if (*cCompt==0) cout << "l’élément nulle est d’indice" <<
cCompt- DebTab << endl ;
}
return 0;
}
77
 EXERCICE 11
Ecris un programme qui permet de déclarer et d’initialiser un tableau de 10 entiers, ensuite de procéder au
tri croissant de celui-ci. Il vous est demandé de faire un tri_bul.

LANGAGE PASCAL LANGAGE C

program Tri_mat ; #include <stdio.h>
{Déclaration du tableau de 10 entiers} #include <stdlib.h>
const Max=10 ; void main ()
Tabint = array [1..Max] of Integer ; {/* Déclaration du tableau de 10 entiers */
{Déclaration des variables indice et d’échange} const int NB_MAX=10;
Var i, j, iEchange : Integer ; int i, j, ichange;
BEGIN int itab [NB_MAX];
{/* Initialisation du tableau */
{Initialisation du tableau}
for (i=0;i<=NB_MAX-1;i++)
for i := 1 to 10 do
{{/* Saisir un entier au clavier */
begin
printf ("entrez l’élément %d\n", i);
{Saisir un entier au clavier}
scanf ("%d", &itab[i]);
WRITELN (‘entrez un entier s.v.p’) ; }
READLN (Tabint[i]) ; /* Tri du tableau */
end ; for (i=0;i<=NB_MAX-1;i++)
{Tri du tableau } {
for i := 1 to 10 do for (j=NB_MAX;j>=i+1;j--)
begin {/* Echange quand l’élément précédent est supérieur */
for j := 10 downto i+1 do if (itab[j] <itab [j-1])
{Echange quand l’élément précédent est supérieur} {
if (Tabint[j] < Tabint [j-1]) then ichange =itab[j];
iEchange = Tabint[j] ; itab[j]=itab[j-1] ;
Tabint[j]= Tabint [j-1] ; itab[j-1]= ichange ;
Tabint [j-1] = iEchange ; }
end ; }
}
{Affichage du tableau trié}
{/* Affichage du tableau trié */
for j := 1 to 10 do
for (j=0;j<=NB_MAX-1;j++)
WRITELN (‘ L’élément’,’’, j,’’,’est :’, Tabint[j]) ; {
END. printf ("L'élément %d est : %d \n",j,itab[j]);
}
LANGAGE C++ return 0;
/* Inclusion de la bibliothèque standard */ }
#include <iostream>
/* Inclusion de la bibliothèque standard */
using namespace std;
{/* Déclaration du tableau de 10 entiers */
const int NB_MAX=10;
int i, j, ichange ; int itab [NB_MAX] ;
{for (i=0;i<=NB_MAX-1;i++) /* Initialisation du tableau */
{{/* Saisir un entier au clavier */
Cout << "entrez l’élément" << i << endl ; sin >> itab[i]) ;
} /* Tri du tableau */
for (i=0;i<=NB_MAX-1;i++)
{ for (j=NB_MAX;j>=i+1;j--)
{/* Echange quand l’élément précédent est supérieur */
if (itab[j] <itab [j-1])
{ ichange =itab[j] ; itab[j]=itab[j-1] ; itab[j-1]= ichange ;
}
}
}
{/* Affichage du tableau trié */
for (j=0;j<=NB_MAX-1;j++)
{
Cout << "L'élément est :" << j <<"est" << itab[j] << endl ;
}
return 0;
} 78
 EXERCICE 12
Ecris un programme qui permet de déclarer et d’initialiser un tableau de 10 entiers, ensuite de procéder au
tri décroissant de celui-ci. Il vous est demandé de faire un tri_bul.

LANGAGE PASCAL LANGAGE C

program Tri_mat ; #include <stdio.h>
{Déclaration du tableau de 10 entiers} #include <stdlib.h>
const Max=10 ; void main ()
Tabint = array [1..Max] of Integer ; {/* Déclaration du tableau de 10 entiers */
{Déclaration des variables indice et d’échange} const int NB_MAX=10;
Var i, j, iEchange : Integer ; int i, j, ichange;
BEGIN int itab [NB_MAX];
{/* Initialisation du tableau */
{Initialisation du tableau}
for (i=0;i<=NB_MAX-1;i++)
for i := 1 to 10 do
{{/* Saisir un entier au clavier */
begin
printf ("entrez l’élément %d\n", i);
{Saisir un entier au clavier}
scanf ("%d", &itab[i]);
WRITELN (‘entrez un entier s.v.p’) ; }
READLN (Tabint[i]) ; /* Tri du tableau */
end ; for (i=0;i<=NB_MAX-2 ; i++)
{Tri du tableau } {
for i := 1 to 9 do for (j=0 ; j<=i+1 ; j++)
begin {/* Echange quand l’élément précédent est supérieur */
for j := 1 to i+1 do if (itab[j] > itab [j-1])
{Echange quand l’élément précédent est supérieur} {
if (Tabint[j] > Tabint [j-1]) then ichange =itab[j];
iEchange = Tabint[j] ; itab[j]=itab[j-1] ;
Tabint[j]= Tabint [j-1] ; itab[j-1]= ichange ;
Tabint [j-1] = iEchange ; }
end ; }
}
{Affichage du tableau trié}
{/* Affichage du tableau trié */
for j := 1 to 10 do
for (j=0 ; j<=NB_MAX-1;j++)
WRITELN (‘ L’élément’,’’, j,’’,’est :’, Tabint[j]) ; {
END. printf ("L'élément %d est : %d \n",j,itab[j]);
}
LANGAGE C++ return 0;
/* Inclusion de la bibliothèque standard */ }
#include <iostream>
/* Inclusion de la bibliothèque standard */
using namespace std;
{/* Déclaration du tableau de 10 entiers */
const int NB_MAX=10;
int i, j, ichange ; int itab [NB_MAX] ;
{for (i=0;i<=NB_MAX-1;i++) /* Initialisation du tableau */
{{/* Saisir un entier au clavier */
Cout << "entrez l’élément" << i << endl ; sin >> itab[i]) ;
} /* Tri du tableau */
for (i=0;i<=NB_MAX-2 ; i++)
{for (j=0 ; j<=i+1 ; j++)
{/* Echange quand l’élément précédent est supérieur */
if (itab[j] > itab [j-1])
{ichange =itab[j] ; itab[j]=itab[j-1] ; itab[j-1]= ichange ;
}
}
}
{/* Affichage du tableau trié */
for (j=0;j<=NB_MAX-1;j++)
{
Cout << "L'élément est :" << j <<"est" << itab[j] << endl ;
}
return 0;
}
79
 EXERCICE 13
Ecris un programme qui permet de déclarer et d’initialiser une matrice de dimension 5 et d’afficher les valeurs
enregistrée.
LANGAGE PASCAL LANGAGE C
program Tri_mat ; #include <stdio.h>
{Déclaration du tableau de 10 entiers} #include <stdlib.h>
const Max=5 ; void main ()
Tabint = array [1.. Max] of array [1.. Max] of Integer ; {/* Déclaration du tableau de 10 entiers */
{Déclaration des variables indice} const int NB_MAX=5;
Var i, j : Integer ; int itab [NB_MAX] [NB_MAX] ;
BEGIN int i, j ;
{Initialisation du tableau} {/* Initialisation du tableau */
for i := 1 to 5 do for (i=0 ; i<=NB_MAX-1;i++)
begin {/* Saisir un entier au clavier */
for j := 1 to 5 do for (j=0 ; j<=NB_MAX-1;i++)
{Saisir un entier au clavier} {
printf ("entrez l’élément %d %d \n", i, j) ;
WRITELN (‘entrez le coefficient’,’’, i,’’, j) ;
scanf ("%d", &itab[i][j]);
READLN (Tabint [i, j]) ; }
end ; }
{Affichage du tableau trié} {/* Affichage du tableau trié */
for i := 1 to 5 do for (i=0;i<=NB_MAX-2 ; i++)
begin {
for j :=1 to 5 do for (j=0 ; j<=NB_MAX-1;j++)
WRITELN (‘ Le coefficient ’,’’, i,’’, j,’’,’est :’, Tabint [i, j]) ; {
end ; printf ("L'élément %d %d est : %d \n", i, j, itab[i][j]));
END. }
}
LANGAGE C++ return 0;
/* Inclusion de la bibliothèque standard */ }
#include <iostream>
/* Inclusion de la bibliothèque standard */
using namespace std;
{/* Déclaration du tableau de 10 entiers */
const int NB_MAX=5;
int itab [NB_MAX] [NB_MAX] ;
int i, j ;
{/* Initialisation du tableau */
for (i=0 ; i<=NB_MAX-1;i++)
{/* Saisir un entier au clavier */
for (j=0 ; j<=NB_MAX-1;i++)
{
Cout << "entrez l’élément " << i << j << endl ;
cin >> itab[i][j] ;
}
}
{/* Affichage du tableau trié */
for (i=0;i<=NB_MAX-2 ; i++)
{
for (j=0 ; j<=NB_MAX-1;j++)
{
Cout << "L'élément d’indice" << i << j <<itab[i][j] <<
endl ;
}
}
return 0;
}

80
 EXERCICE 14
Ecris un programme qui permet d’écrire dans un fichier texte et de lire le contenu de ce fichier.

LANGAGE PASCAL LANGAGE C

program Tri_mat ; #include <stdio.h>
{Déclaration de deux chaines de caractères} #include <stdlib.h>
const Max=81 ; void main ()
cNom, cArticle : string [81] ; {/* Déclaration du tableau de 10 entiers */
{Déclaration des entiers} const int NB_MAX=5;
Var iNombre, iPrix, icompteur, Nb_Enreg : Integer ; int itab [NB_MAX] [NB_MAX] ;
Var c_fich : text ; int i, j ;
{/* Initialisation du tableau */
BEGIN
for (i=0 ; i<=NB_MAX-1;i++)
{Initialisation du tableau}
{/* Saisir un entier au clavier */
assign (c_fich, c_fichier) ;
for (j=0 ; j<=NB_MAX-1;i++)
rewrite (c_fich) ; {
ok := IoResult = 0 ; printf ("entrez l’élément %d %d \n", i, j) ;
if not ok then scanf ("%d", &itab[i][j]);
writeln ('Erreur création fichier ', c_fichier) ; }
exit ; }
WRITELN (‘Le nombre d’enregistrement s.v.p. ’) ; {/* Affichage du tableau trié */
READLN (Nb_Enreg) ; for (i=0;i<=NB_MAX-2 ; i++)
for i := 1 to Nb_Enreg do {
{Affichage du tableau trié} for (j=0 ; j<=NB_MAX-1;j++)
for i := 1 to 5 do {
begin printf ("L'élément %d %d est : %d \n", i, j, itab[i][j]));
WRITELN (‘Entrez le nom du client’) ; }
READLN (cNom) ; }
WRITELN (‘Entrez le nom de l'article‘) ; return 0;
READLN (cArticle) ; }
WRITELN (‘Entrez le nombre d'article ‘) ;
READLN (iNombre) ; LANGAGE C++
WRITELN (‘Entrez le prix de l'article ‘) ; /* Inclusion de la bibliothèque standard */
READLN (iPrix) ; #include <iostream>
WRITE (c_fich, cNom) ; /* Inclusion de la bibliothèque standard */
WRITE (c_fich, cArticle) ; using namespace std;
WRITE (c_fich, iNombre) ; {/* Déclaration du tableau de 10 entiers */
WRITE (c_fich, iPrix) ; const int NB_MAX=5;
int itab [NB_MAX] [NB_MAX] ;
close (c_fich) ;
int i, j ;
end ; {/* Initialisation du tableau */
END. for (i=0 ; i<=NB_MAX-1;i++)
{/* Saisir un entier au clavier */
for (j=0 ; j<=NB_MAX-1;i++)
{
Cout << "entrez l’élément " << i << j << endl ;
cin >> itab[i][j] ;
}
}
{/* Affichage du tableau trié */
for (i=0;i<=NB_MAX-2 ; i++)
{
for (j=0 ; j<=NB_MAX-1;j++)
{
Cout << "L'élément d’indice" << i << j <<itab[i][j] << endl ;
}
}
return 0;
}

81