Toutes
les instructions algorithmiques tournent autour de la gestion des données en mémoire.
Toutes
les données transitent par la mémoire vive.
retour
1.1.1 : Plan
La structure générale d’un algorithme
Les déclarations des
données
Les instructions de base
Les fonctions de base
L’alternative
Les
répétitives
Les
tableaux
Les
procédures et les fonctions
Les
fichiers
Les
piles, listes et files
retour
1.1.2 : LA STRUCTURE GENERALE D’UN ALGORITHME
Un
algorithme est composé d’une partie déclarative permettant de décrire et de
nommer les données manipulées
par l’algorithme.
C’est
dans cette partie déclarative que l’on trouve les procédures et fonctions
appelées par l’algorithme ou le nom d’une bibliothèque les contenant. (cas
des procédures externes non connues du compilateur)
La
deuxième partie de l’algorithme est la partie exécution ou l’on retrouve
les instructions de manipulation des données.
ALGORITHME Nom
de l’algorithme
/* PARTIE DECLARATIVE */
TYPES définition des types
structurés
CONSTANTES définition
des constantes
VARIABLES
définition des variables
PROCEDURE
définition des procédures
FONCTION
définition des fonctions
/* PARTIE EXECUTABLE */
DEBUT
Initialisation des variables
Entrée des données par l’utilisateur
Traitement des données
Sortie des données résultat vers l’utilisateur
FIN
Un ordinateur manipule des
données mais on peut le faire simplement ou plus difficilement. Il existe donc
différentes structures de données que nous allons voir ensuite qui présentent
des avantages ou des inconvénients , le rôle de l'analyste étant de choisir
la structure de données la mieux adaptée au problème à traiter.
La manipulation d’une
donnée se fait grâce à son nom et ce nom permet de manipuler dans certaines
structures de données une quantité importante d’informations.
Liste des structures de
données:
-
CONSTANTE
-
VARIABLE
-
TABLEAU
-
ENREGISTREMENT
-
FICHIER
-
PILE
-
FILE
-
LISTE
-
TABLE
-
OBJET
retour
1.1.3 : LES COMMENTAIRES
Chaque fois que cela sera possible , il faut mettre des
commentaires qui serviront à la maintenance de votre programme et à la
lisibilité.
Les commentaires se placent entre /* et */
/* commentaires
*/
Pour les
corrections à domicile mettre en début du programme:
/****************************************************************************
nom:---------
prénom:------------------ date: -----------
exercice :
---------- à rendre pour
le : ----------------
******************************************************************************/
et pour
chaque boucle , une explication du traitement désiré.
retour
1.1.4 : LES REGLES D’ECRITURE
Le choix des noms de variables
doit permettre d’aider à la compréhension des algorithmes. Il faut
donc donner un nom proche de la véritable utilisation de la donnée. Ex :
client et non i
Décaler les instructions appartenant à une autre
instruction.
retour
1.1.5 : LES DECLARATIONS DES DONNEES
Un ordinateur ne manipule
que des données en mémoire. Il faut donc définir les données qui seront
utilisées pour résoudre le problème à traiter. Chaque donnée sera mise dans
une case de la mémoire et un nom lui sera affecté pour pouvoir la manipuler
facilement par son nom et non par
son adresse.
Pour pouvoir manipuler la
valeur de la donnée 1 ,nous pouvons utiliser son adresse mais pour faciliter l'écriture
algorithmique nous pouvons remplacer son adresse par un nom.
Exemple:
Contenu de l'adresse 0 +
contenu de l'adresse 2 à mettre dans la case ayant pour adresse 1.
Deviendra en langage
algorithmique:
Somme <- note 1 + note 2
1.1.5.1 : Les
variables
Les variables sont des données
qui peuvent changer de valeur au cours de l’algorithme.
Leurs
valeurs sont valable dans le domaine de définition de la donnée qui
peut être un type standard (chaîne, entier, réel,
booléen,octet,mot,caractère)
ou un type structuré, construit précédemment par la commande TYPES.
Nous verrons cette commande
plus loin.
VARIABLES <identifiant_type> <identifiant_var1>[,
<identifiant_var2>[...]]
Cette commande affecte donc
un nom à une case mémoire pour permettre sa manipulation
Exemple :
1.1.5.1.1 : Types disponibles
Entier
:
nombres entiers signés
Exemple :
-10
0
+1523
Réel
:
nombres flottants signés
Exemple :
-10,2
0
+152,3
12
Rappel :
l’ensemble des réels contient l’ensemble des entiers
On
peut donc mettre une variable de type entier dans une variable de type réel.
Octet
:
nombres entiers non signés sur un octet
Mot
:
nombres entiers non signés sur un mot (deux octets)
Booléen
:
type de toute expression relationnelle.
Énumération définissant les
données Vrai
et Faux.
Caractère
:
caractère ANSI sur un octet
Chaîne
:
chaîne de caractères. L'octet 0 est sans signification, les suivants
sont les caractères.
une
chaîne peut être vide (représentation "") ou contenir un à
plusieurs caractères
Les
caractères sont des lettres de l’alphabet majuscules ou minuscules, des
chiffres, des caractères spéciaux .
Voir
la table ASCII en annexe.
1.1.5.2 : Les
constantes
Les constantes sont des
données qui ne changent pas de valeur au cours de l’algorithme.
CONSTANTES
[<identifiant-const1> ={<entier>
|<réel>| <chaine_litterale> | <constante_enumeration> |<cst_expr>}
Cette commande affecte donc
un nom à une case mémoire pour permettre sa manipulation et affecte une valeur
à cette donnée. Valeur qui ne devrait pas bouger tout au long du programme.
Exemple de constantes:
CONSTANTES
TVA = 19,6
IS
= 33,3
MAXI
= 32
PROF
= "lauden"
èAttention :
pour
faire la différence entre un nombre et des chaînes de caractères, il faut
mettre les chaînes de caractères entre doubles quotes.
Exemple
:
"lauden"
10
est différent de "10"
dans
le premier cas on peut l’utiliser dans des calculs et dans le second cas cela
est impossible.
EN
PLUS :
Les
tableaux de constantes sont possibles dans beaucoup de langages ou énumération
avec les fonction ORD, PRED , SUCC .
Exemple :
Déclaration
Tabconst = (" eleve" , " maitre" , " intituteur","professeur")
Utilisation
X <- tabconst(1)
Nous pouvons chaque fois que
possible utiliser des constantes techniques pour éviter de faire des tests avec
le nombre maximum demandé par
l'utilisateur : nous pouvons
ainsi pour les tests mettre un nombre réduit puis mettre la valeur réelle
ensuite avant de donner le
programme définitif à
l'utilisateur.
1.1.5.3 : Les
opérateurs
1.1.5.3.1 : arithmétiques
+
addition
-
soustraction
*
multiplication
/
division flottante
div
division entiere
Result ç 10 DIV 3
Result = 3
mod
reste de la division entiere
Reste ç
10 MOD 3
Reste = 1
1.1.5.3.2 : relationnels
=
égal
<>
différent
<
inférieur
>
supérieur
<=
inférieur égal
>=
supérieur égal
1.1.5.3.3 : logiques
ET
et logique
OU
ou logique
NON non
logique
OUE ou
exclusif
1.1.5.3.4 : Priorité des opérateurs
Par
ordre décroissant :
Priorité
Opérateur(s)
1
non
2
et
3
ou oue
4
= <> < > <= >=
retour
