Discussion :

[nyme92]

Bonjour,
Gros trou :
comment récupérer "une_valeur" calculée dans "machin" dans le prog principal
Merci.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
program truc
integer valeur
.
.
call machin(avec ou sans parametres)
valeur=une_valeur
.
.
end
 
subroutine machin(...)
une_valeur=f(variable interne ou externe)
end

[afrancisco]

Salut,

Je te propose les 2 méthodes suivantes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
program truc
implicit none
integer :: valeur, une_valeur
.
call machin(avec ou sans parametres)
valeur=une_valeur
.
contains
 
subroutine machin(...)
implicit none
une_valeur=f(variable interne ou externe)
end
 
end program

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
program truc
implicit none
integer :: valeur, une_valeur
.
call machin(une_valeur)
valeur=une_valeur
.
end program
 
subroutine machin(une_valeur)
implicit none
integer, intent(out) :: une_valeur
une_valeur=f(variable interne ou externe)
end

[nyme92]

Merci.
Cependant, c'est du 77? J'utilise gfortran. DE ce que je comprends de ton code tu déclare une_valeur comme globale mais tu la passes comme parametre quant même.
Et intent(out), je ne connais pas, mais apparemment cela permet de la renvoyer ?
Merci.

[genteur slayer]

alors, les intent, c'est du F90 cela permet de déclarer une variable paramètre d'une subroutine/fonction comme entrante sortante ou les deux...

cela dit, si tu est en 77 tu peux utiliser la seconde solution de afransico sans les intent et ce devrai être bon...

sinon troisième solution, tu transforme ta subroutine en fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
program truc
implicit none
integer valeur
.
.
valeur= machin(avec ou sans parametres)
 
.
.
end
 
function machin(...)
impliciti none
integer machin
une_valeur=f(variable interne ou externe)
machin=une_valeur
return
end

il est préférable, de mettre return en fin de fonction, mais aussi de subroutine...

[nyme92]

Merci.
Le :: ce n'est pas du 77 il me semble ? Et désigne quoi? J'ai déjà vu cela en c++ mais je ne pense pas que cela fasse la même chose puisque c'est dans le contexte de la création d'objet à partir d'une classe (évidemment).
Donc, je retiens qu'en 77 ma question n'a pas de réponse, et qu'une façon est de transformer la routine en fonction.
Il est vrai que si je n'ai qu'une valeur à ressortir cela paraît le choix logique.
A confirmer, je vais essayer.
Merci.

[DaZumba]

Donc, je retiens qu'en 77 ma question n'a pas de réponse, et qu'une façon est de transformer la routine en fonction.

Tu peux passer par un COMMON BLOCK, mais c'est moche. Sinon, il semble en effet assez logique de passer la valeur que tu souhaites retourner en argument d'une subroutine ou en valeur retournee par une fonction.

[nyme92]

passer la valeur que tu souhaites retourner en argument d'une subroutine ou en valeur retournee par une fonction.

la question d'origine concerne le retour d'un ou plusieur valeur(s) à partir d'un subroutine : comment ?
La fonction est plus logique mais ne permet qu'une seule valeur.

[genteur slayer]

et bien tu peux tout à fait renvoyé un tableau par une fonction.

et pour le ::, c'est juste pour séparé le type (+option) du/des noms de variables exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

integer a

est équivalent à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

integer ::a

ces :: deviennent indispensable quand tu mets des options sur ta variable exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

integer,dimension(N) :: a

de plus tu peux aussi passer un tableau par paramètre dans une fonction ou une subroutine. il me semble qu'en 77 il n'y a pas les tableaux dynamique (ALLOCATABLE) mais bon tu defini un tableau suffisament grand pour tes différents cas et hop!

si j'essaye de le faire en 77 cela donnerai un truc du style:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
C234567
       program toto
       implicit none
       parameter (N=100)
       integer valeur
       dimension valeur(N)
     ....
       call titi(valeur,N)
     ....
       end
 
       subroutine titi(valeur,N)
       implicit none
       integer valeur,N
       dimension valeur(*)
     ....
       valeur(1)=...
       valeur(8)=...
     ....
       return
       end

[DaZumba]

la question d'origine concerne le retour d'un ou plusieur valeur(s) à partir d'un subroutine : comment ?

Ben, c'est trivial. Une routine accepte des arguments pour communiquer avec le code appelant.
En Fortran 77:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
      program toto
      implicit none
 
      real a, b
 
      call set_a_and_b(a, b)
      print *, a, b 
      end
 
      subroutine set_a_and_b(a, b)
      real a, b
 
      a = 42.0
      b = 53.0
      end

[nyme92]

et bien tu peux tout à fait renvoyé un tableau par une fonction.

et pour le ::, c'est juste pour séparé le type (+option) du/des noms de variables exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

integer a

est équivalent à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

integer ::a

ces :: deviennent indispensable quand tu mets des options sur ta variable exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

integer,dimension(N) :: a

mais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
integer,dimension(N) :: a    = integer a(N)

de plus tu peux aussi passer un tableau par paramètre dans une fonction ou une subroutine. il me semble qu'en 77 il n'y a pas les tableaux dynamique (ALLOCATABLE) mais bon tu defini un tableau suffisament grand pour tes différents cas et hop!

si j'essaye de le faire en 77 cela donnerai un truc du style:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
C234567
       program toto
       implicit none
       parameter (N=100)
       integer valeur
       dimension valeur(N)
     ....
       call titi(valeur,N)
     ....
       end
 
       subroutine titi(valeur,N)
       implicit none
       integer valeur,N
       dimension valeur(*)
     ....
       valeur(1)=...
       valeur(8)=...
     ....
       return
       end

Donc cela veut bien dire que les valeurs calculées dans la subroutine doivent être déclarées en global ET dans la subroutine.

[DaZumba]

Donc cela veut bien dire que les valeurs calculées dans la subroutine doivent être déclarées en global ET dans la subroutine.

Il n'y a pas de variables globales en Fortran. Quand aux declarations, chaque variable doit etre definie au point d'utilisation (point d'entree, sous-routines, et fonctions).
Quel est ton niveau en Fortran? Cela permettra de donner des reponses plus adaptees.

[nyme92]

Il n'y a pas de variables globales en Fortran. Quand aux declarations, chaque variable doit etre definie au point d'utilisation (point d'entree, sous-routines, et fonctions).
Quel est ton niveau en Fortran? Cela permettra de donner des reponses plus adaptees.

Intéressant.
Effectivement, les variables sont toutes locales. J'ai confondu sans doute avec un autre langage, Pascal peut-être (à force d'utiliser des langages on y perd son latin).
Pour répondre à ta question, j'en fait depuis 92 mais je ne me suis jamais posé la question. Ce n'est que parce que je suis en train de reprendre un prog laissé de côté depuis longtemps que je me suis posé la question.

Alors, si j'utilise A dans le prog principal, puis A dans une sub mais pour autre chose, ce seront deux A différents. Sans doute pointent-ils vers des adresses différentes.
Donc la valeur de A obtenue dans la sub ne sera pas repercutée dans le prog principal.

[DaZumba]

Alors, si j'utilise A dans le prog principal, puis A dans une sub mais pour autre chose, ce seront deux A différents. Sans doute pointent-ils vers des adresses différentes.

Non. Le Fortran passe les variables par reference (comme le & du C++) et non par valeur comme le C. Mais cela ne veut pas dire qu'on n'a pas a definir les variables dans chaque sous-programme. Du point de vue du compilateur, les blocs definis par program...end, subroutine...end et function...end sont des entites independantes (heureusement, sinon on aurait du mal a faire de la compilation separee).

Donc la valeur de A obtenue dans la sub ne sera pas repercutée dans le prog principal.

Si, c'est le but. Voir l'exemple que j'ai poste precedemment.

[nyme92]

Non. Le Fortran passe les variables par reference (comme le & du C++) et non par valeur comme le C. Mais cela ne veut pas dire qu'on n'a pas a definir les variables dans chaque sous-programme. Du point de vue du compilateur, les blocs definis par program...end, subroutine...end et function...end sont des entites independantes (heureusement, sinon on aurait du mal a faire de la compilation separee).


Si, c'est le but. Voir l'exemple que j'ai poste precedemment.

Donc le but des subs et fns est uniquement du déplacement de code afin d'en faciliter la visibilité. Il n'y a aucune fioriture de portée de variables.
Celles-ci doivent être déclarées où elles sont utilisées.

[DaZumba]

Donc le but des subs et fns est uniquement du déplacement de code afin d'en faciliter la visibilité.

Et la factorisation du code. C'est comme dans la plupart des autres langages.

Il n'y a aucune fioriture de portée de variables.

Par rapport au C, le Fortran ne possede pas les portees globales et de bloc. Mais il y a evidemment la portee locale. Une variable locale a une fonction ou une sous-routine n'existe que jusqu'au retour de celle-ci. Pour les arguments, puisqu'ils sont passes par references, toute modification est passee a l'appelant, sauf si on utilise les intent dont on t'a parle plus haut.

Celles-ci doivent être déclarées où elles sont utilisées.

Oui. Le compilateur a besoin de connaitre le type et le nombre d'element de tous les objets qu'il manipule. Jadis, il etait courant d'utiliser un typage implicite, via la premiere lettre du nom de la variable. Ce n'est plus conseille aujourd'hui, et on precise souvent implicit none au debut de chaque sous-unite du programme (point d'entree, fonctions, sous-routines, modules).

[FR119492]

Salut!
Il est évident qu'il existe une solution: sinon des subroutines qui ne permettraient pas de renvoyer des résultats au programme principal ne serviraient à rien. Mais tu dois être conscient qu'en Fortran "classique", il n'y a aucun lien entre le nom d'une variable dans le programme principal et celui de la même variable dans le sous-programme; seul compte la position dans la séquence des paramètres. Je te propose donc la solution suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
      Program Main
      Implicit None
      Integer a,b,c,d
      a=53
      b=34
      Call Sous(a,b,c,d)
      Write (*,*) c,d
      Stop
      End
C
      Subroutine Sous(w,x,y,z)
      Implicit None
      Integer w,x,y,z
      y=w+x
      z=w-x
      Return
      End

Si je ne me suis pas trompé, ça devrait marcher.

Maintenant, il peut arriver que ta subroutine existe déjà. Dans ce cas, il te suffit d'ajouter à la liste des paramètres la variable locale à laquelle tu veux accéder.

Jean-Marc Blanc

[feynman]

je ne penses pas que tu as besoin d un stop a la fin de ton programme Jean Marc

[nyme92]

Et la factorisation du code. C'est comme dans la plupart des autres langages.


Par rapport au C, le Fortran ne possede pas les portees globales et de bloc. Mais il y a evidemment la portee locale. Une variable locale a une fonction ou une sous-routine n'existe que jusqu'au retour de celle-ci. Pour les arguments, puisqu'ils sont passes par references, toute modification est passee a l'appelant, sauf si on utilise les intent dont on t'a parle plus haut.


Oui. Le compilateur a besoin de connaitre le type et le nombre d'element de tous les objets qu'il manipule. Jadis, il etait courant d'utiliser un typage implicite, via la premiere lettre du nom de la variable. Ce n'est plus conseille aujourd'hui, et on precise souvent implicit none au debut de chaque sous-unite du programme (point d'entree, fonctions, sous-routines, modules).

Ok, merci de ce rappel!

[nyme92]

Salut!
Il est évident qu'il existe une solution: sinon des subroutines qui ne permettraient pas de renvoyer des résultats au programme principal ne serviraient à rien. Mais tu dois être conscient qu'en Fortran "classique", il n'y a aucun lien entre le nom d'une variable dans le programme principal et celui de la même variable dans le sous-programme; seul compte la position dans la séquence des paramètres. Je te propose donc la solution suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
      Program Main
      Implicit None
      Integer a,b,c,d
      a=53
      b=34
      Call Sous(a,b,c,d)
      Write (*,*) c,d
      Stop
      End
C
      Subroutine Sous(w,x,y,z)
      Implicit None
      Integer w,x,y,z
      y=w+x
      z=w-x
      Return
      End

Si je ne me suis pas trompé, ça devrait marcher.

Maintenant, il peut arriver que ta subroutine existe déjà. Dans ce cas, il te suffit d'ajouter à la liste des paramètres la variable locale à laquelle tu veux accéder.

Jean-Marc Blanc

Effectivement, je me souviens de cette histoire d'ordre de position des variables. Merci à toi aussi.