Fortran
आई / ओ

वाक्य - विन्यास

• WRITE(unit num, format num) एक नई पंक्ति में कोष्ठक के बाद डेटा को आउटपुट करता है।
• ब्रैकेट के बाद चर के लिए READ(unit num, format num) इनपुट।
• OPEN(unit num, FILE=file) एक फ़ाइल खोलता है। (फाइलें खोलने के और भी विकल्प हैं, लेकिन वे I / O के लिए महत्वपूर्ण नहीं हैं।
• CLOSE(unit num) एक फ़ाइल को बंद करता है।

सिंपल आई / ओ

इनपुट और आउटपुट लिखने के एक उदाहरण के रूप में, हम एक वास्तविक मूल्य लेंगे और मूल्य और इसके वर्ग को वापस करेंगे जब तक कि उपयोगकर्ता एक नकारात्मक संख्या में प्रवेश नहीं करता है।

नीचे निर्दिष्ट के रूप में, read कमांड दो तर्क लेता है: इकाई संख्या और प्रारूप निर्दिष्ट करता है। नीचे दिए गए उदाहरण में, हम इकाई संख्या के लिए * उपयोग करते हैं (जो स्टडिन को इंगित करता है) और * प्रारूप के लिए (जो इस मामले में वास्तविक के लिए डिफ़ॉल्ट को इंगित करता है)। हम print स्टेटमेंट के प्रारूप को भी निर्दिष्ट करते हैं। एक वैकल्पिक रूप से write(*,"The value....") उपयोग कर सकते हैं write(*,"The value....") या बस स्वरूपण को अनदेखा करें और इसे इस रूप में देखें

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

जिसके परिणामस्वरूप संभवत: कुछ अजीब तरह से तार और मूल्यों में परिणाम होगा।

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

कुछ त्रुटि जाँच के साथ पढ़ें

एक आधुनिक फोरट्रान उदाहरण जिसमें त्रुटि जाँच और फ़ाइल के लिए एक नई इकाई संख्या प्राप्त करने के लिए एक फ़ंक्शन शामिल है।

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

कमांड लाइन तर्क पारित करना

जहां कमांड लाइन के तर्क समर्थित हैं, उन्हें get_command_argument आंतरिक (फोरट्रान 2003 मानक में पेश) के माध्यम से पढ़ा जा सकता है। कमांड लाइन पर दिए गए तर्कों की संख्या जानने के लिए command_argument_count आंतरिक शामिल है।

सभी कमांड-लाइन तर्क तार के रूप में पढ़े जाते हैं, इसलिए संख्यात्मक डेटा के लिए एक आंतरिक प्रकार रूपांतरण किया जाना चाहिए। एक उदाहरण के रूप में, यह सरल कोड कमांड लाइन पर दिए गए दो नंबरों को बताता है:

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 में संख्या तर्क उपयोगी रूप से 0 और command_argument_count के परिणाम के command_argument_count । यदि मान 0 तो कमांड नाम की आपूर्ति की जाती है (यदि समर्थित है)।

कई संकलक कमांड लाइन के तर्कों को एक्सेस करने के लिए गैर-मानक इंट्रिंसिक्स (जैसे getarg ) भी प्रदान करते हैं। चूंकि ये गैर-मानक हैं, इसलिए संगत संकलक प्रलेखन से परामर्श किया जाना चाहिए।

get_command_argument उपयोग उपरोक्त उदाहरण से परे length और status तर्क के साथ बढ़ाया जा सकता है। उदाहरण के लिए, साथ

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

का मूल्य stat होगा -1 यदि पहला तर्क मौजूद है और 5. से लंबाई अधिक से अधिक है, तो कुछ अन्य कठिनाई तर्क को पुन: प्राप्त है का मूल्य stat कुछ सकारात्मक संख्या होगी (और arg कारतूस की पूरी तरह से शामिल होंगे)। अन्यथा इसका मूल्य 0 होगा।

length तर्क को आस्थगित लंबाई वर्ण चर के साथ जोड़ा जा सकता है, जैसे कि निम्न उदाहरण में।

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)