Discussion :

[leup]

Bonjour,

j'écris un programme en fortran 90 et il se trouve que je suis face à une question toute bête. Je veux écrire plusieurs modules et dans chacun avoir une fonction d'initialisation. J'aurais bien vu de pouvoir les appeler donc "initialisation()". Mais à priori si par exemple dans mon programme j'Use plusieurs modules, je risque d'avoir une ambigüité si j'essaie de call la routine "initialisation()". (Admettons qu'il est possible qu'au moins 2 d'entre elles aient exactement les mêmes arguments..)

Est-il possible, en F90, de spécifier lors d'un call le nom du module auquel appartient la fonction appelée ?

[afrancisco]

Salut,

Je te propose :

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
23
24
25
26
27
28
module toto
contains
subroutine initialisation
end subroutine initialisation
end module toto
 
module tata
contains
subroutine initialisation
end subroutine initialisation
end module tata
 
module titi
contains
subroutine initialisation
end subroutine initialisation
end module titi
 
program tordu
use toto, only initialisation => toto_init
use tata, only initialisation => tata_init
use titi, only initialisation => titi_init
 
call toto_init()
call tata_init()
call titi_init()
 
end program tordu

mais je ne suis pas sûr que cela :

• marche
• soit pertinent !!

[genteur slayer]

sinon y a un truc un peu bourrin: tu crée un module "maitre", c'est à dire un truc du genre:

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
module titato
  interface
    subroutine initialisation(P1)
       implicit none
       integer,intent(in) :: P1
    end subroutine initialisation
!
    subroutine initialisationtata
    end subroutine initialisation
!
    subroutine initialisationtiti
    end subroutine initialisation
!
    subroutine initialisationtoto
    end subroutine initialisation
! 
  end interface
end module titato
!********************
subroutine initialisation(P1)
  use titato,only : initialisationtata,initialisationtiti,initialisationtoto
  implicit none
  integer,intent(in) :: P1
  if (P1==1) call initialisationtata()
  if (P1==2) call initialisationtiti()
  if (P1==3) call initialisationtoto()
end subroutine initialisation
!
subroutine initialisationtata
   use tata,only : init
   call init
end subroutine initialisation
!
subroutine initialisationtiti
   use titi,only : init
   call init
end subroutine initialisation
!
subroutine initialisationtoto
   use toto,only : init
   call init
end subroutine initialisation
!

du coup, tu as un module en plus, et si tu rajoute des fonctions, il faut aussi les rajouter dans le module "maitre, donc c un peu bourrin mais cela doit marcher... c'est pas très propre...

sinon:

Code :

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

1
2
3
4
 
use toto, only : initialisation => toto_init
use tata, only : initialisation => tata_init
use titi, only : initialisation => titi_init

ou

Code :

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

1
2
3
4
 
use toto, initialisation => toto_init
use tata, initialisation => tata_init
use titi, initialisation => titi_init

le premier cas (afrancisco tu avais oublié les ":") tu ne peux utiliser que la fonction que tu déclare devant le ONLY et que tu renome...
le second, tu peux utiliser toutes les fonctions et variables du module, mais tu renomme la fonction initialisation...

et cela marche ça normalement en F90/95, je suis pas sûr en revanche que le F77 marche avec ça...

[Ladgalen]

Bonjour

En ce qui concerne F77 je ne pense pas que ça marche vu que les modules sont une nouveauté du F90.

Sinon, si je peux faire un petit commentaire, je trouve que l'idée de subroutine du même nom dans des modules différents d'un même programme c'est un peu chercher le baton pour se faire battre ou encore pourquoi faire simple quand on peut faire compliqué.

Du point de vu de l'exercice et de savoir utiliser only ect ... c'est bien , mais d'un point de vue utilisation debueugage ou autre c'est un peu limite. Imagine le mec qui va mettre son nez dans ton programme. Il faudra déjà qu'il trouve que les subroutine x sont dans le module Y mais en plus il faudra qu'il se rappelle que dans la subroutine Y elle s'appelle Z ... c'est un peu compliqué

[genteur slayer]

je suis d'accord, on peut faire LARGEMENT plus simple... cela dit je comprend un peu l'idée: faire comme dans le c++ avec "class.methode()"

dans l'idée la fonction "init" s'aparente un peu à un constructeur ou quelquechose comme ça

sionon, Joke à propos de gars qui doit relire ce programme: "un informaticien dois savoir se rendre indispensable"

[leup]

Re-bonjour,

je débarque un peu après quelques jours et je lis avec attention vos réponses.

Donc, merci, je pense que la solution avec le "initialisation => toto_init" est celle que je choisirai si j'ai à désambigüiser deux routines du même nom.

En effet, c'est avant tout une question théorique parce que je me pose la question de le faire ou non. Et donc je voulais savoir si c'était possible avant de décider de la marche à suivre.

C'est vrai que j'ai de l'objet dans la tête et que ça n'est sans doute pas la meilleure idée. D'un autre coté, j'aime l'idée qu'un développeur sache que dans chacun des modules fournis, il y a une fonction initialisation(..) et que c'est à celle là qu'il doit se référer avant toute utilisation du module. Une espèce de convention quoi. Mais peut être que pour trancher la poire en deux, je vais nommer ces routines du style "NomModule_initialisation". Ca évite l'ambigüité, et ça reste relativement clair comme convention de nommage.