Pseudo code

Petits bouts de code et grands discours

Pour illustrer un algorithme, rien de tel qu'un petit bout de code... mais quel langage allons nous utiliser? Dans certains cas l'algorithme ne fait que proposer les grandes lignes de la recette, mais ne s'encombre pas des détails de l'implémentation dans tel ou tel langage de programmation.

Je vais donc utiliser un pseudo code pour illustrer certains exemples, mais comme il n'existe pas de réelle convension pour le pseudo code, je définirais donc nos propres convensions, qui permettrons notament d'en faciliter la lecture et la coloration automatique en usage sur l'infobrol.

Je suis un fervent défenseur de l'emploi de l'anglais dans la génération du code en général (règles de nommage des classes, méthodes et variables; comentaires; etc.). J'ai pu constater que le non respect de cette méthode de travail mène le plus souvent à des situations désastreuses à terme.
Cependant, comme le pseudo code que nous utiliserons ne sera utilisé qu'à des fins didactiques sur ce site, je pense que l'emploi du français permettra une meilleur approche. De même, je n'utilise jamais de caractères accentués dans mon code, mais nous pouvons les utiliser dans le pseudo code.

Mots clés du pseudo code

Conteneurs

• classe : sans description
• fonction : sans description
• procédure : sans description

Structures conditionnelles

• si ...alors ... : condition de type if
• si ...alors ... sinon ... : condition de type if else
• si ...alors ... sinon_si ... alors ... : condition de type if elseif
• avec ... égal_à ... : branchement conditionnel de type switch case (amélioration de plusieurs if)

Structures itératives

• pour ... faire ... : itération de type for (itération avec compteur)
• pour_tout ... faire ... : itération de type foreach (itération de tous les éléments)
• variant_de ... jusque ... : itération de type for (pour i variant_de 1 jusque 10 faire ...)
• tant_que ... faire ... : itération de type do while
• jusque ... faire ... : itération de type until
• faire ... jusque ... : itération de type do until
• répéter : sans description

Entrées-sorties

• affiche, afficher : envoyer de l'information vers un dispositif de sortie, le plus souvent vers l'écran
• écrit, écrire : envoyer de l'information vers un dispositif de sortie, par exemple un fichier
• lit, lire : lire l'information depuis une entrée (clavier, fichier, etc.)

Divers

• démarrer, commencer : sans description
• continuer : sans description
• arrêter, sortir, stop, terminer, fin_programme : opération de type exit, break, ou opération de type return (arrêt de la fonction et affectation de la valeur de retour)
• sélectionner : sans description
• choisir : choix d'une valeur parmi un set de valeurs. Dépend d'une valeur booléenne (résultat d'un test, variable, etc.)

Types de données

• booléen : type à deux états (vrai ou faux)
• réel : nombre réel
• entier : nombre entiers
• décimal : nombre décimal
• lettre : caractère
• mots : chaînes de caractères (Strings)
• tableau : sans description
• collection : sans description
• liste : type générique Liste
• rien_en_retour : la méthode ne retourne pas de valeur, il s'agit d'une "procédure" dans certains langages.
• rien : signifie l'absence de valeur.

Symboles

• > : plus grand que
• < : plus petit que
• ∀ : pour tout
• ∃ : existe
• ∈ : appartient
• ¬ : not (négation)
• ∉ : n'appartient pas à
• ∑ : somme
• ∞ : infini
• ∧ : et
• ∨ : ou

Commentaires

• // : précède un commentaire sur une ligne
• /* ... */ : entoure un commentaire multi lignes

Blocs de code

• <condition> : instruction qui effectue un test afin de renvoyer une valeur booléenne
• <expression> : sans description
• <expression_V> : expression à exécuter si la condition est respectée (true, vrai, 1, etc.)
• <expression_F> : expression à exécuter si la condition n'est pas respectée (false, faux, 0, etc.)
• <instruction> : instruction unique
• <instruction_s> : une ou plusieurs instructions
• <_..._> : remplace n'importe quel bloc de code (accepte toute combinaison de lettres, de chiffres, et le tiret)

Opérateurs

• := : affectation
  Par exemple a:=1 signifie que l'on affecte la valeur 1 à la variable a
• = : égalité
  Par exemple a=b teste si les deux variables sont égales et renvoie vrai ou faux

Remarques

Pour les blocs de code, nous pouvons retrouver le mot clé du bloc précédé du mot fin (par exemple : faire... tant que ... fin tant que).

Cette liste de mots clés n'est pas exhaustive. Certains mots clés dépendent uniquement de tel ou tel algorithme et permettent un lien vers une information plus complexe.

J'utiliserais la notation en vigueur pour le langage Java (depuis Java5) pour les génériques, car je trouve qu'elle est vraiment facile d'utilisation. C'est un choix arbitraire, car je n'ai trouvé aucune spécification en méthodologie relative à la notation du type de données dans les types génériques.
La notation que j'utiliserais est donc composée du signe < suivi du nom du type (ou d'une lettre) et terminé par le signe >.
Nous pouvons ajouter certaines précisions relatives au type, entre le nom de type et la balise fermante (>). Par exemple Liste<Personne> est un élément de type Liste qui ne contiendra que des éléments de type Personne.
J'utiliserais aussi toujours la première lettre en majuscule pour désigner un type pour le différencier d'une opération ou d'une instance.
Quelques exemples :

• Pile<?> est un type de pile qui contient des éléments de n'importe quel type
• Pile<T> est un type pile qui contient des éléments de type T. Ceci nous permet de ne pas définir de suite le type, mais au contraire de Pile<?> nous ne pourons rencontrer ici que des éléments du type T qui sera défini ensuite.
• Pile<Animal> est un type pile qui contient des éléments de type Animal
• Pile<T extends Animal> est une pile qui contient des éléments de type T qui sera défini par la suite, mais qui devra obligatoirement comporter les opérations minimum que nous pouvons effectuer pour le type Animal. L'avantage ici par rapport à Pile<Animal> est que nous pouvons par la suite utiliser aussi toutes les opérations spécifiées dans le type T.

Structure du document