Notion de module

Les modules permettent d'améliorer la fiabilité des programmes en évitant la duplication de déclarations identiques.

Exemple 1. Nous créons une unité de compilation nommée 'MODULE'

 
       MODULE typtmod
          IMPLICIT NONE
          TYPE point
             INTEGER :: num
             REAL    :: x, y
          END TYPE point
       END MODULE typtmod

Pour utiliser ce module, il suffit de mentionner une instruction USE ( ici USE typtmod) au sein d'un programme, d'une procédure ou d'une fonction. Par exemple

 
       PROGRAM exemple_module
          USE typtmod
          IMPLICIT NONE
          TYPE(point)   :: a = point(3,2,0,5.)
          PRINT*,a
       END  PROGRAM exemple_module

Tout se passe alors comme si les instructions contenues dans le module typtmod avaient été introduites dans le programme principale.

Exemple 2. Dépendances entre modules et procédure. Un module peut faire appel à son tour à un autre module.

 
       MODULE symmod
          USE typtmod
          IMPLICIT NONE
          CONTAINS
          FUNCTION symetrique (p)
             TYPE(point), INTENT(IN) :: p
             TYPE(point)             :: symetrique
             symetrique%x = -p%x
         END  FUNCTION symetrique
       END MODULE symmod

le mot clé CONTAINS indique que la fonction symetrique est une fonctions interne à l'unité de compilation (MODULE symmod) et ainsi le type point n'a pas besoin d'être déclaré à l'intérieur de la fonction symetrique.

 
       PROGRAM exple_sym
          USE typtmod
          USE symmod
          IMPLICIT NONE
          TYPE(point)   :: a = point(3,2,0,5.), b

          b = symetrique (a)
          PRINT*,a,b
       END PROGRAM exple_sym

$\ominus$ Noter que L'INTERFACE d'une fonction (ou d'une prodédure) n'est pas exigée si celle-ci est définie dans un module.

Exemple3. Partage des données.

 
       MODULE tabmod
          IMPLICIT NONE
          INTEGER, PARAMETER      :: n = 10
          INTEGER, DIMENSION (n)  :: T
       END MODULE tab

Voici une subroutine qui utilise ce module

 
       SUBROUTINE init
          USE tabmod
          IMPLICIT NONE
          INTEGER    :: I
   
          T=(/ (i, i=1,n) /)
       END SUBROUTINE init

Cette subroutine n'a pas d'argument, mais par contre le tableau T est connu via le module tabmod.

 
       PROGRAM exple_tab 
          USE tabmod
          IMPLICIT NONE

          CALL init
          PRINT*,T
       END PROGRAM exple_tab

D'une maniére générale, le seul type de dépendance soit interdit est celui où un module s'appelle lui-même directement ou indirectement : A utilise B qui utilise C qui utilise A.