Fortran
Användning av moduler

Modulsyntax

Modulen är en samling av typdeklarationer, datadeklarationer och procedurer. Den grundläggande syntaxen är:

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

Med hjälp av moduler från andra programenheter

För att få åtkomst till enheter som deklarerats i en modul från en annan programenhet (modul, procedur eller program) måste modulen användas med 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

use stöder endast import av valda namn

program test

  !only iarray is accessible
  use shared_data, only: iarray

  implicit none

  print *, iarray
  
end program

Enheter kan också nås under olika namn genom att använda en namnnamn-lista :

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

Vidare kan namnändring kombineras med det only alternativet

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

så att endast iarray har åtkomst, men den har det lokala namnet local_name .

Om du har valt att importera namn markeras som privat kan du inte importera dem till ditt program.

Inneboende moduler

Fortran 2003 introducerade inneboende moduler som ger tillgång till speciella namngivna konstanter, härledda typer och modulprocedurer. Det finns nu fem inneboende standardmoduler:

• ISO_C_Binding ; stödja C-driftskompatibilitet;
• ISO_Fortran_env ; detaljering av Fortran-miljön;
• IEEE_Exceptions , IEEE_Arithmetic och IEEE_Features ; stödja så kallad IEEE aritmetisk anläggning.

Dessa intrinsiska moduler är en del av Fortran-biblioteket och har åtkomst som andra moduler förutom att use kan ha den inre naturen uttryckligen anges:

use, intrinsic :: ISO_C_Binding

Detta säkerställer att den inneboende modulen används när en användarmodul med samma namn är tillgänglig. Omvänt

use, non_intrinsic :: ISO_C_Binding

säkerställer att samma användare som tillhandahålls modul (som måste vara tillgänglig) åtkomst i stället för den inre modulen. Utan den modulkaraktär som anges i

use ISO_C_Binding

en tillgänglig icke-inneboende modul kommer att föredras framför den inre modulen.

De inneboende IEEE-modulerna skiljer sig från andra moduler genom att deras tillgänglighet i en scoping-enhet kan ändra kodens beteende även utan hänvisning till någon av de enheter som definieras i dem.

Åtkomstkontroll

Tillgängligheten för symboler som deklareras i en modul kan kontrolleras med private och public attribut och uttalanden.

Syntax för uttalningsformuläret:

!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

Syntax för attributformuläret:

integer, parameter, public :: maxn = 1000

real, parameter, private :: local_constant = 42.24

Offentliga symboler kan nås från programenheter med modulen, men privata symboler kan inte.

När ingen specifikation används är standarden public .

Standardåtkomstspecifikationen med

private

eller

public

kan ändras genom att ange olika åtkomst med entitetsdeklarationslista

public :: name1, name2

eller med attribut.

Denna åtkomstkontroll påverkar också symboler som importeras från en annan modul:

module mod1
  integer :: var1
end module

module mod2
  use mod1, only: var1

  public
end module

program test
  use mod2, only: var1
end program

är möjligt, men

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

är inte möjligt eftersom var är privat i mod2 .

Skyddade modulenheter

Förutom att modulenheter kan ha åtkomstkontroll (som är public eller private ) kan modulenheter också ha protect . En offentlig skyddad enhet kan vara associerad med användning, men den använda enheten är föremål för begränsningar för dess användning.

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

Ett offentligt skyddat mål får inte pekas på utanför modulen

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

För en offentlig skyddad pekare i en modul är begränsningarna olika. Det som är skyddat är pekarens associeringsstatus

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

Liksom med variabla pekare kan procedurpekare också skyddas, vilket återigen förhindrar ändring av målassociation.