Fortran forrásának megtekintése

{{Programozási nyelv infobox
| név                    = Fortran
| logó                   = Fortran_acs_cover.jpeg
| paradigma              = [[Többelvű programozási nyelvek|többelvű]]: [[Strukturált programozás|strukturált]], [[Imperatív programozás|imperatív]] ([[Procedurális programozás|procedurális]], [[Objektumorientált programozás|objektumorientált]]), [[Generikus programozás|generikus]]
| megjelent              = 1957
| tervező                = [[John Backus]]
| fejlesztő              = [[John Backus]] & [[IBM]]
| utolsó verzió          = Fortran 2008 (ISO/IEC 1539-1:2010)
| utolsó kiadás dátuma   = 2010
| típus                  = [[Erősen típusos programozási nyelv|erősen típusos]], [[Type system|statikus típus]], [[manifest typing|manifest]]
| megvalósítások = Absoft, [[Cray]], [[Gfortran|GFortran]], [[G95]], [[IBM]], [[Intel Fortran Compiler|Intel]], Lahey/Fujitsu, [[Watcom C compiler|Open Watcom]], Pathscale, [[PGI compiler|PGI]], [[Silverfrost FTN95|Silverfrost]], [[Oracle]], [[XL Fortran]], Visual Fortran és mások
| kiindulási nyelv       = [[Speedcoding]]
| befolyásolt nyelvek    = [[ALGOL|ALGOL 58]], [[BASIC]], [[C (programozási nyelv)|C]], [[PL/I]], [[PACT I]], [[MUMPS]], [[Ratfor]]
| kiterjesztés = <code>.f</code>, <code>.for</code>, <code>.f90</code>, <code>.f95</code>
}}
A '''Fortran''' [[általános célú programozási nyelv|általános célú]] [[programozási nyelv]], melyet elsősorban [[matematika]]i számítások (például mérnöki alkalmazások) megkönnyítésére fejlesztettek ki. Maga a Fortran szó a ''The IBM Mathematical '''For'''mula '''Tran'''slating System'' névből jön (=matematikai képletet fordító rendszer). Eredetileg csupa nagybetűvel írták (FORTRAN-nak), csak később tértek a ma is elfogadott nagy kezdőbetűs (Fortran) írásmódra. A Fortran volt az első ún. [[magas szintű programozási nyelv]]. A nyelvet az [[IBM]] cég fejlesztette ki az [[1950-es évek]]ben, azóta több újabb verziója is megjelent. A különféle Fortran-verziókat eleinte egy-egy római számmal különböztették meg, később pedig évük feltüntetésével a Fortran szó után. A Fortran-verzióik:
<small>

{| class="wikitable"
|'''év''' 
|'''név''' 
|-
|1957
|FORTRAN
|-
|1958
|FORTRAN II
|-
|1958
|FORTRAN III
|-
|1961
|FORTRAN IV
|-
|1966
|FORTRAN 66
|-
|1978
|FORTRAN 77
|-
|1991
|Fortran 90
|-
|1997
|Fortran 95
|-
|2004
|Fortran 2003
|-
|2010
|Fortran 2008
|-
|2018
|Fortran 2018
|-
|2023
|Fortran 2023
|}
</small>
== A jelenleg is használatban lévő verziók ==
* Fortran 66
* Fortran 77
* Fortran 90
* Fortran 95
Új generációs verziók:
* Fortran 2003
* Fortran 2008
* Fortran 2015
* Fortran 2018
* Fortran 2023

Manapság a leginkább elterjedt a 77-es verzió, de egyre népszerűbb a 90-es is. A Fortran 95 a 90-es verzió módosítása, mely 1996-ban jelent meg. Ezeken kívül vannak speciális verziók is, jó példa erre a HPF (High Performance Fortran = nagy teljesítményű Fortran), az F és a Ratfor.

Fontos, hogy a legtöbb Fortran 77-es szerkesztő speciális kiegészítéseket is támogat, pl. nem alapértelmezett kiterjesztéseket is elfogad. E szócikk azonban az alapértelmezett Fortran 77-et, Fortran90-et és Fortan95-öt ismerteti.

Mind a mai napig a Fortran a legelterjedtebb programozási nyelv a mérnöki (és egyéb magas szintű matematikai) számítások elvégzéséhez.{{forrás}} Jelenleg a Fortran a legrégebb óta használatban lévő programozási nyelv. Többi oka is van annak, hogy a Fortran ilyen régóta alkalmazott és előreláthatólag az is marad, ilyen ok például a "szoftver-inercia". Tehát egy cég, amely  hosszú évek során több millió dollárt költött egy megbízható szoftverre, nehezen fog átállni egy újabb nyelvre, főleg annak ismeretében, hogy egy pontos és hiteles szoftver-fordítás és átállás eléggé nehezen kivitelezhető.

==Tulajdonságai==
Habár általános célú nyelvként tartják számon, a Fortrant [[numerikus módszerek|numerikus számításokra]] optimalizálták. Jellegzetes a hatványozás jele: <math>**</math>, és a komplex számok adattípusa (COMPLEX). Szembeszökő, hogy az utasításokat csupa nagybetűvel szokás megadni, bár a legtöbb fordító már kisbetűvel írva is képes megérteni őket. Az már csak kevésbé látható, hogy a szóközök csak a program olvashatóságát, tagoltságát javítják; a szóközök nélkül írt Fortran program ugyanúgy lefordul, és ugyanazt csinálja, mint szóközöket tartalmazó példánya. Így lehet a GO TO GOTO, az ELSE IF ELSEIF, az END DO ENDDO.

A Fortran 90-ben standardizálták a [[vektor]]- és a [[mátrix (matematika)|mátrix]]műveleteket. Ezt segítik a [[MATLAB]] segítségével készült BLAS és LAPACK csomagok. Emellett léteznek még más csomagok is, mint például a LINPACK és EISPACK.<ref>Megjegyzés Cleve Molertől a MATLAB készítőjétől {{cite web | url = http://www.mathworks.com/company/newsletters/news_notes/clevescorner/winter2000.cleve.html | title = MATLAB Incorporates LAPACK | dateformat = mdy | accessdate = December 20 2008 | year = 2000 | month =  | archívurl = https://web.archive.org/web/20091015215812/http://www.mathworks.com/company/newsletters/news_notes/clevescorner/winter2000.cleve.html | archívdátum = 2009-10-15 | archiveurl = https://web.archive.org/web/20091015215812/http://www.mathworks.com/company/newsletters/news_notes/clevescorner/winter2000.cleve.html | archivedate = 2009-10-15 }}</ref> Számos csomag áll rendelkezésre a különféle tudományos és numerikus számításokhoz. A csomagokat nem kell importálni a programba, csak fordításkor kell kapcsolókat megadni.

A Fortran90 lehetőségei többek között a mutatók kezelésében, a saját típusok és a modulok használatának lehetővé tételében nyilvánulnak meg. A Fortran2003 már lehetővé teszi az objektumorientált, a Fortran2008 a párhuzamos programozást.

===Formátum===
A régebbi Fortran programokat kötött formátumban írták, ahol is:
*az első oszlopot a megjegyzés jelének tartották fenn (c, C)
*a második-ötödik oszlopokba kerültek a címkék
*a hatodik oszlop a folytatás jelzésére szolgált
*a hetedik-hetvenkettedik oszlopba kerültek az utasítások

A [[lyukkártya]]-korszakból fennmaradt kötött formátumot a Fortran 90 tette opcionálissá. Egy hasonló megkötés volt, hogy a nevek legfeljebb hat betűsek lehettek. A Fortran 90-ben és 95-ben ez a határ 31; a Fortran 2003-as kiadása 63-ra növelte ezt a hosszt, és azt is lehetővé tette, hogy egy utasítást akár 255 sorba is tördelhessenek. Szabad formátumban a sorvégi & jel jelzi a folytatást. Eredetileg mindent nagybetűkkel írtak; ma a nyelv nagybetűérzéketlen.

===Deklaráció===
Ugyanebből a korszakból maradt fenn az implicit [[deklaráció]] is, ahol az I-N betűvel kezdődő változók egészeket jelölnek a matematikában szokásos módon (INTEGER). A többi betűvel kezdődő név lebegőpontos számot jelent (REAL). Ez a viselkedés azonban felülbírálható:

<syntaxhighlight lang="fortran">
! Minden nem deklarált változó komplex, aminek c-vel vagy z-vel kezdődik a neve
IMPLICIT COMPLEX (c, z)
</syntaxhighlight>

vagy letiltható:

<syntaxhighlight lang="fortran">
IMPLICIT NONE
</syntaxhighlight>

Ezután a nem deklarált változók fordításidejű hibát adnak, ami megkönnyíti a hibakeresést.

===Típusok===
A Fortran alaptípusai: 
*<code>INTEGER</code> egész számok
*<code>REAL</code> lebegőpontos szám
*<code>DOUBLE PRECISION</code> dupla pontosságú lebegőpontos szám
*<code>COMPLEX [[komplex számok|komplex szám]]</code>, két <code>REAL</code>-t tartalmaz
*<code>LOGICAL</code>, logikai érték (<code>.TRUE.</code> vagy <code>.FALSE.</code>)
*<code>CHARACTER</code>, szöveg típus, alapértelmezetten egy hosszúságú

Konstansok deklarálására a <code>PARAMETER</code> kulcsszó szolgál. A szöveges típus hosszát meg kell adni:

Fortran77-ben:
<syntaxhighlight lang="fortran">
       CHARACTER*12 :: USERNAME
C USERNAME legfeljebb 12 karakter hosszú lehet
</syntaxhighlight>
Fortran90-ben:
<syntaxhighlight lang="fortran">
CHARACTER(LEN=12) :: USERNAME !USERNAME legfeljebb 12 karakter hosszú lehet
</syntaxhighlight>

A szöveg értékét aposztrófok között kell megadni. A konkatenáció jele a //.

Szükség lehet arra, hogy egy program mindenütt azonos pontosságú számokat használjon. Ehhez vezették be a KIND-eket. A Fortran77 egyes változataiban, ha egy típus nevét egy csillag és egy szám követte, akkor az a tároláshoz használt bájtok számát jelezte. A Fortran90-be már szabványosítva került be:

<syntaxhighlight lang="fortran">
INTEGER(KIND=2) !Ez -32768 és 32767 közötti értékek tárolására alkalmas.
</syntaxhighlight>

ahol is a KIND a 2 hatványa kell, hogy legyen.

A kevésbé pontos KIND-ek a műveletek közben automatikusan konvertálódnak pontosabb KIND-ekké. Ez azonban csalóka lehet, mert ez pontosabb értéket sejtet a megadottnál, ezért az ilyen műveletek kerülendők.

Szöveges értékekre a KIND a karakterkészlet megválasztását jelenti:

<syntaxhighlight lang="fortran">
CHARACTER(KIND=character_set, LEN=10) :: greek
</syntaxhighlight>

A logikai változókhoz is definiálható KIND, de ez azt jelenti, hogy a két logikai érték egyike tárolódik a megadott számú bájton.

===Alprogramok===
Egy Fortran program lehet főprogram, [[Függvény (programozás)|függvény]] vagy [[szubrutin]]. Főprogram a PROGRAM, függvény a FUNCTION, szubrutin a SUBROUTINE kulcsszóval írható. Mindegyik futása leállítható a STOP utasítással. Végüket END jelzi.

A függvénynek egy, a szubrutinnak több visszatérési értéke lehet. A visszatérési értékek megadásához kötelező a RETURN. Érdemes megadni a függvények és a szubrutinok típusát, mert a kikövetkeztetett típus hibaforrás lehet. A paraméterek típusát a deklarációban kell jelezni. Opcionális paraméterek a Fortran90 óta az OPTIONAL kulcsszóval deklarálhatók. Ha az opcionális argumentumokat nem adjuk meg, akkor létre sem jönnek; ez egy újabb hibaforrás. Paraméter-átadáskor a fordítók nem ellenőrzik a paraméterek típusát, ezért ez szintén hibákhoz vezethet. Szubrutin a neve előtti CALL utasítással hívható. A Fortran hagyományosan cím szerint adja át a paramétereket, vagyis nem másolatokat, hanem címeket ad át.

A Fortran90-től kezdve lehetővé vált a név szerinti paraméter-átadás, a [[rekurzió]] és a modulok használata. A modulok MODULE kulcsszóval deklarálhatók, és deklarációkat, függvényeket, szubrutinokat, vagy interfészeket tartalmazhatnak. Egy modul használatát USE vezeti be. A név szerinti paraméter-átadást interfészek teszik lehetővé, ahol azt is jelezni kell, hogy a változó bemenő (INTENT IN), kimenő (INTENT OUT), vagy mindkettő (INTENT INOUT). Rekurzív függvények a RECURSIVE kulcsszóval és segédfüggvénnyel (RESULT) írhatók. A rekurzív szubrutinokat elég RECURSIVE-nak deklarálni.

===Beágyazott eljárások===
Beágyazott eljárások a Fortran90 óta készíthetők. A gazdaprogramtól CONTAINS kulcsszó választja el, és csak a gazda programból hívhatók. Hozzáférnek a gazda összes változójához; felülírhatják, sőt felüldeklarálhatják őket. A modulokon kívül nem ágyazhatók egymásba; a modulokban a Fortran90-ben egyszintű, a Fortran95-ben és az újabb változatokban tetszőleges szintű beágyazás lehetséges. A beágyazott eljárások az implicit deklaráció megváltoztatását, illetve tiltását is öröklik.

Beágyazott eljárásokkal típuskonstruktorok és generikus eljárások: függvények, szubrutinok is készíthetők.

===Logikai kifejezések és feltételes utasítások===
A két logikai értéket <code>.TRUE.</code> és <code>.FALSE.</code> jelöli. A két pont is a név része, ami segíti a szabadabb névválasztást. Logikai változók a <code>LOGICAL</code> megjelöléssel deklarálhatók. A logikai műveleteket a <code>.NOT.</code> (nem), az <code>.AND.</code> (és) és az <code>.OR.</code> (vagy) valósítja meg. Precedenciájuk szerint a <code>.NOT.</code> a legerősebb, ezt követi az <code>.AND.</code>, és végül az <code>.OR.</code> Az összehasonlító operátorok:
*<code>.EQ.</code> egyenlő
*<code>.NE.</code> nem egyenlő
*<code>.LT.</code> kisebb
*<code>.LE.</code> kisebb-egyenlő
*<code>.GT.</code> nagyobb
*<code>.GE.</code> nagyobb-egyenlő

A Fortran90 óta használhatók a más programnyelvekben megszokott összehasonlító szimbólumok is.

A feltételes utasításokat <code>IF</code> kezdi és <code>END IF</code> zárja. Lehet egy ELSE és több ELSE IF ága. Ha az utasítások nem a feltétel sorában kezdődnek, akkor kötelező a THEN az IF és az ELSE IF ágakban. A feltétel kiválasztása fentről lefelé halad, így a speciálisabb feltételeket előre kell venni. A feltételes szerkezetek egymásba ágyazhatók, de ha túl mély lenne a beágyazás, vagy túl bonyolultak a feltételek, akkor inkább szubrutint kell használni.

===Ciklusok===
A Fortran 77-es verzió szabványában csak egyféle ciklus, a DO ciklus érhető el, ami megfelel a más programnyelvek által használt ''for'' ciklusnak. A while és az until ciklusok szervezéséhez a <code>GO TO</code> utasítás megkerülhetetlen. Sok implementáció azonban már tartalmazta ezeket a ciklusokat is. Ezen úgy segítettek, hogy betették a 90-es szabványba az EXIT utasítást, amivel már nem lehet bárhova elugrani. Ez az utasítás arra szolgál, hogy a vezérlés elhagyja a ciklust, és az az utáni első sorra lépjen.

A ciklus belsejében a C-től eltérően nem lehet megváltoztatni a ciklusváltozót, ezért a futtatások száma ránézésre megállapítható.

Fortran77-ben:
<syntaxhighlight lang="fortran">
c Legyen iFunc() egész értékkel visszatérő függvény .
c A fordítónak csak egyszer kell iFunc-ra hivatkoznia.
DO 100 i = 1, iFunc(4711)
   c.. valami értelmes művelet
   c Nem lehet megváltoztatni i értékét
100 CONTINUE
</syntaxhighlight>

Ugyanez Fortran90-ben:
<syntaxhighlight lang="fortran">
! Legyen iFunc() egész értékkel visszatérő függvény .
! A fordítónak csak egyszer kell iFunc-ra hivatkoznia.
DO i = 1, iFunc(4711)
   !.. valami értelmes művelet
   ! Nem lehet megváltoztatni i értékét
ENDDO
</syntaxhighlight>

Ugyanez az iteráció C-ben:
<syntaxhighlight lang="c">
 for (i = 1; i <= iFunc(4711); i++) {
    /* valami értelmes művelet */
    /* i megváltoztatható */
 }
</syntaxhighlight>

C-ben a ciklust egy logikai kifejezés határozza meg. Az iteráció addig megy, amíg ez a kifejezés igaz. A ciklus törzsében hívott függvények mellékhatásai megváltoztathatják az i változót, ezért nem biztos, hogy annyiszor fut le a ciklus, ahányszor akarjuk. A Fortran 95 óta lehet egy függvényt vagy szubrutint PURE-nak deklarálni, ami megköveteli a mellékhatásoktól való mentességet. Eszerint a bemenő argumentumok nem módosíthatók. Emellett a PURE-nak deklarált függvény vagy szubrutin nem tartalmazhat I/O utasításokat, és a globális változókart sem módosíthatja. Ha ez mégis megtörténne, akkor fordítási hibát kapunk.

===Tömbök===
A Fortranban a [[Tömb (adatszerkezet)|tömbök]] indexelése alapértelmezésben 1-től kezdődik. Egy tömb megadható elemeinek típusával, a nevével és kerek zárójelbe tett hosszával vagy indexhatáraival. A túlindexelést  a fordítók nem figyelik, így ez gyakori hiba. Magasabb dimenziós tömbök is megadhatók, a lehetséges legnagyobb dimenziószám a 7.

Az egydimenziós tömbök kezelhetők vektorként, a kétdimenziósak mátrixként. Teljesen kitöltött mátrixok kezelhetők vektorként is, vagyis lehet őket skálázni, skaláris szorzatukat venni. Függvényekben és szubrutinokban a tömbök méreteinek meghatározása a főprogramra hagyható. Résztömbök indextartományokkal hivatkozhatók. Paraméterként a tömbök helyettesíthetők annyi megfelelő típusú változóval, ahány eleme a tömbnek van. A típusokat a fordítók nem ellenőrzik. A Fortran90 óta lépésköz is használható, tehát lehet például minden második sorra vagy oszlopra hivatkozni.

A Fortran90 óta különféle függvények léteznek a tömbök különböző méreteinek lekérdezésére. A Fortran90 előtt a tömbelemek egymás után oszlopfolytonosan tárolódtak a memóriában, a Fortran90 óta ez nincs meghatározva, akár különböző memóriákba is kerülhetnek az elemek. A tömböket a Fortran nem inicializálja, a frissen létrehozott tömb elemei határozatlanok. Teljes tömbök ciklusokkal tölthetők fel. Régebben szokás volt nagy méretű tömböket deklarálni, és csak részben feltölteni, mivel nem volt dinamikus allokáció. Ez a lehetőség a Fortran90-ben jelent meg először, a deklarációban ALLOCATABLE kulcsszóval, a tulajdonképpeni programban <code>ALLOCATE</code>, illetve DEALLOCATE utasításokkal. Dinamikus tömb csak allokált állapotban használható argumentumként. A tömbelemek feltételes megválasztásához a Fortran90-től kezdve maszkok is készíthetők WHERE feltétel END WHERE blokkal. A blokk egy másik formájában a maszk feltételének nem megfelelő elemekkel is lehet csinálni valamit a blokkban kiadott ELSEWHERE utasítással.

===Stringek===
A stringek a CHARACTER kulcsszóval és hosszukkal deklarálhatók. Ez tulajdonképpen a maximális hosszuk. A stringek nem tömbök, ezért nem allokálhatók, de lehet részstringjeikre indexekkel hivatkozni. A stringek indexelése is 1-től kezdődik. Az üres string és az üres részstring nem megengedett; az egykarakteres részstringre úgy lehet hivatkozni, hogy kezdetét és végét ugyanaz a szám jelöli. A stringekben a Fortran megkülönbözteti a kis- és nagybetűket.

===Globális változók===
A Fortran hagyományosan nem ismeri a globális változókat. Ehelyett közös blokkokat kell létrehozni a COMMON kulcsszóval, két / közé tett névvel és magukkal a blokkba tartozó, előzetesen deklarált változókkal. A közös tömböket minden olyan részprogramba be kell tenni, ahol hivatkoznak rájuk. A névegyezés nem kötelező, a részprogramok csak a sorrendből tudják, hogy melyik változó melyik. [[Típusellenőrzés]] nincs, ezért a közös blokkokat hibaforrásnak tekintik, és lehetőleg mellőzik. Ha mégis használni kell, akkor külön fájlba teszik és INCLUDE-olják mindenhová. A névtelen közös blokk speciális.

===Előre ismert adatok===
Az előre ismert értékű változók a <code>DATA</code> kulcsszóval, névvel és két / jel közé tett értékükkel deklarálhatók. Tömbök is deklarálhatók így. A <code>DATA</code>-ban megadott változók nem kerülhetnek be úgy közös blokkokba, mint a közönséges változók; ezen a <code>BLOCK DATA</code> és egy <code>END</code> közé zárt programrészlet segít. Csak itt lehet őket deklarálni és közös blokkba tenni.

===I/O===
Változók beolvasására a <code>READ</code>, kiíratásra a <code>WRITE</code> utasítás szolgál. A standard be- és kimenet használatához egy csillagot kell utánuk írni, vagy egy zárójelbe két, vesszővel elválasztott csillagot. Az első csillagot helyettesítheti egy I/O egység száma, a másodikat egy <code>FORMAT</code> utasítás kóddal. Ha a FORMAT utasítás helyett csak egy csillag van, akkor az listavezérelt kiíratás, amit fájlba íráskor kerülni kell. Az egységszámok 1 és 99, egyes rendszereken 1 és 255 közé eshetnek. Az előre megnyitott standard bemenet egységszáma az 5, a standard kimeneté a 6. Egy egységen egy időben legfeljebb egy fájl lehet megnyitva, és a Fortran programban összesen legfeljebb 32 fájl lehet egyszerre megnyitva.

A <code>FORMAT</code> utasítás a kiírandó szöveg formázására szolgál. A formátumban használt leggyakoribb kódok:

*A – szöveg
*D – pontosabb valós szám, exponenciális alak (normálalak)
*E – valós szám, exponenciális alak (normálalak)
*F – valós szám, fixpontos formátum
*I – egész
*X – horizontális ugrás olvasáskor, szóköz íráskor
*/ – vertikális ugrás (új sor)

Az E, a D és az F általános formája w.d alakú, ahol w a szám egészrésze, és d a törtrésze. Az egészet jelentő kód után is meg kell adni, hogy milyen hosszú lesz a szám. A szöveget jelentő kódnál is megadható hossz, de nem kötelező. A <code>FORMAT</code> utasítás paramétereként egy ilyen elemekből építkező kódot kell megadni, vagy egy címkét, amivel a kódot tartalmazó sorra mutatunk.

Ha a kiírandó adat túl rövid, akkor a fordítók szóközökkel pótolják ki. Ha az adat [[törtrész]]e túl hosszú, akkor kerekíti. Ha az adat [[egészrész]]e vagy a szöveges adat túl hosszú, akkor figyelmeztetésként csillagokat ír ki.

Csak megnyitott fájlba lehet írni, vagy onnan olvasni. Egyes egységekre megnyitás nélkül írni, illetve a leírtakat kiolvasni nem fordítási hiba, de nem oda kerülnek az információk, ahova akartuk; ilyen például a 39-es egység, ami a szalagos tárhoz volt rendelve. Ma egy új fájlt hoz létre TAPE39 vagy FTN039.DAT névvel. Ez a [[szalagos egység]]ek használatának idejéből maradt fenn, és elavultnak tekintik. Az <code>OPEN()</code> utasításban nagyon sok opció adható meg. A FILE = fájlnévben a fájl elérési útját kell megadni. Az UNIT = egységszám megadása is kötelező. A fájl elérése lehet SEQUENTIAL (=szekvenciális, közvetett) vagy DIRECT (=direkt, közvetlen); alapértelmezésben SEQUENTIAL. A fájl formátuma lehet FORMATTED (=formázott) vagy UNFORMATTED (=formázatlan); alapértelmezésben UNFORMATTED. Formázott esetben meg kell adni a rekordhosszt is, erre a RECL = rekordhossz szolgál. A rekordhossz többnyire megfeleltethető a fájl sorainak hosszával. Használat után a fájlt be kell zárni a CLOSE (egységszám) utasítással.

További opciók az ERR=címke az I/O hiba kezelésének címkéje, STA= a fájl állapota: NEW, ha új, OLD, ha régi, és SCRATCH, ha átmeneti. Bezáráskor a fájl törölhető a CLOSE utasítás a STATUS='DELETE' paraméterrel.

A szekvenciális fájlok rekordonként olvashatók a fájl elejétől a fájl végéig. A Fortran77 nem specifikálta a mutató helyét, ezért megnyitás után az olvasáshoz ki kellett adni a REWIND utasítást, amivel a fájl elejére lehet ugrani. A Fortran90 óta az írásra vagy csak olvasásra megnyitott fájl elejére, a hozzáfűzésre megnyitott fájl végére mozog.

Minden olvasás alapértelmezetten új rekordot olvas be, egészen addig, amíg el nem ér a fájl végéig. Visszafelé a <code>BACKSPACE</code> utasítással lehet mozogni. Új rekordokat csak a fájl végére lehet fűzni; REWIND után írni a fájl tartalmának megsemmisülésével jár. A direkt hozzáférésű fájlokban lehet sorszámmal hivatkozni a rekordokra, de ehhez meg kell adni a rekordhosszt, ami a fájl egész életében állandó marad. A formázott fájlok szövegként írhatók-olvashatók, míg a nem formázottak bináris gépi kódot tartalmaztak és nem hordozhatók, gyakran még azonos típusú gépek és operációs rendszerek között sem.

A szövegfájlok rendszerint formázott szekvenciális fájlok. A nem formázott szekvenciális fájlok az egyes programegységek közötti kommunikációra valók. Egy rekord akár több ezer mezőt is tartalmazhat; ennek csak az operációs rendszer szab határt. A nem formázott direkt elérésű fájlok használata hatékonyabbá teheti a programot, de használatához tudni kell, hogy az adott rendszer milyen mértékegységben méri a rekordhosszt, és hogy egy számot hány bájton tárol. A formázott direkt elérésű fájlok rekordhosszát mindenütt karakterben mérik.

A Fortran90 újabb utasításokkal és paraméterekkel bővítette a fájlkezelés képességeit. Így például <code>APPEND</code>-re megnyitva a mutató eleve a fájl végére van pozicionálva, és különféle tulajdonságok kérdezhetők le a fájl megnyitása után.

===Felhasználói típusok===
Felhasználói típusok a Fortran90 óta TYPE kulcsszóval hozhatók létre:
<syntaxhighlight lang="fortran">
TYPE PONT
REAL x, y, z
END TYPE PONT
</syntaxhighlight>

Ez az adatszerkezet inkább a [[Pascal (programozási nyelv)|Pascal]] rekordjaira és a [[C (programozási nyelv)|C]] nyelv struct-jaira hasonlít, mint osztályokra. Az objektumorientált programozást a Fortran2003 vezette be.

A típusba a % jellel lehet lefúrni:

<syntaxhighlight lang="fortran">
P%x=4.0
P%y=4.0
P%z=5.0
</syntaxhighlight>

Az egyes felhasználói típusok egymásba ágyazhatók. Mélyebbre is le lehet fúrni:
<syntaxhighlight lang="fortran">
golyo%kozeppont%x
</syntaxhighlight>

Az összetett típusok lehetnek tömbelemek, paraméterek vagy visszatérési értékek. Az egyes adatmezők értékei tömbök is lehetnek, kivéve a dinamikus tömböket.

===Pointerek===
A pointereket a Fortran90 vezette be. A pointerek POINTER kulcsszóval és céljuk típusával deklarálandók. A pointerek lehetséges célját TARGET jelöli a deklarációban. Az így megjelölt célra => jellel állítható pointer; ezután a cél hivatkozható a pointer nevével is, de tényleges másolás nem történik. A pointerek hivatkozásait a fordítók automatikusan feloldják. A pointer átállítható egy másik célra, vagy a Null értékre a NULLIFY utasítással.

A pointerek is allokálhatók; ekkor a NULLIFY utasítás [[memóriaszemét|memóriaszemetet]] hagy maga után; helyette deallokálni kell. A pointerek mutathatnak dinamikus tömbökre is. A dinamikus tömbök hatékonyabbak, de a dinamikus pointerek flexibilisebbek.

A pointerek lehetnek argumentumok, de csak INTENT deklaráció nélkül. Használatuk interfészt igényel. Lehetnek visszatérési értékek is. Lehetnek tömbök elemei, mezőértékek is.

==Újabb változatok==
A Fortrannak több átdolgozott kiadása is megjelent a Fortran90 óta, de ezek nem terjedtek még el széles körben.
===Fortran95===
A Fortran95 újdonságai:
*<code>FORALL</code> és beágyazott <code>WHERE</code> szerkezetek a vektorizáció megkönnyítésére
*<code>PURE</code> és <code>ELEMENTAL</code> eljárások
*A származtatott típusok és a pointerek inicializálása
*A <code>DATA</code>-ban foglaltak inicializálási lehetőségeinek bővítése
*Az allokált tömbök automatikus deallokálásása a hatókör elhagyásával

Több belső függvény használatának körét bővítették, például a MAXLOC kaphat egy dim paramétert.

Eltávolítottak néhány, a régi programozási gyakorlatban használt eszközt, amik azonban számos hibalehetőséget hordoztak magukban:
*<code>REAL</code> és <code>DOUBLE PRECISION</code> ciklusváltozók
*Ugrás blokkon kívüli <code>END IF</code>-re
*H formátumleíró
*Számított címkéjű GO TO utasítások

A Fortran95 kibővítette az allokálható tömbök használati körét. Így lehetnek típusmezők, paraméterek és visszatérési értékek. Az automatikus deallokáció miatt ezzel elmúlik a memóriaszivárgás veszélye, ami pointerek esetén fennáll. Egy másik hasznos lehetőség a lebegőpontos kivételkezelés.

A Fortran95 két opcionális modult is tartalmaz, amik lehetővé teszik a változó hosszúságú stringek kezelését és a feltételes fordítást. Ezek azonban nem érhetők el mindenütt, így hordozható program nem használhatja őket.

===Fortran2003===
A Fortran2003 sok új, objektumelvű eszközt vezetett be. A Fortran Munkacsoport honlapján összefoglaló érhető el róluk.<ref>[http://www.nag.co.uk/sc22wg5/ Fortran Working Group (WG5)] {{Wayback|url=http://www.nag.co.uk/sc22wg5/ |date=20110423074710 }}. Letölthető, mint [ftp://ftp.nag.co.uk/sc22wg5/N1551-N1600/N1579.pdf PDF file]{{Halott link|url=ftp://ftp.nag.co.uk/sc22wg5/N1551-N1600/N1579.pdf |date=2018-07 }} or [ftp://ftp.nag.co.uk/sc22wg5/N1551-N1600/N1579.ps.gz <code>gzip</code>-peltömörített PostScript fájl]{{Halott link|url=ftp://ftp.nag.co.uk/sc22wg5/N1551-N1600/N1579.ps.gz |date=2018-07 }}, FTP.nag.co.uk</ref>
*A felhasználói típusok lehetőségeinek kibővítése: parametrizálhatóság, a hozzáférés ellenőrzése, konstruktorok és finalizátorok
*Öröklődés, polimorfizmus, dinamikus típusallokáció, és típushoz kapcsolódó eljárások
*Az adatkezelés lehetőségeinek bővítése: allokálható komponensek, VOLATILE attributum, explicit típusspecifikáció tömbkonstruktorokban, allokáló utasítások, a pointerkezelés képességének bővítése, a belső eljárások képességeinek bővítése, kiterjesztett inicializáló kifejezések
*Input-output: aszinkron adatátvitel, adatáram hozzáférés, saját típusokhoz készíthető író-olvasó műveletek, a formátum konverziókban történő kerekítések ellenőrzése, az automatikusan megnyitott egységek nevei, kulcsszavak regularizációja, FLUSH utasítás, és hozzáférés a hibaüzenetekhez
*Eljáráspointerek
*Lebegőpontos hibakezelés és IEEE szerinti lebegőpontos aritmetika
*A C nyelvvel való együttműködés javítása, a képességek megfeleltetése
*Nemzetköziség: ISO 10646 négy bájtos karakterek kezelése, tizedespont helyett tizedesvessző választása az I/O utasításokban
*Az operációs rendszerrel való együttműködés: hozzáférés parancssori argumentumokhoz, környezeti változókhoz, és a processzor hibaüzeneteihez
*Almodulok, a modulok specifikációjának és implementációjának szétbontása különböző alprogramokba. Ez javítja a nagy könyvtárak áttekinthetőségét, támogatja az üzleti titkok megőrzését, és segít elkerülni a fordítási kaszkádokat.
===Fortran2008===
A Fortran2008 nevével ellentétben 2010-ben jelent meg. Az új képességek a párhuzamos programozást támogatják.<ref>N1836, Summary of Voting/Table of Replies on ISO/IEC FDIS 1539-1, Information technology - Programming languages -
Fortran - Part 1: Base language {{PDFlink|ftp://ftp.nag.co.uk/sc22wg5/N1801-N1850/N1836.pdf| 101&nbsp;KiB<!-- application/pdf, 101k bytes -->}}</ref> 
*Almodulok, a modulok további strukturálása
*CO-tömbök, párhuzamos végrehajtási modell<ref>N1830, Information technology – Programming
languages – Fortran – Part 1: Base language {{PDFlink|ftp://ftp.nag.co.uk/sc22wg5/N1801-N1850/N1830.pdf| 7.9&nbsp;MiB<!-- application/pdf, 7.9M bytes -->}}</ref>
*DO CONCURRENT, függetlenül végrehajtható iterációk
*CONTIGUOUS attributum, tárolási szabályok specifikálása
*BLOCK szerkezet, lokális hatókörű objektumok deklarálását tartalmazhatják
*Rekurzív allokálható komponensek, a felhasználói típusok rekurzív pointereinek alternatívája

===Fortran 2015===

A nyelv tervezett következő továbbfejlesztése a Fortran 2015 csak kisebb változtatásokat fog tartalmazni. A tervek közt szerepel további átjárhatóság a Fortran és a C között, további párhuzamossági funkciók, és az "egyszerű hiányosságok, és létező funkciók közötti különbségek eltávolítása".<ref name="Fortran2015">{{cite web|url=http://software.intel.com/en-us/blogs/2013/08/08/doctor-fortran-goes-dutch-fortran-2015|title=Doctor Fortran Goes Dutch: Fortran 2015}}</ref>

==Fordítók==
Fortran-fordítók minden számítógépre léteznek, a munkaállomásoktól a [[szuperszámítógép]]ekig.
===Kereskedelmi szoftverek===
A kereskedelmi fordítók fő szállítói a számítógépgyártók, mint az [[IBM]], a [[Sun Microsystems]], a [[Hewlett-Packard|HP]], az [[Intel]], vagy szoftvergyártók, mint az [[Absoft]], a [[PGI]], a [[NAG]], a [[Lahey]], vagy a [[Salford]]. Tisztán Fortran77-fordítókat ma már nem készítenek, mert a Fortran95 majdnem a teljes Fortran77-et tartalmazza, csak néhány hibaforrást távolítottak el belőle.

Egyes termékek magánfelhasználóknak és nem kereskedelmi célokra ingyenes próbaverzióban is elérhetők, mint [[Linux]]ra az Intel-Fortran-Compiler, a Sun Studio Express, [[Windows]]ra a Salford fordítója, és a [[Digital Equipment Corporation|DEC]] Fortran az [[OpenVMS]] számára.
===Szabad szoftverek===
A majdnem minden platformra elérhető GNU Compiler Collection (GCC) a 4.0-s verzió óta tartalmaz Fortran95 fordítót (GNU Fortran). A GCC korábbi verziói még a Fortran77-hez tartalmaznak fordítót. Emellett a G95 egy másik fordító a Fortran95-höz.<ref>[http://g95.org/ G95]</ref> Ezen alapul a 2003 gfortran. Az OpenWatcom fejlesztői is megalkották saját FORTRAN-77-fordítójukat.<ref>{{Cite web |url=http://www.openwatcom.org/ |title=OpenWatcom |accessdate=2019-11-09 |archiveurl=https://web.archive.org/web/20180715032145/http://www.openwatcom.org/ |archivedate=2018-07-15 }}</ref>
===Keresztfordítók===
Vannak keresztfordítók, amik a Fortran77-ben készült programokat automatikusan C nyelvre fordítják. Ilyen fordító például az f2c. Az így készült C kód azonban nehezen olvasható.<ref>{{Cite web |url=http://www.netlib.org/f2c/ |title=f2c |accessdate=2011-10-08 |archiveurl=https://web.archive.org/web/20111005053835/http://www.netlib.org/f2c/ |archivedate=2011-10-05 }}</ref> A NAG-fordító a C-t köztes nyelvként használja.
===Nyelvi támogatás===
Míg a legtöbb fordító a teljes Fortran95 szabványt támogatja, addig a Fortran2003 és a Fortran2008 képességeinek csak egy része érhető el. A Cray és az IBM fordítója azonban a Fortran2003 összes képességét használja.<ref>Ian D. Chivers, Jane Sleightholme, ''Compiler support for the Fortran 2003 standard'', [http://doi.acm.org/10.1145/1520752.1520755 ACM SIGPLAN Fortran Forum ''29'', 2 (2009).]</ref>

==Humor==
A Fortran77-hez volt egy javaslat, ami betiltotta volna az O betű használatát a változónevekben, hogy ne lehessen összetéveszteni a 0 számjeggyel. Mivel a javaslat ''A kártékonynak tekinthető O betű'' nevet viselte, ezért sokan arra gondoltak, hogy az O betűt teljesen ki fogják törölni az ábécéből. Ennek előnyei közé tartozott volna a GO TO utasítás kiküszöbölése, és a nehézkes FORMAT utasítások kivezetése; a GO TO törlése kikényszerítette volna a strukturált programozást. Megjegyezték, hogy ezután egyes régebbi programok nem futnának, de ezek legtöbbje nem lenne konform.<ref>X3J3 post-meeting distribution for meeting held at Brookhaven National Laboratory in November 1976.</ref><ref>"The obliteration of O", Computer Weekly, March 3, 1977</ref>

Amikor a bizottság azt kezdte el vitatni, hogy a DO ciklus minimális végrehajtási száma 0 (elöltesztelő) vagy 1 (hátultesztelő) legyen, Loren Meissner azzal az ötlettel állt elő, hogy a minimális végrehajtási szám 2 legyen. Ezt azzal indokolta, hogy ha valamit egyszer akarunk megcsinálni, akkor oda nem kell ciklus.

== Jegyzetek ==
{{jegyzetek}}

== Források ==
*Professional Programmers Guide to Fortran77
* [http://nimbus.elte.hu/oktatasi_anyagok/fortran/02_miajo.html nimbus.elte.hu]
* [http://people.cs.vt.edu/~asandu/Deposit/Fortran95_notes.pdf Adrian Sandu: Introduction to Fortran 95 and Numerical Computing. A Jump-Start for Sciencist and Engineers] {{Wayback|url=http://people.cs.vt.edu/~asandu/Deposit/Fortran95_notes.pdf |date=20100623174633 }}

== További információk ==

* Lőcs Gyula, Vigassy József: ''A fortran programozási nyelv,'' Műszaki könyvkiadó, Budapest, 1970
{{IBM}}
{{Főbb programozási nyelvek}}
{{Nemzetközi katalógusok}}
{{Portál|Informatika|i }}

[[Kategória:Programozási nyelvek]]
[[Kategória:IBM]]