Fortran
I / O

Sintassi

• WRITE(unit num, format num) restituisce i dati dopo le parentesi in una nuova riga.
• READ(unit num, format num) ingressi alla variabile dopo le parentesi.
• OPEN(unit num, FILE=file) apre un file. (Ci sono più opzioni per aprire i file, ma non sono importanti per I / O.
• CLOSE(unit num) chiude un file.

I / O semplice

Come esempio di input e output di scrittura, acquisiremo un valore reale e restituiremo il valore e il relativo quadrato finché l'utente non immetterà un numero negativo.

Come specificato di seguito, il comando read accetta due argomenti: il numero di unità e l'identificatore di formato. Nell'esempio seguente, usiamo * per il numero di unità (che indica stdin) e * per il formato (che indica l'impostazione predefinita per i valori reali, in questo caso). Specifichiamo anche il formato per la dichiarazione di print . In alternativa, puoi usare write(*,"The value....") o semplicemente ignorare la formattazione e averlo come

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

che risulterà probabilmente in alcune stringhe e valori stranamente distanziati.

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

Leggi con alcuni errori di controllo

Un moderno esempio di Fortran che include il controllo degli errori e una funzione per ottenere un nuovo numero di unità per il file.

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

Passando gli argomenti della riga di comando

Dove gli argomenti della riga di comando sono supportati, possono essere letti tramite il get_command_argument intrinsico (introdotto nello standard Fortran 2003). Il command_argument_count intrinsic fornisce un modo per conoscere il numero di argomenti forniti nella riga di comando.

Tutti gli argomenti della riga di comando vengono letti come stringhe, pertanto è necessario eseguire una conversione del tipo interno per i dati numerici. Ad esempio, questo semplice codice somma i due numeri forniti sulla riga di comando:

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'argomento numero in get_command_argument varia utilmente tra 0 e il risultato di command_argument_count . Se il valore è 0 viene fornito il nome del comando (se supportato).

Molti compilatori offrono anche elementi intrinseci non standard (come getarg ) per accedere agli argomenti della riga di comando. Poiché questi non sono standard, dovrebbe essere consultata la corrispondente documentazione del compilatore.

L'uso di get_command_argument può essere esteso oltre l'esempio precedente con gli argomenti length e status . Ad esempio, con

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

il valore di stat sarà -1 se il primo argomento esiste e ha lunghezza maggiore di 5. Se c'è qualche altra difficoltà nel recuperare l'argomento il valore di stat sarà un numero positivo (e arg sarà composto interamente da spazi vuoti). Altrimenti il ​​suo valore sarà 0 .

L'argomento della length può essere combinato con una variabile di carattere di lunghezza differita, come nell'esempio seguente.

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)