Problème de modules

**Bénarès77** · 02/12/2008, 17h52

Bonjour à tous,

Je suis loin d'être un pro en fortran, et en ce moment j'essaye de comprendre comment fonctionne les modules. Ce faisant, je suis tombé sur un problème dont je ne comprends pas l'origine. A titre de test, j'ai écrit ce petit programme :

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
 
module mod1
implicit none
integer n
double precision, allocatable :: u(:)
end module mod1
 
module mod2
use mod1
implicit none
 
contains	
  subroutine blague(m)
          implicit none
          integer m,i
 
          m=2*n
          !write(*,*) 'bip'
          allocate(u(m))
          do i=1,m
               u(i)=i           
          enddo
          deallocate(u)
     end subroutine blague
 
end module mod2
 
 
program test_allocate
use mod1
use mod2
implicit none
 
integer nn,j,m
 
nn=2
do n=1,nn
     call blague(m)
     write(*,*) (u(j),j=1,m)
enddo
 
end program test_allocate

Or lorsque je compile et exécute, il me sort ceci :

Code :

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

1
2
3
 
0. 0.
1. 2. 3. 4.

Chose amusante, lorsque je lui fais afficher le 'bip' dans la subroutine 'blague', il me donne :

Code :

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

1
2
3
4
5
 
bip
1. 2.
bip
1. 2. 3. 4.

Comment est-ce possible ? J'ai essayé différentes configurations, avec des 'interface' et autres, mais j'ai toujours le même problème. Je compile avec g95 sans aucune option sous cygwin. Je pense qu'il y a un truc que je n'ai pas bien pigé à propos des interfaces explicites...
Merci d'avance pour votre aide.

P.S. : je ne vous soumets pas ce problème juste pour m'amuser

, je suis en train d'écrire un programme plus gros qui aura cette structure.

**Ladgalen** · 03/12/2008, 09h41

Salut

La syntaxe de tes modules est bonne, tu pourrais cependant n'en faire qu'un seul en mettant blague dans mod1 ... mais si tu t'exerce ...

Pour ce qui est de ton erreur je pense qu'elle est liée au deallocate. Dans blague tu deallocates u alors que tu veux imprimer ce qu'il contient par la suite. Je saurais pas t'expliquer avec des mots juste mais c'est comme si tu "supprimais ta variable"

Le programme suivant fonctionne :

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
module mod1
implicit none
integer n
double precision, allocatable :: u(:)
end module mod1
 
module mod2
use mod1
implicit none
 
contains
  subroutine blague(m)
          implicit none
          integer m,i
 
          m=2*n
          allocate(u(m))
          do i=1,m
               u(i)=i           
          enddo
          write(*,*) (u(i),i=1,m)
         deallocate(u)
     end subroutine blague
 
end module mod2
 
program test_allocate
use mod1
use mod2
implicit none
 
integer nn,j,m
 
nn=2
do n=1,nn
     call blague(m)
enddo
 
end program test_allocate

Le fait que ça marche avec bip est un peu bizare mais souvent observer (avec "ok" aussi

). En fait quand tu imprime quelque chose il y a une histoire d'accés mémoire qui fait qu'il enregistre ailleurs et donc se souvient du contenu des variables ... mais j'avoue que c'est un peu flou pour moi !

**Bénarès77** · 05/12/2008, 14h58

Merci de ta réponse, malheureusement ça ne règle pas vraiment mon problème . En effet, à l'avenir dans mon programme j'aurai besoin d'utiliser le tableau u dans le programme principal pour faire des opérations dessus, et le réinjecter dans d'autres subroutines. J'ai peur que s'il ne parvienne pas à m'afficher correctement u à l'écran, les résultats qu'il me donnera par la suite seront faux...

Pour résumer, as-tu une idée de comment faire passer proprement u, dont la dimension est recalculée à chaque fois dans blague, à l'intérieur du programme principal ?

**Ladgalen** · 05/12/2008, 15h53

Je vois deux possibilités :

1) ne pas utiliser de tableau dynamique.
Tu pourrais définir une dimension maximum de ton tableau u. Ensuite dans blague tu as la dimension à utiliser et tu n'utilises que la partie du tableau qui t'intéresse. Il faut juste que tu pense à vérifier que tu vas utiliser une dimension plus petite que le max que tu as définit.

2) Faire 2 subroutines de plus qui allocate et deallocate u. Tu met celle qui allocate u avant blague et celle qui le deallocate après blague et après tout ce que tu veux faire avec u.

Ceci dis tout ça est un peu lourd ... je vois pas trop l'intérêt pour un tableau de dimension 10 ! Pourquoi veux tu faire un deallocate de u directement ? Ou alors tu te sert de u dans ta subroutine blague, si tu appelle d'autre subroutine depuis la subroutine blague elles pourront sans problème utiliser u !

**Ehouarn** · 07/12/2008, 08h57

Bonjour,

Comme te l'a signalé Ladgalen, tu ne dois pas désallouer u() dans blague si tu souhaite t'en servir par ailleurs.

Vu que justement tu veux te servir de u() en dehors de sa routine d'initialisation, mais que tu veux également pouvoir le réinitialiser un certain nombre de fois, je te proposerai plutôt de modifier ta routine 'blague' comme suit:

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
 
  subroutine blague(m)
          implicit none
          integer m,i
 
          m=2*n
          ! Allocation de u()
          if (allocated(u)) then
            deallocate(u)
            allocate(u(m))
          else
            allocate(u(m))
          endif
          do i=1,m
               u(i)=i           
          enddo
 
     end subroutine blague

En clair, lorsque l'on exécute 'blague', on teste si 'u' est déjà alloué; si oui, c'est que ce n'est pas la première fois que l'on passe par 'blague' et il faut d'abord désallouer u() avant de le réallouer.
Ainsi, une fois l'exécution de 'blague' terminée, u() est toujours alloué (et initialisé) et est donc accessible/utilisable pour toutes routines/fonctions utilisant le mode 'mod2'.

Bonne continuation.

**Bénarès77** · 08/12/2008, 18h52

Bonjour,

D'abord merci de vos réponses.
@Ehouarn : Si j'utilise la subroutine telle que tu l'as écrite, la dimension de u ne va pas changer à chaque appel de blague, puisque tu ne feras l'allocation qu'une seule fois, à la première itération.
@Ladgalen : 1/ Effectivement, je peux comme ceci, je cherchais une solution plus élégante qui ne m'oblige pas à faire ce genre de check.
2/ Je vais essayer ça ce soir, je verrais ce que ça donne.
Et effectivement tu as raison pour m=10 c'est complètement inutile. Mais mon vrai programme est beaucoup plus gros et prendra des tableaux de 10000, 100000 valeurs.