Introduction
Il est nécessaire dans un premier temps de prendre
conscience de la difficulté que nous avons d’exprimer la solution à un problème
donné de façon complète et non ambiguë.
Dans la situation de résolution d’un problème, deux
étapes :
§
Qu’avons nous à
faire : QUOI
§
Comment
allons-nous résoudre le problème : Expression du COMMENT
Deux étapes distinctes, l’analyse précédant toujours la
conception.
Par la suite nous utiliserons un pseudo-langage, comportant
toutes les structures de base d' un
langage de programmation.
Un programme est une suite d' instructions
exécutées par la machine.
Ces instructions peuvent soit s' enchaîner
les unes après les autres, on parle alors de SEQUENCE D' INSTRUCTIONS;
ou bien s' exécuter dans certains cas
et pas dans d' autres, on parle alors
de STRUCTURE ALTERNATIVE; ou se répéter plusieurs fois, on parle alors de
STRUCTURE REPETITIVE.
La déclaration des variables
Un programme exécutable est composé de deux
parties :
Données / Instructions
La partie instructions contient les
instructions à exécuter. Nous verrons dans le chapitre suivant quelles sont les
principales instructions distinguées.
La partie données contient toutes les
variables utilisées par le programme.
Un programme exécutable est chargé dans la
mémoire centrale de l' ordinateur, les
valeurs que l' on a affectées aux
variables doivent être conservées tout le temps du déroulement du programme.
Par conséquent, il faut que le programme
soit capable de réserver la place nécessaire aux variables.
Pour ce faire, les variables doivent être
déclarées afin que le compilateur sache quelle place elles vont occuper.
Les valeurs des variables sont par
définition amenées à être modifiées ou tout du moins susceptibles d’être
modifiées. Elles s’opposent en ce sens à des données immuables qui peuvent être
utilisées par le programme et qui conservent donc leur valeur tout au long de
l’exécution du programme. Celles-ci seront désignées sous le vocable de Constantes par opposition à Variables.
Les types :
Les variables que l' on
utilise dans les programmes ne sont pas toutes de même nature, il y a des
nombres, des caractères, ... On dit que les variables sont typées.
Il est nécessaire de donner un type aux
variables. Cela permet d' une part de
contrôler leur utilisation (ex: on ne peut pas diviser un caractère par un
entier). D' autre part, le programme
connait ainsi la place qu’il lui faut réserver pour cette variable.
Les langages de programmation offrent à
minima les types suivants :
ENTIER
: il s' agit des variables destinées
à contenir un nombre entier positif ou négatif.
Dans notre langage, on écrira la déclaration
des variables de type entier :
ENTIER variable1, variable2, ... ;
Généralement un entier occupe 2 octets, ce
qui limite les valeurs de -32768 à +32768.
Cependant cela dépend des machines, des
compilateurs, et des langages.
Certains langages distinguent les entiers
courts (1 octet), les entiers longs (4 octets) et les entiers simples (2
octets).
REEL
: il s' agit des variables numériques
qui ne sont pas des entiers, c' est à
dire qui comportent des décimales et qui sont des valeurs approximatives.
Dans notre langage, la déclaration des
variables de type réel est la suivante :
REEL variable1, variable2, ... ;
Les valeurs numériques peuvent recouvrir
bien d’autres types (décimal, flottant, …)
CARACTERE
: Les variables de type caractère contiennent des caractères alphabétiques ou
numériques (de 0 à 9), mais dans ce cas ils ne sont pas considérés comme étant
des nombres et on ne peut pas faire d' opérations
dessus.
Un caractère occupe un octet.
Dans notre langage, une variable de type
caractère se déclare ainsi :
CAR variable1 , variable2 , ...;
N.B. : les chaînes de caractères,
dans notre langage, sont des tableaux de caractères (voir 1.6.2)
BOOLEEN
: Il est souvent nécessaire lorsque l' on
écrit un programme d' introduire des
variables qui prennent les valeurs VRAI ou FAUX ou les valeurs OUI ou NON.
Pour cela, il existe un type particulier
dont les variables ne peuvent prendre que 2 valeurs : VRAI ou FAUX.
Dans notre langage, la déclaration s' écrit :
BOOLEEN variable, variable, ... ;
La séquence d' instructions
Une instruction est une action que l' ordinateur
est capable d' exécuter.
Chaque langage de programmation fournit une liste des
instructions qui sont implémentées et que l' on
peut donc utiliser sans les réécrire
Dans notre pseudo-langage, nous aurons une liste minimum d' instructions, nécessaire et suffisante pour les
programmes que nous aurons à écrire. Cette liste est bien entendu moins fournie
que celle que proposerait un langage informatique opérationnel.
L' affectation
Variable
<-- Valeur
Ce qui se lit "variable reçoit valeur" et qui
signifie que l' on mémorise la valeur
à un endroit nommé variable.
Par
exemple : i <-- 1 Termine
<-- VRAI
3.2. Les opérations arithmétiques
Les opérations arithmétiques courantes, addition,
soustraction, multiplication et division s' écrivent
ainsi :
variable
<--val1 + val2
variable
<-- val1 - val2
variable
<-- val1 * val2
variable
<-- val1 / val2
On doit toujours affecter le résultat d' une opération dans une variable.
Le dialogue avec l' utilisateur
Pour permettre au programme de dialoguer avec l' utilisateur, c' est
à dire d' afficher un résultat à l' écran et de lire une entrée au clavier, il faut au
moins deux instructions une pour lire, l' autre
pour afficher.
Dans le pseudo-langage, elles s' écrivent
ainsi :
LIRE
Variable
AFFICHER
Texte Variable Variable Texte ...
La première lit tous les caractères qui sont saisis au
clavier, jusqu' à ce que l' utilisateur appuie sur la touche entrée, et stocke
le résultat dans la variable.
La seconde affiche sur l' écran
le ou les textes et la valeur des variables.
AFFICHER
"Quel est ton nom ? "
LIRE
nom_utilisateur
AFFICHER
"Ton nom est : " nom_utilisateur ". Le mien est TOTO"
La structure alternative
Il est souvent nécessaire lorsque l' on
écrit un programme de distinguer plusieurs cas conditionnant l' exécution de certaines instructions. On utilise alors
une structure alternative : si on est dans tel cas, alors on fait cela sinon on
fait ceci.
La syntaxe de cette instruction est la suivante :
SI
condition ALORS actions [ SINON actions] FSI
Les crochets signifient que la partie SINON actions
est facultative.
SI (a <
0) ALORS ABS<-- a*(-1) SINON ABS <-- a FSI
SI (a
<> 0) ALORS RES <-- B/a FSI
4.1. Les conditions
4.1.1. Les opérateurs de comparaison
Pour exprimer les conditions on utilise les opérateurs
conditionnels suivants :
§
= égal
§
< inférieur
§
supérieur
§
<= inférieur
ou égal
§
>= supérieur
ou égal
§
différent
(a<1)
(toto
<> titi)
Les opérateurs logiques
Ils peuvent être combinés pour exprimer des conditions complexes.
Les opérateurs logiques sont les suivants :
§
ET
§
OU
§
NON
§
XOR(ou exclusif)
Pour qu’une condition dont les deux membres sont reliés par
un ET soit vraie, il faut que les deux membres soient vrais. Avec le OU que
l’un ou l’autre soit vrai. Le NON exprime la négation du vrai. Avec l’opérateur
XOR, il faut que l’un ou l’autre soit vrai mais pas les deux.
(a<2) ET ((b
= 0) OU (c <>a)) XOR (d = 1))
Lorsque l' on
écrit de telles conditions, il est recommandé de mettre toutes les parenthèses
afin d' éviter les erreurs. Les
parenthèses précisent que l’on doit d’abord évaluer ce qui se trouve entre les
2 parenthèses.
Les actions conditionnées
Les actions qui suivent le SINON ou le ALORS peuvent être :
§
- une simple instruction
§
- une suite d' instructions
séparées par des ;
§
- une autre alternative
§
- une répétitive
La structure répétitive
Un programme a presque toujours pour rôle de répéter la même
action un certain nombre de fois. Pour ce faire on utilise une structure
permettant de dire " Exécute ces actions jusqu' à
ce que telle condition soit remplie".
Bien qu' une seule
soit nécessaire, la plupart des langages de programmation proposent trois types
de structure répétitive.
Voici celles de notre pseudo-langage.
Le TantQue
TantQue condition
Faire
actions
FTQ
Ce qui signifie : tant que la condition est vraie, on
exécute les actions.
fini
<-- FAUX;
TantQue
(NON fini)
Faire
i<-i+1;
SI
(x/i < epsilon)
ALORS
fini <-- VRAI
SINON
x <-- x/i
FSI
FTQ
Le Faire Jusqu' à
FAIRE
actions
JUSQUA condition
Ce qui signifie que l' on
exécute les actions jusqu' à ce que
la condition soit vraie.
fini
<-- FAUX;
Faire
i
<-i+1;
SI
(x/i < epsilon)
ALORS
fini <-- VRAI
SINON
x <-- x/i
FSI
Jusqua
(fini = VRAI);
Le Pour
Très souvent, on utilise une structure répétitive avec un
compteur et on s' arrête lorsque le
compteur a atteint sa valeur finale.
i <-- 1
TantQue
(i < 10)
Faire
p
<-- p*x
i
<-- i+1
FTQ
C' est pourquoi la
plupart des langages de programmation offrent une structure permettant d' écrire cette répétitive plus simplement.
Dans le pseudo-langage c' est
la structure POUR
:
POUR
variable ALLANT DE valeur initiale A
valeur finale [PAS valeur du pas]
FAIRE
actions
FinPour
Lorsque le PAS est omis, il est supposé égal à +1.
POUR i
ALLANT DE 1 A
10
FAIRE
p
<-- p*x
FinPour
Les tableaux
On peut regrouper plusieurs variables sous un même nom,
chacune étant alors repérée par un numéro. C' est
ce que l' on appelle un tableau. On
peut faire un tableau avec des variables de n' importe
quel type.
Dans tous les cas le ième élément d' un tableau appelé TAB sera adressé par TAB(i).
Généralement on fait des tableaux à une dimension, mais il
existe également des tableaux à deux dimensions, dans ce cas TAB(i,j)
représente la jème colonne et la ième ligne.
TABLEAU type variable [
longueur ] ;
TABLEAU
CAR mot[10];
TABLEAU
ENTIER liste_nb[25];
TABLEAU
CAR MOTS[10][20];
