Premiers pas en F90

Exemple de programme

Structure

program nom_du_programme declaration des variables
instructions
end program nom_du_programme

Les variables

– variables : noms (chaˆınes de caract`eres alphanum´eriques plus quelques autres, cf. section 2.4) permettant de manipuler des donn´ees en m´emoire.
– op´eration essentielle : l’affectation (symbole =) exemple : variable n (entier) :
n=2
n=n+1
! – – p r e n d l a v a l e u r 2 ! – – a u g m e n t e d e 1
ce n’est pas une egalit´ mais une op´eration : la valeur de n stock´ee en m´emoire est remplac´ee par elle-mˆeme plus 1.
– le bloc d´eclaration des variables sert a` indiquer a` la machine quel est le type de chaque variable utilis´ee afin de r´eserver la place en m´emoire n´ecessaire.
– d´eclaration implicite : bien que f90 ne l’exige pas, il est prudent de d´eclarer toutes les variables. Pour ´eviter les oublis, placer l’instruction implicit none au d´ebut du bloc d´eclaration. Les oublis sont alors d´etect´es `a la compilation.
– les tableaux : tous les types pr´ec´edents peuvent ˆetre structur´es en tableaux avec l’attribut dimension
i n t e g e r , d i m e n s i o n ( −2 : 2 ) : : dim
r e a l , d i m e n s i o n ( 1 : 3 , 0 : 4 , 1 :20) : : tab
c h a r a c t e r , d i m e n s i o n ( 1 : 3 , 4:6) : : tch
→ chaque argument de dimension indique les bornes de la dimension correspondante par un intervalle en-tier min:max
→ acc`es aux composantes :
dim ( 0 ) = 1 0
tab ( 2 , 3 , 2 0 ) = 2 . 3 e−5
tch ( 1 , 5 ) = ’ a ’

Les identificateurs

– caract`eres du clavier permettant de nommer une va-riable ou un autre el´ement du programme ;
– suite de 1 a` 31 caract`ere alphanum´eriques parmi : lettres sans accents majuscules et minuscules, chiffres, caract`ere (soulign´e) ;
– le 1ER caract`ere doit ˆetre une lettre ;
– les majuscules et minuscules ne sont pas diff´erenti´ees ;
– exemple :
→ les identificateurs suivants sont valides :
constante_gaz
pi2
Rk54
→ les identificateurs suivants ne sont pas valides :
accentu´e avec espace
Il_y_a_plus_de_trente_et_un_caracteres _souligne_devant
1 _chiffre_devant nom#alphanumerique

Continuation de ligne : caract`ere &

– une ligne d’instructions comporte au maximum 132 caract`eres
– si plus de 132 ⇒ message d’erreur :
write(*,*) ’Au clair de la lune, mon ami Pierrot. Prete moi ta plume, pour ecrire un mot. Ma chandelle est morte, je n ai plus de feu. Ouvre moi la porte pour l amour de dieu’
Error : Unterminated character constant beginning at (1)

Les commentaires : symbole !

– tout ce qui est a` droite du symbole ! est ignor´e par le compilateur
– cela permet d’´ecrire des commentaires dans le pro-gramme, c.-a`-d. du texte qui en explique le fonction-nement
– le ! peut ˆetre plac´e n’importe o`u dans la ligne (au d´ebut, au milieu, a` la fin), et a` n’importe quel endroit du programme
– exemple : voir le programme page 30.

Les structures de contrˆole

Ce sont des instructions qui permettent de faire des it´erations ou des tests sur des variables.

Le test if

– exemple : calcul de la valeur y = x LN x SI x=0 0SINON
i f ( x / = 0 . 0 ) t h en
y = x∗log ( x )
e l s e
y = 0 . 0 end i f
– syntaxe g´en´erale :
[ nom : ] i f ( expression logique ) t h en
instructions
[ e l s e i f ( expression logique ) t h en
instructions ]
[ e l s e
instructions ]
end i f [ nom ]
o`u nom permet de donner un nom `a la structure pour une meilleure lisibilit´e du programme (par exemple en cas de if imbriqu´es)
– expression logique est une combinaison d’un ou plusieurs tests sur des variables, ainsi que des trois operateurs logiques

1 Introduction 
1.1 Qu’est-ce qu’un programme informatique ?
1.2 Le langage F90 : generalites
2 Premiers pas en F90 
2.1 Exemple de programme
2.2 structure
2.3 Les variables
2.4 les identificateurs
2.5 Continuation de ligne : caractere &
2.6 Les commentaires : symbole !
2.7 Les structures de controle
2.7.1 Le test if
2.7.2 La s´election select case
2.7.3 It´erations : structure do
2.8 Les entr´ees-sorties ´ecran/clavier
2.9 Compilation
2.10 Execution
2.11 Ecrire un programme proprement
2.12 Exemple complet
3 Un peu plus loin 
3.1 Variables “constantes”
3.2 Sous-programmes
3.2.1 Objectif
3.2.2 Fonctionnement
3.2.3 Arguments d’une subroutine
3.2.4 Arguments d’une fonction – d´eclaration du r´esultat
3.2.5 Les tableaux en arguments
3.2.6 Les chaˆınes en arguments
3.3 Tableaux
3.4 Entr´ees-sorties (E/S)
3.5 Trouver des erreurs dans un programme
4 Programmation modulaire
4.1 Introduction
4.1.1 Qu’est-ce-que c’est ?
4.1.2 Interet
4.2 Les procedures internes
4.3 Les procedures externes
4.4 Les modules
4.5 Compilation separee
5 Utilisation avancee 
5.1 Types derives
5.2 Pr´ecision des reels
5.3 Fonctions de fonctions
5.4 Interface generique
5.5 Creation de nouveaux operateurs
5.6 Ressources privees, publiques, semi-privees
5.7 Pointeurs
References