Fortran
Uso de módulos

Sintaxis del modulo

El módulo es una colección de declaraciones de tipo, declaraciones de datos y procedimientos. La sintaxis básica es:

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

Usando módulos de otras unidades de programa

Para acceder a las entidades declaradas en un módulo desde otra unidad de programa (módulo, procedimiento o programa), el módulo debe usarse con la declaración de 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

La declaración de use permite importar solo los nombres seleccionados

program test

  !only iarray is accessible
  use shared_data, only: iarray

  implicit none

  print *, iarray
  
end program

También se puede acceder a las entidades con un nombre diferente utilizando una lista de cambio de nombre :

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

Además, el cambio de nombre se puede combinar con la only opción

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

de modo que solo se accede a la entidad del módulo iarray , pero tiene el nombre local local_name .

Si se selecciona para importar nombres de marca como privados, no puede importarlos a su programa.

Módulos intrínsecos

Fortran 2003 introdujo módulos intrínsecos que brindan acceso a constantes con nombre especiales, tipos derivados y procedimientos de módulos. Ahora hay cinco módulos intrínsecos estándar:

• ISO_C_Binding ; apoyando la interoperabilidad de C;
• ISO_Fortran_env ; detallando el entorno de Fortran;
• IEEE_Exceptions , IEEE_Arithmetic y IEEE_Features ; soportando la llamada facilidad aritmética IEEE.

Estos módulos intrínsecos son parte de la biblioteca Fortran y se accede a ellos como otros módulos, excepto que la declaración de use puede tener la naturaleza intrínseca explícitamente establecida:

use, intrinsic :: ISO_C_Binding

Esto garantiza que el módulo intrínseco se use cuando esté disponible un módulo proporcionado por el usuario con el mismo nombre. A la inversa

use, non_intrinsic :: ISO_C_Binding

asegura que se acceda al mismo módulo proporcionado por el usuario (que debe ser accesible) en lugar del módulo intrínseco. Sin la naturaleza del módulo especificado como en

use ISO_C_Binding

se preferirá un módulo no intrínseco disponible sobre el módulo intrínseco.

Los módulos IEEE intrínsecos son diferentes de otros módulos en que su accesibilidad en una unidad de alcance puede cambiar el comportamiento del código allí, incluso sin hacer referencia a ninguna de las entidades definidas en ellos.

Control de acceso

La accesibilidad de los símbolos declarados en un módulo puede controlarse utilizando atributos y declaraciones private y public .

Sintaxis del formulario de declaración:

!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

Sintaxis de la forma de atributo:

integer, parameter, public :: maxn = 1000

real, parameter, private :: local_constant = 42.24

Se puede acceder a los símbolos públicos desde las unidades de programa que usan el módulo, pero los símbolos privados no pueden.

Cuando no se utiliza ninguna especificación, el valor predeterminado es public .

La especificación de acceso por defecto usando

private

o

public

se puede cambiar especificando un acceso diferente con la lista de declaración de entidad

public :: name1, name2

o utilizando atributos.

Este control de acceso también afecta a los símbolos importados de otro módulo:

module mod1
  integer :: var1
end module

module mod2
  use mod1, only: var1

  public
end module

program test
  use mod2, only: var1
end program

es posible, pero

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

no es posible porque var es privado en mod2 .

Entidades de módulo protegido

Además de permitir que las entidades de módulo tengan control de acceso (ya sea public o private ), las entidades de módulo también pueden tener el atributo de protect . Una entidad protegida pública puede estar asociada al uso, pero la entidad utilizada está sujeta a restricciones sobre su uso.

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

Un objetivo protegido público no puede ser apuntado fuera de su módulo

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

Para un puntero público protegido en un módulo, las restricciones son diferentes. Lo que está protegido es el estado de asociación del puntero.

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

Al igual que con los punteros variables, los punteros de procedimiento también pueden protegerse, impidiendo nuevamente el cambio de asociación objetivo.