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
    Valeurs possibles : classe
  • fonction : sans description
    Valeurs possibles : fonction
  • procédure : sans description
    Valeurs possibles : procédure, procedure

 

Structures conditionnelles

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

 

Structures itératives

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

 

Entrées-sorties

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

 

Divers

  • démarrer, commencer : sans description
    Valeurs possibles : demarre, démarre, demarrer, démarrer, commencer
  • continuer : sans description
    Valeurs possibles : continue, continuer
  • 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)
    Valeurs possibles : fin_programme, arrête, arrêter, sortir, stop, termine, terminer, terminé
  • sélectionner : sans description
    Valeurs possibles : selectionner, sélectionner
  • choisir : choix d'une valeur parmi un set de valeurs. Dépend d'une valeur booléenne (résultat d'un test, variable, etc.)
    Valeurs possibles : choisir

 

Types de données

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

 

Symboles

  • > : plus grand que
    Valeurs possibles :
  • < : plus petit que
    Valeurs possibles :
  •  : pour tout
    Valeurs possibles :
  •  : existe
    Valeurs possibles :
  •  : appartient
    Valeurs possibles :
  • ¬ : not (négation)
    Valeurs possibles :
  •  : n'appartient pas à
    Valeurs possibles :
  •  : somme
    Valeurs possibles :
  •  : infini
    Valeurs possibles :
  •  : et
    Valeurs possibles :
  •  : ou
    Valeurs possibles :

 

Commentaires

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

 

Blocs de code

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

 

Opérateurs

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

 

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'utiliserai 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.

 

Document créé le 20/12/09 09:33, dernière modification le 06/04/18 19:47
Source du document imprimé : https://www.gaudry.be/pseudocode-info.html

L'infobrol est un site personnel dont le contenu n'engage que moi. Le texte est mis à disposition sous licence CreativeCommons(BY-NC-SA). Plus d'info sur les conditions d'utilisation et sur l'auteur.