Fortran
I / O

Syntaxe

• WRITE(unit num, format num) affiche les données après les crochets dans une nouvelle ligne.
• READ(unit num, format num) saisit la variable après les crochets.
• OPEN(unit num, FILE=file) ouvre un fichier. (Il y a plus d'options pour ouvrir des fichiers, mais elles ne sont pas importantes pour les E / S.
• CLOSE(unit num) ferme un fichier.

Simple I / O

À titre d'exemple d'écriture des entrées et des sorties, nous allons prendre une valeur réelle et renvoyer la valeur et son carré jusqu'à ce que l'utilisateur entre un nombre négatif.

Comme spécifié ci-dessous, la commande read prend deux arguments: le numéro d'unité et le spécificateur de format. Dans l'exemple ci-dessous, nous utilisons * pour le numéro d'unité (qui indique stdin) et * pour le format (qui indique la valeur par défaut pour les réels, dans ce cas). Nous spécifions également le format de l'instruction d' print . On peut aussi utiliser write(*,"The value....") ou simplement ignorer le formatage et l’avoir comme

print *,"The entered value was ", x," and its square is ",x*x

ce qui entraînera probablement des chaînes et des valeurs étrangement espacées.

program SimpleIO
   implicit none
   integer, parameter :: wp = selected_real_kind(15,307)
   real(kind=wp) :: x
   
   ! we'll loop over until user enters a negative number
   print '("Enter a number >= 0 to see its square. Enter a number < 0 to exit.")'
   do
      ! this reads the input as a double-pricision value
      read(*,*) x
      if (x < 0d0) exit
      ! print the entered value and it's square
      print '("The entered value was ",f12.6,", its square is ",f12.6,".")',x,x*x
   end do
   print '("Thank you!")'
   
end program SimpleIO

Lire avec quelques vérifications d'erreur

Un exemple Fortran moderne qui inclut la vérification des erreurs et une fonction permettant d'obtenir un nouveau numéro d'unité pour le fichier.

module functions

contains

    function get_new_fileunit() result (f)
        implicit none

        logical    :: op
        integer    :: f

        f = 1
        do 
            inquire(f,opened=op)
            if (op .eqv. .false.) exit
            f = f + 1
        enddo

    end function

end module

program file_read
    use functions, only : get_new_fileunit
    implicit none

    integer            :: unitno, ierr, readerr
    logical            :: exists
    real(kind(0.d0))   :: somevalue
    character(len=128) :: filename

    filename = "somefile.txt"

    inquire(file=trim(filename), exist=exists)
    if (exists) then
        unitno = get_new_fileunit()
        open(unitno, file=trim(filename), action="read", iostat=ierr)
        if (ierr .eq. 0) then
            read(unitno, *, iostat=readerr) somevalue
            if (readerr .eq. 0) then
                print*, "Value in file ", trim(filename), " is ", somevalue
            else
                print*, "Error ", readerr, & 
                        " attempting to read file ", & 
                        trim(filename)
            endif
        else
            print*, "Error ", ierr ," attempting to open file ", trim(filename)
            stop
        endif
    else
        print*, "Error -- cannot find file: ", trim(filename)
        stop
    endif

end program file_read

Passer des arguments de ligne de commande

Lorsque les arguments de ligne de commande sont pris en charge, ils peuvent être lus via la get_command_argument intrinsèque de get_command_argument (introduite dans la norme Fortran 2003). La commande command_argument_count permet de connaître le nombre d’arguments fournis sur la ligne de commande.

Tous les arguments de ligne de commande sont lus en tant que chaînes, donc une conversion de type interne doit être effectuée pour les données numériques. Par exemple, ce code simple additionne les deux chiffres fournis sur la ligne de commande:

PROGRAM cmdlnsum
IMPLICIT NONE
CHARACTER(100) :: num1char
CHARACTER(100) :: num2char
REAL :: num1
REAL :: num2
REAL :: numsum

!First, make sure the right number of inputs have been provided
IF(COMMAND_ARGUMENT_COUNT().NE.2)THEN
  WRITE(*,*)'ERROR, TWO COMMAND-LINE ARGUMENTS REQUIRED, STOPPING'
  STOP
ENDIF

CALL GET_COMMAND_ARGUMENT(1,num1char)   !first, read in the two values
CALL GET_COMMAND_ARGUMENT(2,num2char)

READ(num1char,*)num1                    !then, convert them to REALs
READ(num2char,*)num2

numsum=num1+num2                        !sum numbers
WRITE(*,*)numsum                        !write out value

END PROGRAM

L'argument number de get_command_argument situe utilement entre 0 et le résultat de command_argument_count . Si la valeur est 0 le nom de la commande est fourni (si pris en charge).

De nombreux compilateurs offrent également des éléments intrinsèques non standard (tels que getarg ) pour accéder aux arguments de la ligne de commande. Comme ils ne sont pas standard, la documentation du compilateur correspondante doit être consultée.

L'utilisation de get_command_argument peut être étendue au-delà de l'exemple ci-dessus avec les arguments length et status . Par exemple, avec

character(5) arg
integer stat
call get_command_argument(number=1, value=arg, status=stat)

la valeur de stat sera -1 si le premier argument existe et a une longueur supérieure à 5. S'il y a une autre difficulté à récupérer l'argument, la valeur de stat sera un nombre positif (et arg sera entièrement composé de blancs). Sinon, sa valeur sera 0 .

L'argument length peut être combiné avec une variable de longueur de longueur différée, comme dans l'exemple suivant.

character(:), allocatable :: arg
integer arglen, stat
call get_command_argument(number=1, length=arglen)  ! Assume for simplicity success
allocate (character(arglen) :: arg)
call get_command_argument(number=1, value=arg, status=stat)