Fortran
Utilisation des modules

La syntaxe du module

Le module est un ensemble de déclarations de type, de déclarations de données et de procédures. La syntaxe de base est la suivante:

module module_name
  use other_module_being_used

  ! The use of implicit none here will set it for the scope of the module. 
  ! Therefore, it is not required (although considered good practice) to repeat 
  ! it in the contained subprograms. 
  implicit none

  ! Parameters declaration
  real, parameter, public :: pi = 3.14159
  ! The keyword private limits access to e parameter only for this module
  real, parameter, private :: e = 2.71828

  ! Type declaration
  type my_type
    integer :: my_int_var
  end type

  ! Variable declaration
  integer :: my_integer_variable

! Subroutines and functions belong to the contains section
contains

  subroutine my_subroutine
    !module variables are accessible
    print *, my_integer_variable
  end subroutine

  real function my_func(x)
    real, intent(in) :: x
    my_func = x * x
  end function my_func
end module

Utilisation de modules d'autres unités de programme

Pour accéder aux entités déclarées dans un module à partir d'une autre unité de programme (module, procédure ou programme), le module doit être utilisé avec l'instruction use .

module shared_data
  implicit none

  integer :: iarray(4) = [1, 2, 3, 4]
  real :: rarray(4) = [1., 2., 3., 4.]
end module


program test

  !use statements most come before implicit none
  use shared_data

  implicit none

  print *, iarray
  print *, rarray
end program

L'instruction use prend en charge l'importation uniquement des noms sélectionnés

program test

  !only iarray is accessible
  use shared_data, only: iarray

  implicit none

  print *, iarray
  
end program

Les entités peuvent également être consultées sous un nom différent en utilisant une liste de renommage :

program test

  !only iarray is locally renamed to local_name, rarray is still acessible
  use shared_data, local_name => iarray

  implicit none

  print *, local_name

  print *, rarray
  
end program

En outre, renommer peut être combiné avec la only option

program test
  use shared_data, only : local_name => iarray
end program

de sorte que seule l’entité de module iarray est accessible, mais qu’elle porte le nom local local_name .

Si elle est sélectionnée pour les noms que l' importation privée marque vous ne pouvez pas les importer dans votre programme.

Modules intrinsèques

Fortran 2003 a introduit des modules intrinsèques qui donnent accès à des constantes nommées spéciales, à des types dérivés et à des procédures de module. Il existe maintenant cinq modules intrinsèques standard:

• ISO_C_Binding ; soutenir l'interopérabilité C;
• ISO_Fortran_env ; détaillant l'environnement Fortran;
• IEEE_Exceptions , IEEE_Arithmetic et IEEE_Features ; supportant l'installation arithmétique dite IEEE.

Ces modules intrinsèques font partie de la bibliothèque Fortran et sont accessibles comme d’autres modules, sauf que la déclaration d’ use peut avoir la nature intrinsèque explicitement énoncée:

use, intrinsic :: ISO_C_Binding

Cela garantit que le module intrinsèque est utilisé lorsqu'un module fourni par l'utilisateur du même nom est disponible. inversement

use, non_intrinsic :: ISO_C_Binding

s'assure que ce même module fourni par l'utilisateur (qui doit être accessible) est accessible à la place du module intrinsèque. Sans la nature de module spécifiée comme dans

use ISO_C_Binding

un module non intrinsèque disponible sera préféré au module intrinsèque.

Les modules IEEE intrinsèques sont différents des autres modules en ce sens que leur accessibilité dans une unité de portée peut modifier le comportement du code même sans référence à aucune des entités qui y sont définies.

Contrôle d'accès

L'accessibilité des symboles déclarés dans un module peut être contrôlée à l'aide public attributs et d'énoncés private et public .

Syntaxe du formulaire de déclaration:

!all symbols declared in the module are private by default
private

!all symbols declared in the module are public by default
public

!symbols in the list will be private
private :: name1, name2

!symbols in the list will be public
public :: name3, name4

Syntaxe de la forme d'attribut:

integer, parameter, public :: maxn = 1000

real, parameter, private :: local_constant = 42.24

Les symboles publics sont accessibles depuis les unités de programme utilisant le module, mais pas les symboles privés.

Si aucune spécification n'est utilisée, la valeur par défaut est public .

La spécification d'accès par défaut en utilisant

private

ou

public

peut être modifié en spécifiant un accès différent avec l' entité-déclaration-liste

public :: name1, name2

ou en utilisant des attributs.

Ce contrôle d'accès affecte également les symboles importés d'un autre module:

module mod1
  integer :: var1
end module

module mod2
  use mod1, only: var1

  public
end module

program test
  use mod2, only: var1
end program

est possible, mais

module mod1
  integer :: var1
end module

module mod2
  use mod1, only: var1

  public
  private :: var1
end module

program test
  use mod2, only: var1
end program

n'est pas possible car var est privé dans mod2 .

Entités de module protégées

En plus de permettre aux entités de module d'avoir un contrôle d'accès (étant public ou private ), les entités de modules peuvent également avoir l'attribut protect . Une entité publique protégée peut être associée, mais l'entité utilisée est soumise à des restrictions d'utilisation.

module mod
  integer, public, protected :: i=1
end module

program test
  use mod, only : i
  print *, i   ! We are allowed to get the value of i
  i = 2        ! But we can't change the value
end program test

Une cible publique protégée n'est pas autorisée à pointer en dehors de son module

module mod
  integer, public, target, protected :: i
end module mod

program test
  use mod, only : i
  integer, pointer :: j
  j => i   ! Not allowed, even though we aren't changing the value of i
end program test

Pour un pointeur protégé dans un module, les restrictions sont différentes. Ce qui est protégé est le statut d'association du pointeur

module mod
  integer, public, target :: j
  integer, public, protected, pointer :: i => j
end module mod

program test
  use mod, only : i
  i = 2   ! We may change the value of the target, just not the association status
end program test

Comme pour les pointeurs variables, les pointeurs de procédure peuvent également être protégés, empêchant à nouveau le changement d'association cible.