Leçons de niveau 14

COBOL/Sous-programmes

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Sous-programmes
Icône de la faculté
Chapitre no 9
Leçon : COBOL
Chap. préc. :Opérations sur les chaînes
Chap. suiv. :Fonctions intrinsèques
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « COBOL : Sous-programmes
COBOL/Sous-programmes
 », n'a pu être restituée correctement ci-dessus.



L'utilisation de sous-programme permet de réutiliser du code : plutôt que de réécrire plusieurs fois le même traitement (le même code), faites plusieurs appels à un même sous-programme. C'est de la programmation procédurale. Un sous-programme permet d'effectuer un traitement particulier (défini par les instructions COBOL qui le composent), vous pouvez lui passer plusieurs arguments en paramètre : lors de son appel, précisez les variables que votre sous-programme pourra utiliser, elles constitueront l'environnement d'exécution du programme et permettront de modifier le résultat de son exécution (il en est de même pour les fonctions mathématiques).

Appel d'un sous-programme[modifier | modifier le wikicode]

Considérons un programme principal (appelant) a et un programme secondaire (appelé) b. Le programme a fait appel au programme b en utilisant l'instruction CALL :


prg est le nom du programme appelé, par exemple dans notre cas, nous mettrons "b". La clause USING nous permet de spécifier la liste des arguments à passer au sous-programme, vous pouvez en passer autant que vous voulez.

Les variables passées en paramètre doivent être de niveau 01 ou 77.

Vous pouvez précéder chacun de ces arguments (ou chaque groupe d'arguments) de REFERENCE ou CONTENT. Le premier est un passage par référence : la variable que vous passez pourra être modifiée par le sous-programme, vous devez donc l’utiliser avec prudence. Le second est un passage par valeur : c’est une copie de l'argument qui est passée au sous-programme et ainsi si celui-ci la modifie, cela n'a pas d'incidence sur la variable d'origine.

  • Si aucun mode de passage n'est précisé, c’est le passage par référence qui sera utilisé.
  • Si vous n'avez pas besoin de modifier la valeur d'un argument, passez-le par valeur.

Concernant le programme appelé[modifier | modifier le wikicode]

Les variables passées en paramètre doivent être définies dans la LINKAGE SECTION de la DATA DIVISION (juste après la WORKING-STORAGE SECTION) du sous-programme appelé. Ces définitions doivent être identiques à celles des variables originales (définies dans le programme appelant), à ceci près que la clause VALUE ne peut être utilisée.


Vous devez également préciser dans la PROCEDURE DIVISION du programme appelé une clause USING permettant d'énumérer ces variables : leur ordre d'apparition est important, il doit correspondre à l’ordre utilisé lors de l'appel du sous-programme (l'instruction CALL).


Il n’est pas nécessaire que les variables aient le même nom dans le programme appelant et le programme appelé. La correspondance des arguments entre les 2 programmes ne se fait pas sur leur nom mais sur leur ordre d'apparition.

Structure des sous-programmes[modifier | modifier le wikicode]

Il y a deux manières de découper un programme en plusieurs sous-programmes.

Code séparé[modifier | modifier le wikicode]

La première façon de faire est de définir les sous-programmes l'un après l'autre. Voici par exemple la définition d'un programme a puis la définition d'un programme b.

Début de l'exemple
Fin de l'exemple


b est appelé par a, l'instruction STOP RUN (qui met fin à l'exécution) est remplacée par EXIT PROGRAM qui marque la fin du sous-programme.

Code imbriqué[modifier | modifier le wikicode]

La seconde façon de faire est d'imbriquer la définition du sous-programme appelé dans celle du sous-programme appelant :

Début de l'exemple
Fin de l'exemple


Ici, la définition du sous-programme b est imbriquée dans celle du sous-programme a : elle est placée entre le STOP RUN qui marque la fin de l'exécution (en clair : après la dernière instruction) et le END PROGRAM qui marque la fin du programme.

Cette façon de faire est utile si l'usage du sous-programme b se limite au programme a.

Exemple : MAX de deux entiers[modifier | modifier le wikicode]

Voici un programme dans lequel nous définissons un sous-programme max (lignes 15 à 29), appelé à partir du programme principal a (lignes 1 à 13).

Début de l'exemple
Fin de l'exemple


Nous passons 3 variables à notre sous-programme : 2 que nous ne modifierons pas et que nous passerons donc par valeur, et une dernière qui prendra la valeur du maximum des deux autres que nous passerons par référence.

L'ordre de passage des arguments nous indique que les variables a, b, max du programme appelé correspondent aux variables x, y, max du programme appelant.