Fortran
Utilizzo dei moduli

Sintassi del modulo

Il modulo è una raccolta di dichiarazioni di tipo, dichiarazioni di dati e procedure. La sintassi di base è:

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

Utilizzo di moduli da altre unità di programma

Per accedere a entità dichiarate in un modulo da un'altra unità di programma (modulo, procedura o programma), il modulo deve essere utilizzato con l'istruzione 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'istruzione use supporta l'importazione solo dei nomi selezionati

program test

  !only iarray is accessible
  use shared_data, only: iarray

  implicit none

  print *, iarray
  
end program

È possibile accedere alle entità anche con un nome diverso utilizzando una lista di ridenominazione :

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

Inoltre, la rinomina può essere combinata con l' only opzione

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

in modo che sia accessibile solo l' iarray del modulo, ma ha il nome locale local_name .

Se selezionato per l'importazione di nomi contrassegnati come privati, non è possibile importarli nel programma.

Moduli intrinseci

Fortran 2003 ha introdotto moduli intrinseci che forniscono accesso a costanti speciali denominate, tipi derivati ​​e procedure modulo. Ora ci sono cinque moduli intrinseci standard:

• ISO_C_Binding ; supportare l'interoperabilità C;
• ISO_Fortran_env ; dettagliando l'ambiente Fortran;
• IEEE_Exceptions , IEEE_Arithmetic e IEEE_Features ; supporto della cosiddetta funzione aritmetica IEEE.

Questi moduli intrinseci fanno parte della libreria Fortran e sono accessibili come altri moduli, tranne che l'istruzione use può avere la natura intrinseca esplicitamente dichiarata:

use, intrinsic :: ISO_C_Binding

Ciò garantisce che il modulo intrinseco venga utilizzato quando è disponibile un modulo fornito dall'utente con lo stesso nome. al contrario

use, non_intrinsic :: ISO_C_Binding

si accerta che lo stesso modulo fornito dall'utente (che deve essere accessibile) sia accessibile al posto del modulo intrinseco. Senza la natura del modulo specificata come in

use ISO_C_Binding

un modulo non intrinseco disponibile sarà preferito rispetto al modulo intrinseco.

I moduli IEEE intrinseci sono diversi dagli altri moduli in quanto la loro accessibilità in una unità di scoping può cambiare il comportamento del codice anche senza riferimento a nessuna delle entità definite in essi.

Controllo di accesso

L'accessibilità dei simboli dichiarati in un modulo può essere controllata utilizzando attributi e dichiarazioni private e public .

Sintassi del modulo di dichiarazione:

!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

Sintassi del modulo di attributo:

integer, parameter, public :: maxn = 1000

real, parameter, private :: local_constant = 42.24

È possibile accedere ai simboli pubblici dalle unità di programma utilizzando il modulo, ma i simboli privati ​​non possono.

Quando non viene utilizzata alcuna specifica, l'impostazione predefinita è public .

La specifica di accesso predefinita usando

private

o

public

può essere modificato specificando un accesso diverso con elenco dichiarazione-entità

public :: name1, name2

o usando attributi.

Questo controllo di accesso influisce anche sui simboli importati da un altro modulo:

module mod1
  integer :: var1
end module

module mod2
  use mod1, only: var1

  public
end module

program test
  use mod2, only: var1
end program

è possibile, ma

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

non è possibile perché var è privato in mod2 .

Entità modulo protetto

Oltre a consentire alle entità del modulo di avere il controllo dell'accesso (essendo public o private ) le entità dei moduli possono anche avere l'attributo protect . Un'entità pubblica protetta può essere associata all'utilizzo, ma l'entità utilizzata è soggetta a restrizioni sul suo utilizzo.

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 obiettivo pubblico protetto non può essere indicato all'esterno del suo modulo

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

Per un puntatore protetto pubblico in un modulo le restrizioni sono diverse. Ciò che è protetto è lo stato di associazione del puntatore

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

Come con i puntatori variabili, anche i puntatori di procedura possono essere protetti, impedendo nuovamente il cambio dell'associazione target.