Repository navigation
Pseudocode 23 fr
Il s'agit de la toute première révision de la norme Pseudocode. Santé !
Durée d'effet : année universitaire 2023 – 2024
N'utilisez ces informations que pour le bien, jamais pour le mal. Ne les exposez pas au feu. N'utilisez pas d'équipement lourd après les avoir lues, cela peut provoquer une somnolence. Ne lisez pas sous l'influence de l'alcool (bien que plusieurs rapports non confirmés indiquent que l'alcool améliore réellement la lisibilité). (...) Si vous avez du mal à comprendre une section particulière, relisez-la encore et encore et encore… Tenez-vous droit. Mangez vos légumes. Ne marmonnez pas. Norme Pascal (ISO 7185:1990, traduit de l'anglais)
- Table des matières
- Règles d'orthographe
- Espaces blancs
- Identifiants
- Programme
- Commentaires
- Directives du compilateur
- Types
- Déclarations
- Instructions
- Expressions
- Paramètres
Le Pseudocode est sensible à la casse. Les accents et les diacritiques sont significatifs, sauf dans les mots réservés (mots-clés et builtins). Cela signifie que la fonction intégrée écrireÉcran peut être orthographiée écrireEcran ou ecrireEcran, mais pas écrireécran.
Les espaces blancs sont considérés comme insignifiants. Cela signifie que les espaces supplémentaires, les tabulations et les sauts de ligne (ou tout autre caractère d'espacement Unicode) n'affectent pas la signification du code.
Par exemple, les instructions suivantes sont équivalentes :
x : entier ;et
x :
entier
;Les identifiants sont définis par l'expression régulière PCRE2 suivante : [\p{L}_][\p{L}_0-9]*
Explication : un identifiant se compose d'une ou plusieurs lettres Unicode, d'un trait de soulignement ou de chiffres. Le premier caractère ne peut pas être un chiffre.
programme ⟨nom⟩ c'estLe programme est la construction la plus fondamentale, car il est présent dans tout fichier Pseudocode.
⟨nom⟩ est un identifiant indiquant le nom du programme.
Le programme commence après le c'est et continue jusqu'à la fin du fichier.
Les commentaires sont utilisés pour documenter le code et le rendre plus lisible. Il existe deux types de commentaires : sur une seule ligne et sur plusieurs lignes.
Les commentaires n'affectent pas la signification du programme, mais ils séparent les jetons, agissant effectivement comme des espaces.
Les commentaires sur une seule ligne commencent par // et continuent jusqu'à la fin de la ligne.
// Ceci est un commentaire sur une seule ligneLes commentaires sur plusieurs lignes commencent par /* et se terminent par */. Ils peuvent s'étendre sur plusieurs lignes.
/* Ceci est un multiligne
clown comment
*/Les directives de compilateur sont des instructions spéciales exécutées au moment de la compilation.
#assert ⟨expr⟩ ⟨message⟩Assertion statique. Si ⟨expr⟩ est faux, le programme est arrêté et ⟨message⟩ est affiché. ⟨expr⟩ doit être implicitement convertible vers le type booléen. ⟨message⟩ est facultatif et doit être implicitement convertible vers le type chaîne.
#assert faux
#assert 1 == 1 "Ceci ne devrait jamais échouer"#eval expr ⟨expr⟩Affiche la valeur et le type d'une expression connue au moment de la compilation.
#eval expr 1 + 1 // Affiche "entier: 2"#eval type ⟨type⟩Affiche les informations d'un type.
#eval type entier // Affiche "entier"Les types définissent le type de données qu'une variable peut contenir.
Les types primitifs sont les types les plus basiques. Ils sont utilisés pour représenter des valeurs simples, telles que les scalaires, des valeurs de vérité et les chaînes.
Le type entier représente des entiers.
Le type réel représente des nombres réels.
Le type booléen représente des valeurs booléennes. Les valeurs de véritées sont exprimées avec les mot-clés vrai et faux.
Le type caractère représente des caractères. L'encodage est défini par le langage cible.
Le type chaîne représente des chaînes de longueur connue à l'exécution.
Le type chaîne(N) représente des chaînes de longueur connue à la compilation. N définit la longueur maximale de la chaîne. L'encodage est défini par le langage cible.
tableau[⟨longueur⟩] de ⟨type-element⟩Les tableaux sont utilisés pour représenter des collections de valeurs de même type.
Les tableaux commencent à l'indice 1.
- ⟨longueur⟩ est une expression unique ou une liste d'expressions séparées par des virgules qui s'évaluent au moment de la compilation à une valeur
entier. Elles définissent la longueur de chaque dimension du tableau. - ⟨type-element⟩ est le type des éléments du tableau.
La syntaxe des tableaux multidimensionnels n'est qu'un raccourci pour des tableaux de tableaux.
tableau[1, 2] de entierEst un raccourci pour :
tableau[1] de tableau[2] de entierstructure début
⟨composant⟩ : ⟨type⟩;
// …
finLes structures sont des types de données définis par l'utilisateur qui regroupent différents types de variables sous un seul nom. Cela est particulièrement utile pour gérer ensemble des données liées. Les structures implémentent les types en produit.
Le contenu d'une structure consiste en une liste de déclarations de variables.
Exemples (utilisant les alias de types) :
type t_personne = structure début
nom, prenom : chaîne(50);
age : entier;
fin;
type t_classe = structure début
libelle : chaîne(20);
eleves : tableau[35] de t_personne;
fin;Les déclarations divisent le programme en parties nommées et réutilisables.
début
// instructions…
finLe programme principal est le point d'entrée du programme.
Il doit y avoir exactement un programme principal.
constante ⟨type⟩ ⟨nom⟩ := ⟨valeur⟩;Les constantes désignent des valeurs connues au moment de la compilation.
⟨valeur⟩ est une expression connue au moment de la compilation ou un initialiseur.
constante réel PI := 3.14159;Les initialiseurs initialisent les variables ou les constantes de types composés (tableau ou structure).
Ils suivent principalement la syntaxe et les règles d'initialisation entre accolades du C.
constant tableau[10] de entier A = { 1,2,3,4,5,6,7,8,9,10 };
constante structure début
x: entier;
c: tableau [4] de caractère;
fin B := {
1
};procédure ⟨nom⟩(⟨paramètres-formels⟩) c'est début
// instructions…
finLes procédures regroupent et réutilisent des instructions qui exécutent une tâche spécifique.
Elles peuvent avoir zéro ou plusieurs paramètres formels.
procédure sayHello(entF name : chaîne) c'est début
écrireÉcran("Hello ", name);
finfonction ⟨nom⟩(⟨paramètres-formels⟩) délivre ⟨type⟩ c'est début
// instructions…
retourne ⟨valeur⟩;
finLes fonctions regroupent et réutilisent des instructions qui exécutent une tâche spécifique et renvoient une valeur.
Comme les procédures, les fonctions peuvent avoir zéro ou plusieurs paramètres formels.
fonction add(entF a : entier, entF b : entier) délivre entier c'est début
retourne a + b;
finLes prototypes pré-déclarent des fonctions et des procédures définies ailleurs. La syntaxe rappelle celle du C, avec la signature suivie d'un point-virgule. Exemple :
procédure sayHello(entF name : chaîne);
fonction add(entF a : entier, entF b : entier) délivre entier;Contrairement au C, les noms de paramètres ne peuvent pas être omis.
Une fonction/procédure donnée peut être prototypée plusieurs fois, à condition que toutes les signatures soient identiques.
type ⟨nom⟩ = ⟨type⟩;Les alias de type dénomment un nouveau type, afin d'ajouter un niveau d'abstraction et d'améliorer la sémantique du code.
Exemple :
type t_pid = entier;
// Maintenant t_pid est un alias pour entierLes alias de type sont couramment utilisés pour définir des types de tableau/structure complexes car ils évitent de répéter le type. Exemple :
type t_personne = structure début
nom : chaîne(50);
prenom : chaîne(50);
age : entier;
fin;
type t_fileAttente = tableau[50] de t_personne;Les instructions sont les éléments de base d'un programme. Elles sont utilisées pour contrôler le flux d'exécution, effectuer des opérations et prendre des décisions.
L'instruction no-op ne fait rien. Elle se compose d'un seul point-virgule ;.
Les builtins sont des sous-routines fournies par le compilateur.
Builtins liés à entrée/sortie.
écrireÉcran(⟨arg1⟩, ⟨arg2⟩, …);Le builtin variadique écrireÉcran affiche les arguments donnés sur la sortie standard, suivis d'un saut de ligne. Tous les types ne sont pas pris en charge, selon le langage cible.
Il peut également prendre zéro argument, auquel cas il affiche simplement un saut de ligne.
lireClavier(⟨variable⟩);Le builtin lireClavier lit une valeur depuis l'entrée standard et l'affecte à la variable donnée. Tous les types ne sont pas pris en charge, selon le langage cible.
assigner(⟨nomLog⟩, ⟨nomExt⟩);La procédure builtin assigner assigne un nom de fichier physique (extérieur) au nom de fichier logique fourni.
ouvrirAjout(⟨nomLog⟩);La procédure builtin ouvrirAjout ouvre le fichier fourni en mode ajout.
ouvrirÉcriture(⟨nomLog⟩);La procédure builtin ouvrirÉcriture ouvre le fichier fourni en mode écriture.
ouvrirLecture(⟨nomLog⟩);La procédure builtin ouvrirLecture ouvre le fichier fourni en mode lecture.
lire(⟨nomLog⟩, ⟨variable⟩);La procédure builtin lire lit une valeur binaire à partir d'un fichier et l'affecte à la variable fournie.
écrire(⟨nomLog⟩, ⟨expression⟩);La procédure builtin écrire écrit en binaire la valeur de l'expression fournie dans le fichier.
FdF(⟨nomLog⟩);La fonction intégrée FdF teste l'indicateur de fin de fichier sur le fichier fourni et renvoie vrai s'il est défini, faux sinon.
fermer(⟨nomLog⟩);La procédure builtin fermer ferme le fichier fourni.
⟨variable⟩ := ⟨expression⟩;Les affectations changent la valeur d'une variable, qui peut être une variable locale, un élément de tableau, ou un composant de structure.
Toute expression suivie d'un point-virgule est une instruction valide.
⟨nom⟩ : ⟨type⟩;
⟨nom1⟩, ⟨nom2⟩ : ⟨type⟩;Déclare une ou plusieurs variables locales.
Les variables locales peuvent également avoir des initialiseurs.
⟨nom⟩ : ⟨type⟩ := ⟨expression⟩;
⟨nom1⟩, ⟨nom2⟩ : ⟨type⟩ := ⟨expression⟩;Lorsque plusieurs variables sont déclarées, elles sont toutes initialisées à la même valeur.
Un bloc anonyme définit une nouvelle portée. Syntaxe :
début
// instructions…
finLes instructions de flux de contrôle sont utilisées pour contrôler le flux d'exécution dans un programme. Elles permettent de prendre des décisions, de répéter des instructions et de passer à différentes parties du code.
Les boucles vous permettent de répéter un bloc de code plusieurs fois.
tant que ⟨condition⟩ faire
// instructions…
finfaireLa boucle tant que exécute des instructions tant que ⟨condition⟩ est vraie.
⟨condition⟩ peut être entourée de parenthèses.
⟨condition⟩ doit être une expression booléenne ou implicitement convertible en booléen.
faire
// instructions…
tant que ⟨condition⟩La boucle faire exécute les instructions à l'intérieur de la boucle au moins une fois, puis répète la boucle tant que ⟨condition⟩ est vraie.
⟨condition⟩ peut être entourée de parenthèses.
⟨condition⟩ doit être une expression booléenne ou implicitement convertible en booléen.
répéter
// instructions…
jusqu'à ⟨condition⟩La boucle répéter exécute les instructions à l'intérieur de la boucle au moins une fois, puis répète la boucle tant que ⟨condition⟩ est fausse.
⟨condition⟩ peut être entourée de parenthèses.
⟨condition⟩ doit être une expression booléenne ou implicitement convertible en booléen.
pour ⟨variable⟩ de ⟨expr-min⟩ à ⟨expr-max⟩ faire [pas ⟨expr-pas⟩]
// instructions…
finfaireLa boucle pour exécute les instructions à l'intérieur de la boucle pour chaque valeur de ⟨variable⟩ entre ⟨expr-min⟩ et ⟨expr-max⟩.
⟨variable⟩, ⟨expr-min⟩ et ⟨expr-max⟩ doivent être des expressions entières ou implicitement convertibles en entier.
⟨variable⟩ doit être déclarée avant la boucle.
⟨expr-pas⟩ est une expression entière optionelle. Elle définit l'incrément de la variante de boucle. Quand omise, la valeur effective est 1.
Les alternatives vous permettent d'exécuter différents blocs de code en fonction d'une condition.
si ⟨condition⟩ alors
// instructions…
sinonsi ⟨condition⟩ alors
// instructions…
sinon
// instructions…
finsiL'instruction si exécute les instructions à l'intérieur du bloc alors si ⟨condition⟩ est vrai.
⟨condition⟩ peut être entouré de parenthèses.
⟨condition⟩ doit être une expression booléenne ou implicitement convertible en booléen.
Les blocs sinonsi sont facultatifs. Elles sont exécutées si le bloc si précédent est faux et que la ⟨condition⟩ du bloc sinonsi actuel est vrai.
Le bloc sinon est optionnel. Il est exécuté si tous les blocs si et sinonsi précédents sont faux.
selon ⟨expression⟩ c'est
quand ⟨valeur⟩ =>
// instructions…
quand ⟨valeur⟩ =>
// instructions…
quand autre =>
// instructions…
finselonL'instruction selon exécute le bloc quand dont la ⟨valeur⟩ est égale à la valeur de ⟨expression⟩, ou le bloc quand autre si aucun des blocs quand ne correspond.
Le type de ⟨expression⟩ doit prendre en charge l'opérateur ==.
La ⟨valeur⟩ de chaque cas doit être connus au moment de la compilation et du même type que ⟨expression⟩.
Les cas ne définissent pas leur propre portée, donc attention aux collisions de noms de variables.
Une expression est une combinaison de valeurs, de variables, d'opérateurs et de fonctions qui est évaluée pour produire un résultat. Les expressions sont des éléments fondamentaux en programmation et sont utilisées pour effectuer des calculs, prendre des décisions et manipuler des données.
Les littéraux de chaîne sont entourés de guillemets doubles ("). Ils ne peuvent s'étendre que sur une seule ligne.
Ils prennent en charge les séquences d'échappement.
Les littéraux de caractères se composent d'un seul caractère entouré de guillemets simples (').
Ils prennent également en charge les séquences d'échappement.
| Séquence d'échappement | Signification |
|---|---|
\a |
Alerte (bip, cloche) |
\b |
Retour arrière |
\e |
Caractère d'échappement |
\f |
Saut de page |
\n |
Saut de ligne |
\r |
Retour chariot |
\t |
Tabulation horizontale |
\v |
Tabulation verticale |
\\ |
Barre oblique inverse |
\' |
Apostrophe ou guillemet simple |
\" |
Guillemets doubles |
\nnn |
L'octet dont la valeur numérique est donnée par nnn interprété comme un nombre octal |
\xhh… |
L'octet dont la valeur numérique est donnée par hh… interprété comme un nombre hexadécimal |
\uhhhh |
Point de code Unicode inférieur à 10000 hexadécimaux |
\Uhhhhhhhh |
Point de code Unicode où h est un chiffre hexadécimal |
TL;DR : identique au C, mais sans \? (car ce langage n'a pas de trigrammes).
Les entiers sont des nombres sans point décimal. Les littéraux d'entier sont exprimés sous forme de séquence de chiffres décimaux.
Les littéraux de réel sont exprimés sous forme de séquence de chiffres décimaux avec un point décimal facultatif. Les chiffres avant le point décimal sont facultatifs.
Les booléens sont soit vrai (true) soit faux (false).
Le tableau suivant répertorie la priorité et l'associativité de chaque opérateur. Les opérateurs sont répertoriés de haut en bas, par ordre de priorité décroissant.
| Priorité | Opérateur | Description | Associativité |
|---|---|---|---|
| 1 |
()[].
|
Appel de fonction/procédure Indice de tableau Accès au composant de structures |
De gauche à droite |
| 2 |
+ -NON(type)
|
Plus et moins unaires Négation logique ou bit-à-bit Cast |
De droite à gauche |
| 3 |
* / %
|
Multiplication, division et reste | De gauche à droite |
| 4 |
+ -
|
Addition et soustraction | De gauche à droite |
| 5 |
< <=> >=
|
Pour les opérateurs relationnels < et ≤ respectivement Pour les opérateurs relationnels > et ≥ respectivement |
De gauche à droite |
| 6 |
== !=
|
Pour les opérateurs relationnels = et ≠ respectivement | De gauche à droite |
| 7 | XOR |
Disjonction exclusive (OU exclusif) logique ou bit-à-bit | De gauche à droite |
| 8 | ET |
Conjonction (ET) logique ou bit-à-bit | De gauche à droite |
| 9 | OU |
Disjonction (OU) logique ou bit-à-bit logique | De gauche à droite |
Lors de l'analyse d'une expression, un opérateur répertorié sur une ligne sera lié plus étroitement (comme par des parenthèses) à ses arguments que tout opérateur répertorié sur une ligne plus bas. Par exemple, l'expression a + b * c est analysée comme a + (b * c), et non comme (a + b) * c.
Les opérateurs qui se trouvent dans la même cellule (il peut y avoir plusieurs lignes d'opérateurs répertoriées dans une cellule) sont évalués avec la même priorité, dans la direction donnée.
nomFonction(⟨arg1⟩, ⟨arg2⟩, …)Les appels sont utilisés pour invoquer des fonctions et des procédures. Ce sont des expressions qui donnent une valeur. Lors de l'appel d'une procédure, la valeur produite est de type void et ne peut pas être utilisée.
⟨arg1⟩, ⟨arg2⟩, … sont des paramètres effectifs.
Voici un graphique des conversions autorisées entre les types.
flowchart LR
booléen -.faux → 0<br>vrai → 1.-> entier
entier -.0 → faux<br>≠0 → vrai.-> booléen
caractère -.définie par l'implémentation.-> entier
entier -.définie par l'implémentation.-> caractère
chaîneN["chaîne(<var>N</var>)"] --> chaîne
chaîneN ==Chaîne plus grande (<var>n</var> > 0)==> chaîneN2["chaîne(<var>N</var> + <var>n</var>) "]
entier --> réel
réel -.arrondir vers zéro .->entier
nomFichierLog
tableaux["<em>n'importe quel tableau</em>"]
structures["<em>n'importe quelle structure</em>"]
| Forme du lien | Type de conversion |
|---|---|
| Solide | implicite |
| Pointillé | explicite (avec syntaxe de conversion) |
| Épais | affectation uniquement |
Lorsqu'une conversion est définie par l'implémentation, le résultat dépend des règles de le langage cible.
Lorsque le résultat d'une conversion n'est pas spécifié, l'identité est supposée.
Les paramètres formels définissent les données qu'une fonction/procédure attend de l'appelant.
Syntaxe :
⟨mode-formel⟩ ⟨nom⟩ : ⟨type⟩Les paramètres effectifs sont les valeurs effectives passées à une fonction/procédure, conformément à ses paramètres formels.
Syntaxe :
⟨mode-effectif⟩ ⟨nom⟩| nom | mode formel | mode effectif | description |
|---|---|---|---|
| entrée | entF |
entE |
La valeur est copiée depuis l'appelant. |
| sortie | sortF |
sortE |
La fonction/procédure initialise la valeur. La valeur est indéfinie avant d'être assignée. |
| entrée/sortie | entF/sortF |
entE/sortE |
La fonction/procédure peut muter la valeur du côté de l'appelant. |