Site A.T.L.A.N.T.I.C-83
COURS = Algorithmique (Chapitre_2a) - VERSION: 1.0 (M.A.J: 14/04/09)
- AUTEUR(s): Bernard GIACOMONI
Ecran large mobile
Retour
sommaire cours

II.CONVENTIONS D'ECRITURE DU PSEUDO-CODE:


II.1.FORME GENERALE D'UN ALGORITHME:


II.1.1.PRESENTATION GENERALE:


Nous avons vu au chapitre précédent que, pour des raisons de lisibilité et de compréhension, le texte d'un algorithme ne doit occuper qu'une seule page.


II.1.2.LE CORPS DE L'ALGORITHME:

  • Il est très conseillé d'encadrer le corps d'un algorithme (instructions et déclaration de données) par les termes conventionnels DEBUT et FIN (éventuellement suivis du nom donné à l'algorithme).
  • Dans le corps de l'algorithme, la déclaration des données doit être séparée de la liste des instruction et doit la précéder.
  • Lorsqu'une instruction est rédigée en texte libre, il est conseillé de la placer entre deux signes délimiteurs (par exemple < et >). Ceci permet de les distinguer des lignes contenant des instructions respectant une convention d'écriture.
  • Enfin, il est conseillé de recourir à l'indentation pour bien distinguer les niveaux d'écriture.

II.1.3.LES COMMENTAIRES:

  • On distingue un commentaire par le signe // en début de texte.
  • Il est conseillé de faire précéder le corps de l'algorithme (la partie entre DEBUT et FIN) par un commentaire en-tête explicitant au moins la fonction de l'algorithme, les données consommées, les données produites(pourront également figurer l'identification du projet dans le cadre duquel cet algorithme est utilisé, le nom de son rédacteur, la date de rédaction ou de modification, et tout renseignement facilitant l'identification ou la modification de cet algorithme).
  • Des commentaires (ne pas confondre avec les instructions écrites en texte libre) peuvent également être insérés dans le corps de l'algorithme. Cependant, il ne faut pas en abuser, car un algorithme doit être compréhensible par lui-même (c'est tout de même sa principale utilité!).


II.1.4.EXEMPLE DE PRESENTATION:

Exemple de présentation d'un algorithme

II.2.MANIPULATION DES DONNEES:


II.2.1.DEFINITIONS:


En algorithmique, on appelle DONNEE toute information connue ou hypothétique, susceptible d'agir sur le déroulement ou le résultat d'un algorithme (à l'exclusion des opérations qu'il renferme).
Une DONNEES SIMPLE se différencie d'une DONNEES COMPOSEE par le fait qu'elle ne peut être décomposée en plusieurs autres données.

EXEMPLES:
- Un nombre est une donnée simple.
- Un jeu de coordonnées cartésiennes est une donnée composée
- Une chaîne de caractères est une données composée (de plusieurs caractères).
- L'identité d'une personne est une donnée composée (du nom et des prénoms).
- Une liste d'adhèrents est une donnée composée (de plusieurs identités d'adhérents).

REMARQUE:
Les composants d'une donnée composée peuvent eux-mêmes être des données composées (par exemple, chaque composant d'une liste de coordonnées cartésiennes est une donnée composée de trois nombres).


DECLARER une donnée, c'est lui donner un NOM (on dit aussi une ETIQUETTE) et définir son TYPE.


REMARQUE: La déclaration peut s'accompagner de la fixation de la VALEUR de la donnée, mais cette opération ne fait pas partie de la déclaration proprement dite.


Par convention, le nom d'une donnée ne commence jamais par un chiffre et ne comporte aucun des caractères spéciaux pouvant créer une confusion avec d'autres éléments du langage:
  • Opérateurs arithmétiques et logiques:espace, guillemets, <, >, (, ), +, -, *, /, %, ^, =, ., ;, !, &, |, [, ], etc...En fait, il est recommandé de se limiter aux lettres, aux chiffres décimaux et au caractère _ (underscore).
  • Mots clefs: Var, const, SI, ALORS, SINON, FINSI, SUIVANT, LE, CAS, FINCAS, POUR, TANT, QUE, FAIRE, FINFAIRE, ENTRER, SORTIR, PROCEDURE, FONCTION, RETOUR, ET, OU, NON, XOR, TRUE, FALSE, true, false, VRAI, FAUX, vrai, faux, etc...


Le TYPE caractérise la nature de la donnée. En algorithmique, les types suivants font l'objet d'une convention d'écriture:


Nom conventionnel Signification
Numerique Nombres entiers ou fractionnaires: 15, -30, 0.56789, -456.678 ....etc. Notez l'emploi du point à la place de la virgule, dans les nombres fractionnaires
Booléen Valeur d'une assertion (VRAI ou FAUX). Résultat d'une condition logique. Exemple: la valeur de la condition: A>6 est: VRAI pour A =7 et FAUX pour A=6). Les valeurs admises sont VRAI, FAUX, TRUE, FALSE, vrai, faux, true, false.
Caractère Caractère de typographie (lettres, chiffres, ponctuation, espaces, etc....On les note entre deux «quotes» (ex: 'A' est le caractère A)
Chaine de caractères Texte, formé de plusieurs caractères. On les note entre guillemets: '' ceci est une chaîne de caractères ''


REMARQUE:

En algorithmique, rien n'empêche de créer d'autres types (ex: type Monétaire, type Entier, type Date, type couleur, etc...). Il suffira de bien les définir. Il n'existe pas à proprement parler de convention pour définir de nouveaux types. On pourra les définir dans la section «déclaration des données» au moyen d'un commentaire.


Par exemple:


  • Le type Couleur est l'ensemble des couleurs: {violet, indigo, bleu, vert, jaune, oranger, rouge}
  • Le type EntierPositif est l'ensemble des nombres entiers plus grands que zéro


II.2.2.LES CONSTANTES:


II.2.2.1.DEFINITION:


Une CONSTANTE est une donnée dont la valeur ne peut pas varier au cours de l'exécution d'un algorithme.


II.2.2.2.DECLARATION:


Une constante peut apparaître directement sous forme de sa valeur. Par exemple:
3,14159, 'A', "Chaine de caractères".

On peut également la déclarer, c'est à dire lui attribuer un nom et une valeur, au moyen de l'opérateur «const». La syntaxe est:
const <etiquette> = <valeur de la constante>


Le type d'une constante est implicitement défini par la valeur qui lui est affectée.


EXEMPLE:
«const PI = 3,14159» définit la constante PI comme étant égale à 3,14159. Par la suite, on pourra utiliser l'étiquette PI à la place de l'écriture de la constant correspondante.


II.2.3.LES VARIABLES SIMPLES:


II.2.3.1.DEFINITION:


Une VARIABLE est un CONTENEUR de données dont le contenu peut être modifié au cours de l'exécution de l'algorithme.
Une VARIABLE est dite SIMPLE lorsque elle ne peut contenir qu'une donnée simple.


II.2.3.2.DECLARATION:


Déclarer une variable revient à lui attribuer une étiquette(ou nom) et un type. La syntaxe conventionnelle d'une déclaration est la suivante:


Déclaration d'une seule variable):


Var <Etiquette de variable> en <Nom de type>


Déclarations multiples (une liste de variables):

Var <Etiquette_1>, <Etiquette_2>, .......... , <Etiquette_n> en <Nom de type>


EXEMPLES: Var Nom en Chaîne de caractères
Var Char en Caractères
Var Reponse en Booleen
Var Pression, AnciennePression en Numerique


II.2.3.3.AFFECTATION D'UNE VARIABLE SIMPLE:


Affecter un contenu à une variable, c'est charger la valeur de ce contenu dans le conteneur que constitue cette variable. L'affectation est indiquée par l'opérateur ←:

<Etiquette de variable> ← <Valeur à transférer dans la variable>

Signifie: le contenu de la variable correspondant à l'étiquette est chargé avec la valeur de l'expression libellée à droite (il faut donc à priori que le type de la valeur de l'expression soit compatible avec le type de la variable).


EXEMPLES:
Pression 24 // charge la valeur 24 dans la variable Pression.
Char 'B' // charge le caractère 'B' dans la variable Char.
Pression AnciennePression // Charge dans Pression la valeur de la variable AnciennePression
Prenom ''Arthur'' // charge la chaîne ''Arthur'' dans la variable // Prenom.
Surface PI*R^2 // Charge dans Surface la valeur de l'expression // numérique PI.R2


REMARQUE:

Dans la presque totalité des langages de programmation, l'affectation est indiquée par l'opérateur = qui est beaucoup plus facile à écrire sur un clavier. De ce fait, on utilise parfois le signe = dans des pseudo-codes, à la place de la flèche inversée.
Cependant, il faut remarquer que l'affectation en algorithmique (et en programmation) n'a pas grand chose à voir avec l'égalité algébrique que l'on peut trouver dans une équation: en effet, elle n'indique pas que les termes de gauche et de droite doivent être toujours égaux. Elle indique seulement que la valeur du terme de droite est transférée dans le terme de gauche. Avant le transfert, les valeurs peuvent être différentes, après le transfert, les valeurs restent égales jusqu'à ce qu'un des deux termes soient modifiés par l'exécution.
La flèche inversée traduit donc plus intuitivement le fonctionnement de l'affectation, le signe = traduisant plutôt une condition imposée aux deux termes. Dans les pseudo-codes et langages utilisant le signe = pour l'affectation, la condition d'égalitée est marquée par le signe ==.


II.2.4.VARIABLES COMPOSEES:


II.2.4.1.TABLEAUX DE VARIABLES MONODIMENSIONNELS:


DEFINITION:


Un tableau monodimensionnel est constitué d'une suite de variables de même type. Chacune de ces variables est appelée «élément» du tableau.


SCHÉMA GÉNÉRAL DE LA DÉCLARATION:


Tableau <nom du tableau> ( <dimension> ) en <type des éléments>

<nom du tableau> est l'étiquette attribuée au tableau
<dimension> est le nombre d'éléments -1 que contient ce tableau
<type des éléments> est le type commun à tous les éléments.


EXEMPLES:

Tableau T1 (9) en numérique // Déclare une liste de 9+1 = 10 variables // numériques
Tableau T2 (7) en alphanumerique // Déclare une liste de 7+1 = 8 chaines de // caractères


ACCES À UN ÉLÉMENT DU TABLEAU:


Si le rang d'un élément dans la liste est le nombre entier positif r, l'indice d'un élément de la liste est le nombre i = r-1. Le premier élément a donc l'indice 0. On accède à la valeur de chaque élément grâce à la valeur de son indice:


<Valeur de l'élément de rang r> = <Etiquette> ( <indice de l'élément> )

avec: <indice de l'élément> = r-1


REMARQUE: L'indice de l'élément est placé entre parenthèses, alors que dans la plupart des langages de programmation, on utilise les crochets [ et ].


EXEMPLES: soit la déclaration: Tableau T1 (9) en numérique // Tableau de 10 éléments indicés de 0 à 9

T1 (0) désigne le premier élément du tableau T1
T1 (5) désigne le sixième élément du tableau T1
T1 (12-3) désigne le dernier élément du tableau T1


II.2.4.2.TABLEAUX A UNE DIMENSION DYNAMIQUES:


Certains pseudo-codes acceptent qu'un tableau ne soit pas dimensionné lors de sa déclaration. On peut par exemple se contenter de:


Tableau T1 () en numérique


Dans ce cas, avant d'utiliser le tableau, il faut préciser sa dimension avec une instruction:

Redim <nom de tableau> <dimension-1>


EXEMPLE:

Tableau T1()
............
............
Redim T1 14 // Va dimensionner le tableau à 15 elements


II.2.4.3.TABLEAUX DE VARIABLES MULTIDIMENSIONNEL:


DEFINITION:

Un tableau de variables multidimensionnel est un tableau dont tous les éléments sont eux-même des tableaux (c'est un «tableau de tableaux», voire un «tableau de tableaux de tableaux de ...... de tableaux.


STRUCTURE D'UN TABLEAU MULTIDIMENSIONNEL:

Un tableau multidimensionnel peut se représenter sous la forme d'une arborescence dans laquelle:
  • La racine représente le tableau lui-même
  • Les noeuds de premier niveau représentents les éléments de ce tableau (les sous-tableaux)
  • Les noeuds du deuxième niveau représentent les éléments des sous-tableaux (les "sous-sous tableaux")
  • Les noeuds du troisième niveau représentent les éléments des sous-sous-tableaux (les "sous-sous-sous tableaux")
  • etc... jusqu'à ce qu'on arrive à des éléments variables simples:

EXEMPLE:
Le schéma ci-dessous représente la décomposition arborescente d'un tableau. Si l'on suppose que les éléments de la rangée inférieure sont des variables simples et non des tableaux, il s'agit d'un tableau à trois dimensions.



MECANISME D'INDEXATION DES ELEMENTS:


En nous aidant du schéma ci-dessus, explicitons le mécanisme d'indexation des éléments et sous-éléments:


INDEXATION DES ELEMENTS DE PREMIER NIVEAU:


Ils constituent les éléments T(0), T(1), ...., T(i), ..., T(m) du tableau T de m+1 éléments.


INDEXATION DES ELEMENTS DE DEUXIEME NIVEAU:


Si T possède au moins deux dimensions, les éléments du premier niveau sont eux-même des tableaux constitués de n+1 éléments. Considérons un de ces sous-tableaux, par exemple T(i): pour repérer les éléments de T(i), on utilisera deux indices: l'indice i, plus un deuxième indice, variant de 0 à n. Les éléments de T(i) seront alors repérés par T(i,0), T(i,1), ...,T(i,j),...., T(i,n).


De même:

  • Les éléments du tableau T(1) seront repérés par T(1,0), T(1,1), ...,T(1,j) ,...., T(1,n).
  • les éléments du tableau T(2) seront repérés par T(2,0), T(2,1), ...,T(2,j) ,...., T(2,n).
  • les éléments du tableau T(m) seront repérés par T(m,0), T(m,1), ...,T(m,j) ,...., T(m,n).
Si T possède deux dimensions, ces éléments seront des variables simples, sinon, ils seront eux-mêmes des tableaux.


INDEXATION DES ELEMENTS DE TROISIEME NIVEAU:


Si T possède au moins trois dimensions, les éléments T(i,j) composant le deuxième niveau seront des tableaux de p+1 éléments. Pour repérer les éléments de ces tableaux, on utilise trois indices: par exemple, les éléments du tableau T(i,j) seront repérés par : T(i,j,0), T(i,j,1), ...,T(i,j,k),...., T(i,j,n).


De même:

  • les éléments du tableau T(i,1) seront repérés par T(i,1,0), T(i,1,1), ...,T(i,1,j),...., T(i,1,p).
  • les éléments du tableau T(2,j) seront repérés par T(2,j,0), T(2,j,1), ...,T(2,j,j),...., T(2,j,p).
  • les éléments du tableau T(3,5) seront repérés par T(3,5,0), T(3,5,1), ...,T(3,5,j),...., T(3,5,p).
Si T possède trois dimensions, ces éléments seront des variables simples, sinon, ils seront eux-mêmes des tableaux.


INDEXATION DES NIVEAUX SUIVANTS:
De proche en proche, on peut ainsi construire des tableaux à dimensions multiples, par décomposition des éléments en tableaux. A chaque niveau correspond un indice supplémentaire.


DECLARATION D'UN TABLEAU MULTIDIMENSIONNEL:


La déclaration d'un tableau multidimensionnel obeït au schéma suivant:


Tableau <nom tableau> ( <dim 1>, <dim 2>,....,<dim n>) en <type des éléments>
avec: <dim 1>, <dim 2>, ..., <dim n> représentent les dimensions des tableaux de chaque niveau d'indexation.


EXEMPLE:
Tableau T ( m, n, p ) en numerique
est la déclaration d'un tableau à trois dimensions contenant des nombres.


ACCES A UN ELEMENT D'UN TABLEAU MULTIDIMENSIONNEL:


On accède à un élément par la suite des valeurs d'index qui permettent de le sélectionner dans l'arborescence que constitue le tableau:


  • T ( 2, 7, 5) permet d'atteindre la valeur du 5éme élément du 7éme élément du 2éme élément du tableau T
  • T ( i, 7, 4 ) permet d'atteindre la valeur du 4éme élément du 7éme élément du iéme élément du tableau T
  • T( i, j, k ) permet d'atteindre la valeur du kéme élément du jéme élément du iéme élément du tableau T


EXEMPLE: TABLEAU A DEUX DIMENSIONS:


SCHEMA DE DECLARATION:

Tableau <nom du tableau> ( <dim1>, <dim2> ) en <type des éléments>


Ceci veut dire que Tableau est constitué de dim1+1 éléments et que ces éléments sont eux-mêmes des tableaux de dim2 éléments.


EXEMPLE: Tableau T (4, 3) en numerique déclare un tableau de 5 tableaux de 4 variables numériques.


1er élément de T1 -> T(0,0) T(0,1) T(0,2) T(0,3)
2em élément de T1 -> T(1,0) T(1,1) T(1,2) T(1,3)
3em élément de T1 -> T(2,0) T(2,1) T(2,2) T(2,3)
4em élément de T1 -> T(3,0) T(3,1) T(3,2) T(3,3)
5em élément de T1 -> T(4,0) T(4,1) T(4,2) T(4,3)


On voit ici que T est constitué de tableaux d'éléments (ce sont les lignes) et que chaque ligne constitue elle-même un tableau de 4 éléments .


REMARQUES:
- La ligne colorée représente les éléments du tableau T[1].
- Le 3eme élément de la 2 eme ligne sera T(1, 2).


II.2.4.4.STRUCTURES DE DONNEES:


DEFINITION:


Un type de donnée structuré ou STRUCTURE est constituée d'un ensemble de données rassemblées et organisées.


DÉCLARATION D'UN TYPE STRUCTURE:


Elle correspond au schéma suivant.


Structure < Nom de structure ><Déclaration de variable>
<Déclaration de variable>
...........................................
...........................................
...........................................
<Déclaration de variable>
FinStructure

<Déclaration de variable> peut être n'importe quelle déclaration de donnée simple ou composée, y compris une déclaration de structure.


En fait, une structure décrit un nouveau type de variable complexe, créé par agglomération de types existants: la définition d'une structure crée un nouveau type de données.


EXEMPLE:
Structure typeIdentite
var Nom en chaîne de caractères
var Prenom en chaîne de caractères
FinStructure


DÉCLARATION D'UNE VARIABLE STRUCTURÉE:


Le schéma d'une déclaration est le suivant:


var<Nom de variable>en<Nom de structure>

EXEMPLE: Identite en typeIdentité


REMARQUE:

Bien faire la différence entre TypeIdentité, qui n'est pas une variable, mais uniquement un type de variable (comme numerique, chaîne de caractère, etc...) et Identité, qui, une fois déclaré qui est une variable, c'est à dire un conteneur dans lequel on peut charger des valeurs.


ARBORESCENCE ET STRUCTURE:


L'exemple suivant montre qu'une structure peut être décrite sous une forme arborescente:


Soient les déclarations suivantes:
Structure typeIdentite
var Nom en chaîne de caractères
var Prenom en chaîne de caractères
FinStructure


Structure typeElève
var Identite en typeIdentité
Tableau Notes(10) en numerique
var Moyenne en numerique
FinStructure


Dans cet exemple, on définit d'abord un type structuré appelé typeIdentité, constitué des éléments Nom et Prenom. Puis, on définit un deuxième type structuré, typeEleve. Ce type est constitué:

  • D'une structure (structure Identité, de type TypeIdentité)
  • D'un tableau de dimension 10 (Notes)
  • D'une variable simple (Moyenne)


En définitive, la structure TypeEleve pourra être représentée par l'arborescence suivante:



La déclaration:

Structure Eleve en typeEleve


crée en fait un conteneur de données nommé Eleve qui est une variable composée dont la structure est celle de typeEleve. Dans cette variable, on trouvera au premier niveau les éléments Identite, Notes et Moyenne est à un deuxième niveau, les éléments Nom, Prenom qui composent la structure Identité et les éléments Notes[0], Notes[1],....., Notes[10] qui composent le tableau Notes.


REMARQUE:

Il existe donc une analogie entre une structure et un tableau: en fait, un tableau est un cas particulier de structure: une structure composée uniquement de tableaux.


ACCÈS À UN ÉLÉMENT D'UNE DONNÉE STRUCTURÉE:


La représentation d'une structure sous forme arborescente permet de justifier la syntaxe d'accès à un élément d'une structure. La syntaxe est la suivante:

<Nom de la variable structure>.<noeud niveau 1>---.<noeud niveau i>---.<noeud auquel on veut accéder>


On représente donc le cheminement qui permet de rejoindre l'élément auquel on veut accéder, à partir de la racine de l'arborescence. Les noeuds de l'arborescence sont les éléments et sous éléments composant la structure. Les niveaux successifs de l'arborescence sont représentés par des points (.):


EXEMPLE:
Accès à la donnée Moyenne: Eleve.Moyenne
Accès au prénom: Eleve.Identité.Prenom
Accès à la quatrième note du tableau Notes: Eleve.Note(3)
Accès au tableau Notes tout entier: Eleves.Notes



II.2.4.5.TABLEAUX DE STRUCTURES


DEFINITION:


Un tableau de structures est un tableau dont les éléments terminaux sont des structures.


DECLARATION:


Une fois déclaré, un type structuré est un type comme les autres. Il est donc possible de déclarer des tableaux de structures de données:


EXEMPLE:
On a défini précédemment la structure typeEleve. On peut définir un tableau de ces structures qui représentera l'effectif d'une classe de 30 élèves:


Tableau Eleves (30) en typeEleve.


ACCES A UN ELEMENT TERMINAL:


La différence avec une structure simple est que le noeud racine est un tableau:


<Nom de la variable tableau de structures> (<valeur indice>).<noeud de niveau 1>---.<noeud de niveau i>---.<noeud auquel on veut accéder>


L'indice étant celui de l'élément du tableau de structures qui conduit au noeud de niveau 1.


EXEMPLES:

On atteindra la 3eme note du 15 eme élève de la façon suivante:
NoteCherchee ← Eleve(14).Note(2)

On atteindra le nom du troisième élève de la façon suivante:
Nom ← Eleve(2).Identite.Nom

On atteindra la moyenne du trentième élève de la façon suivante:
Nom ← Eleve(29).Moyenne


II.3.LES OPERATIONS D'ENTREE-SORTIE:


II.3.1.DEFINITIONS:


Les opérations d'entrée-sortie représentent les échanges de données entre le processeur et sa périphérie.


Dans le domaine du génie logiciel, ces échanges concernent des informations. Une source de données pouvant fournir des informations se nomme « périphérique d'entrée». Une source de données pouvant accepter des informations se nomme «périphérique de sortie»


II.3.2.ACQUISITION D'INFORMATIONS PAR L'EXECUTANT:


II.3.2.1.SYNTAXE:


L'acquisition d'une information en provenance d'un périphérique s'effectue grâce à l'instruction ENTRER (INPUT dans les langages informatiques). Sa syntaxe est la suivante:


ENTRER <Liste d'étiquettes de variables>

EXEMPLE:
var Texte en chaîne de caractères
var Nombre en numerique
.................................
ENTRER Texte, Nombre



II.3.2.2.FONCTIONNEMENT:


L'instruction ENTRER affecte aux variables dont les étiquettes figurent dans la liste les valeurs qui lui sont fournies par le périphérique, dans l'ordre déterminé par cette liste. types de chacune de ces variables doivent être compatibles avec les valeurs qui leur sont affectées.


REMARQUE: identification du périphérique.

Dans un langage informatique, il faudrait ajouter à cette instruction un argument permettant d'identifier le périphérique concerné. En algorithmique, cela n'est pas forcément nécessaire à la compréhension de la procédure. En cas de besoin, on peut toujour utiliser un commentaire:


EXEMPLES:

Saisie d'un texte depuis le clavier d'un ordinateur:

var Texte en chaîne de caractères
---------------------
ENTRER Texte // DEPUIS le clavier

Saisie de la position de la souris sur l'écran:
var X, Y en numerique
---------------------
ENTRER X, Y // DEPUIS le gestionnaire de souris

Saisie d'une mesure envoyee par un capteur:

Structure Message
{
var Temperature en numerique
var DirectionVent en Numerique
var VitesseVent en Numerique
}
------------------------
ENTRER Message //DEPUIS la station de météorologie


II.3.3.ENVOI D'INFORMATIONS A UN PERIPHERIQUE:


II.3.3.1.SYNTAXE:


L'envoi d'informations vers un périphérique s'effectue grâce à l'instruction SORTIR (OUTPUT dans les langages informatiques). Sa syntaxe est la suivante:


SORTIR <Liste d'étiquettes de variables>


EXEMPLE:

var Texte en chaîne de caractères
var Nombre en numerique
.................................
SORTIR Texte, Nombre


II.3.3.2.FONCTIONNEMENT:


L'instruction SORTIR transmet au périphérique concerné les valeurs des variables dont les étiquettes figurent dans la liste, dans l'ordre déterminé par cette liste. Les types de chacune de ces variables doivent être compatibles avec les valeurs attendues par le périphérique.


REMARQUE: identification du périphérique.


Même remarque que pour l'instruction ENTRER.


EXEMPLES:

Envoi d'un texte vers une imprimante:

var Texte en chaîne de caractères
.................................
SORTIR Texte //VERS l'imprimante


Positionner le curseur sur l'écran à 230 pixels vers la droite et 320 pixels vers le bas par rapport à l'angle haut, gauche:

var X, Y en numerique
.................................
X ← 230 // Pixels
Y ← 320 // Pixels
SORTIR X, Y // VERS le gestionnaire du curseur d'écran


II.3.4.LE PROBLEME DE LA SYNCHRONISATION:


En algorithmique, on considére qu'une instruction ENTRER aura toujours pour effet l'acquisition des informations spécifiées par le processeur. De même, on considère qu'une instruction SORTIR pourra toujours transmettre les informations spécifiées au périphérique concerné. Ce faisant, on néglige complètement l'aspect temporel du mécanisme:


II.3.4.1.SYNCHRONISATION EN ENTREE:


Pour qu'un processeur puisse acquérir des informations en provenance d'un périphérique, il faut qu'au moment ou il exécute son instruction ENTRER, ces informations soient disponibles. Ceci implique:
  • Soit que l'exécution de l'instruction ENTRER par le processeur et la transmission des informations par le périphérique soient SYNCHRONES (c'est à dire se produisent au même moment). En pratique, une entrée synchrone nécessite un mécanisme logiciel de synchronisation, basé sur la gestion d'événements.
  • Si l'exécution de l'instruction ENTRER par le processeur est ASYNCHRONE de la transmission des informations par le périphérique, il faut qu'avant l'exécution de l'instruction ENTRER, le périphérique ait mis les informations à disposition du processeur dans un conteneur de stockage. C'est dans ce conteneur (extérieur à l'exécutant) que l'instruction ENTRER prend les informations. On dit alors que l'entrée est «bufferisée» (l'anglais, «buffer» est équivalent au mot «tampon» en Français: il faut donc comprendre ce terme dans le sens «mémoire tampon» permettant de stocker provisoirement une information, dans l'attente de son utilisation).


SCHEMA DE DEROULEMENT D'UNE ENTREE ASYNCHRONE BUFFERISEE:



II.3.4.2.SYNCHRONISATION EN SORTIE:


Pour qu'un périphérique puisse acquérir des informations en provenance d'un processeur, il faut qu'au moment ou celui-ci exécute son instruction SORTIR:
  • Ou bien le périphérique soit prèt à exploiter l'information (prèt à imprimer, prèt à afficher, etc).
  • Ou bien le périphérique possède les moyens de stocker (bufferiser) cette information en vue d'une exploitation différée.


II.3.4.3.CONCLUSION:


Dans un système informatique, le processeur et le périphérique peuvent échanger des signaux de synchronisation (par exemple, signaux «prèt à émettre» ou «prèt à recevoir» émis par le périphérique vers le processeur.
De plus , les langages de programmation offrent toute une gamme d'instructions de synchronisation:
  • Les instructions d'entrée-sortie possèdent des paramètres qui définissent leur comportement. Par exemple, une entrée peut être déclarée «blocante»: dans ce cas, le processeur va attendre, pour exécuter cette entrée, que le périphérique lui ait signalé qu'il était prèt àdélivrer un message.
  • Toute une gamme d'instructions permettent la synchronisation des traitements sur les événements extérieurs (attente d'événements, gestionnaires de signaux, etc.).
En algorithmique, les contraintes de synchronisation liées aux opérations d'entrée-sortie ne sont, en général, pas prises en compte. On doit donc considérer que ces instructions sont toujours exécutées avec succès. Dans les cas où cette hypothése semble trop simplificatrice, il pourra être utile d'ajouter àl'algorithmes des mécanismes décrivant la synchronisation nécessaire. Le cas est traité dans les annexes (ANNEXE I: Parallélisme et gestion d'événements).


Retour accès aux cours Retour sommaire cours