Fortran
I / O

Syntax

• WRITE(unit num, format num) matar ut data efter parenteserna i en ny rad.
• READ(unit num, format num) ingångar till variabeln efter parenteserna.
• OPEN(unit num, FILE=file) öppnar en fil. (Det finns fler alternativ för att öppna filer, men de är inte viktiga för I / O.
• CLOSE(unit num) stänger en fil.

Enkel I / O

Som ett exempel på att skriva input & output tar vi in ett verkligt värde och returnerar värdet och dess kvadrat tills användaren anger ett negativt tal.

Som anges nedan tar det read kommandot två argument: enhetsnumret och formatspecifikatorn. I exemplet nedan använder vi * för enhetsnumret (som indikerar stdin) och * för formatet (som indikerar standard för reals, i detta fall). Vi anger också formatet för print . Man kan alternativt använda write(*,"The value....") eller helt enkelt ignorera formatering och ha det som

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

vilket sannolikt kommer att resultera i några märkligt åtskilda strängar och värden.

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

Läs med lite felkontroll

Ett modernt Fortran-exempel som inkluderar felkontroll och en funktion för att få ett nytt enhetsnummer för filen.

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

Skickar kommandoradsargument

Där kommandoradsargument stöds kan de läsas in via get_command_argument intrinsic (introducerad i Fortran 2003-standarden). command_argument_count ger ett sätt att känna till antalet argument som tillhandahålls på kommandoraden.

Alla kommandoradsargument läses in som strängar, så en intern konvertering måste göras för numerisk data. Som ett exempel summerar denna enkla kod de två siffrorna som anges på kommandoraden:

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

get_command_argument i get_command_argument sträcker sig användbart mellan 0 och resultatet av command_argument_count . Om värdet är 0 levereras kommandonamnet (om det stöds).

Många kompilatorer erbjuder också icke-standard intrinsics (som getarg ) för att komma åt kommandoradsargument. Eftersom dessa inte är standard, bör motsvarande kompilatordokumentation konsulteras.

Användning av get_command_argument kan förlängas utöver ovanstående exempel med length och status argument. Till exempel med

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

värdet på stat kommer att vara -1 om det första argumentet finns och har längd större än 5. Om det finns någon annan svårighet att hämta argumentet kommer värdet på stat att vara ett positivt tal (och arg kommer helt att bestå av tomma). Annars blir dess värde 0 .

Den length argumentet kan kombineras med en uppskjuten längd teckenvariabel, såsom i det följande exemplet.

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)