Discussion :

[leup]

bonjour,

j'ai un problème (évidemment).

J'ai créé un certains nombres de routines et fonctions en F90. Un sous-ensemble de ces routines et fonctions appartient à un même module.

Mais cet ensemble représentant une longue liste de lignes de code, j'ai mis chaque routine dans un fichier séparé et j'ai créé un fichier nomModule.f90 dans lequel on retrouve toutes les interfaces de mes fonctions. Tout ça dans un souci de lisibilité. Donc, en gros ça me permet de m'organiser en mettant tous les fichiers sources d'un même module dans un répertoire dédié, etc..

Bref..

j'ai un problème de compilation avec une routine de mon module qui fait appel à une fonction du même module. Il se trouve que cette fonction renvoie un tableau de valeurs. Je suis obligé de déclarer explicitement l'interface de ma fonction dans ma routine, alors qu'elles sont sensées appartenir au même module. A priori, ça risque de se reproduire avec d'autres modules à venir, et je trouve ça peu élégant.

maRoutine.f90 :

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
subroutine maRoutine(x,y,z)

integer :: x,y
integer,dimension(:) :: z

!obligatoire sinon erreur de compilation
interface
function maFonction(x,y)
integer :: x,y
integer,dimension(x+y) :: z
end function
end interface

z = maFonction(x,y)

end subroutine

maFonction.f90

Code :

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

1
2
3
4
5
6
7
8
9
 
function maFonction(x,y)
 
integer :: x,y
integer,dimension(x+y) :: maFonction
 
maFonction(i) = ...
 
end function

monModule.f90

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
 
module monModule
 
interface
subroutine maRoutine(x,y,z)
integer :: x,y
integer,dimension(:) :: z
end subroutine
end interface
 
interface
function maFonction(x,y)
integer :: x,y
integer,dimension(x+y) :: z
end function
end interface
 
contains
 
...
 
end module

et quand je compile, sans avoir l'interface de ma fonction explicitement déclarée dans ma fonction, j'obtiens ce message d'erreur :

Code :

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

1
2
 
Error: Function 'maFonction' at (1) has no implicit type

y'a-t-il une astuce de compilation qui m'ai échappé ou bien une façon d'écrire les modules avec blocs interfaces pour que les fonctions et routines du module se connaissent entre elles sans avoir besoin de les redéclarer ? ou alors le problème d'une fonction qui retourne un tableau de valeurs est-il trop complexe pour F90 et doit donc forcément passer par une déclaration explicite d'interface à l'intérieur même de la routine ?

Merci de votre attention.

[leup]

Hmm.. je pense avoir trouvé la réponse :

Il est des cas où l’interface d’appel doit être “explicite”. Il en existe 10 :
• fonction à valeur tableau,
• fonction à valeur pointeur,
• fonction à valeur chaîne de caractères dont la longueur est déterminée
dynamiquement,
• tableau à profil implicite,
• argument muet avec l’attribut pointer ou target,
• passage d’arguments à mots-clé,
• argument optionnel,
• procédure générique,
• surcharge ou définition d’un opérateur,
• surcharge du symbole d’affectation.

A priori, au moins tant que je compilerais dans des fichiers séparés, je serais obligé de déclarer mes interfaces de fonctions à valeur de retour de type tableau directement dans mes routines appelantes.

[genteur slayer]

Moi je suis partisant du TOUT EXPLICIT donc en général je fait 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
module toto
 
  interface
    function titi(P1,P2)
      implicit none
      real(kind=8),intent(in) :: P1,P2
      real(kind=8),dimension(1:)::titi
    end function titi
   
    subroutine tata(P1,P2)
      implicit none
      real(kind=8),intent(in) :: P1,P2
    end subroutine titi
  end interface
 
end module toto
 
function titi(P1,P2)
  implicit none
  real(kind=8),intent(in) :: P1,P2
  real(kind=8),dimension(1:)::titi
  {ce que doit faire ta fonction}
end function titi
   
subroutine tata(P1,P2)
  use toto, only : titi
  implicit none
  real(kind=8),intent(in) :: P1,P2
end function titi

en gros la fonction use te dit d'aller quand voir dans le module... si tu oublie le only, il va dire que tu appele ta subroutine de manière récurente et le compilo va râler...

[leup]

Salut et merci !

effectivement, j'ai pu résoudre certains conflits et avoir un résultat un peu mieux ficelé grâce au ONLY.
Et oui tu as raison dans la mesure du possible, il faut expliciter au maximum. Ca évite bien des problèmes par la suite.