Allocation dynamique d'un tableau

**Dreyliciouss** · 06/08/2010, 10h00

Bonjour,

Je m'adresse à vous tous sur ce forum car je n'ai pas trouvé la réponse à ma question.
En effet, je voudrais savoir s'il est possible d'allouer un tableau dont les dimensions sont lues dans un fichier binaire et de retourner ce tableau en sortie.

Je sais qu'allouer un tableau et lui attribuer ses dimensions dynamiquement en les récupérant dans un fichier sont possible mais je sais que l'instruction ALLOCATABLE n'est pas compatible avec l'instruction INTENT.

Est ce que quelqu'un a déjà réalisé quelque chose de similaire?

Merci d'avance pour vos réponses.

**genteur slayer** · 06/08/2010, 12h42

tu peux passer par un module:

Code :

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

1
2
3
4
 
module toto
  real(kind=8),dimension(:),allocatable :: titi
end module toto

puis dans une autre routine:

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
 
subroutine litfichier
use toto
implicit none
 
...
open(unit=15,.....)
  read(15)taille
...
  if (allocated(titi)) deallocate(titi)
  allocate(titi(taille))
...
  read(15)titi
...
  return
end subroutine litfichier

ensuite tu n'a qu'à charger le module toto dans la/les routine qui utilise le tableau titi !!!

**Dreyliciouss** · 06/08/2010, 14h24

Merci pour cette réponse

J'ai donc suivi votre méthode qui m'a l'air vraiment bien. Mais j'avoue que j'ai du mal à voir comment déclarer le tableau et dimensions dans chaque fonction.

**Dreyliciouss** · 06/08/2010, 15h01

J'ai essayé d'inclure tes suggestions dans mon code mais j'obtiens les erreurs suivante :

1) Number of subscripts declared and used do not match (PROJ)
2) Illegal structure component reference.

PROJ correspond à titi dans ton exemple.
La deuxième erreur intervient lorsque j'essai de lire dans le fichier (je récupère ce que je lis dans le tableau PROJ avec l'instruction READ).

Je ne comprend pas du tout la première erreur. Auriez-vous une idée de ce à quoi elle peut correspondre?

**Sylvain Bergeron** · 06/08/2010, 15h09

Envoyé par Dreyliciouss

1) Number of subscripts declared and used do not match (PROJ)

C'est un problème de dimension. Tu fais référence à un tableau avec un nombre d'indice différent du nombre de dimensions déclaré. Par exemple :

Code :

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

1
2
3
real, dimension(:,:) :: Tableau ! 2 dim
...
Tableau(3) = ... ! 1 dim

**Dreyliciouss** · 06/08/2010, 15h19

Nikel! L'erreur a disparue par contre, à la dernière ligne de code lorsque j'essai d'allouer les dimensions a et b lues précédemment dans le fichier, il me dit "ALLOCATE argument must be ALLOCATABLE or POINTER. (PROJ)". Cela vient sans doute de la déclaration de a et b.

Mais quand je déclare a et b avec la ligne suivante :

Code :

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

INTEGER, ALLOCATABLE :: a,b

Il me dit :

ALLOCATABLE or POINTER array-spec must be deferred shape. (A)
ALLOCATABLE or POINTER array-spec must be deferred shape. (A)

et l'erreur précédente est toujours présente. Je ne sais pas comment les déclarer correctement.

**Sylvain Bergeron** · 06/08/2010, 15h47

Ce n'est pas A et B qui doivent avoir l'attribut allocatable, c'est Proj...

**Dreyliciouss** · 06/08/2010, 15h49

Proj est déjç défini comme alloctable dans le module toto. Dois-je le redéfinir comme allocatable dans la routine où je l'utilise aussi?

**Sylvain Bergeron** · 06/08/2010, 15h53

... Euh.....

As-tu un implicit none dans la routine ? Sinon, ajoute le.

(Si Proj a l'attribut allocatable et que le compilateur te dit que Proj doit avoir l'attribut allocatable, c'est qu'il ne voit possiblement pas la variable Proj du module)

**Dreyliciouss** · 06/08/2010, 16h00

Oui ma routine contient bien "implicit non"
Comme tu l'as dit précédemment j'ai l'impression qu'il ne voit pas la variable Proj du module puisqu'il me dit : "No implicit data type given for this symbol (PROJ)"

**Sylvain Bergeron** · 06/08/2010, 16h07

As-tu bien un use du module dans la routine (ou dans le module contenant routine s'il y a lieu) ?

Si oui, as-tu une clause "only" sur le use ? si oui, Proj est dans la liste ?

As-tu un "private" affectant Proj dans le module ?

**Dreyliciouss** · 09/08/2010, 08h33

J'ai bien une instruction "use toto" dans ma routine. Par contre, je n'ai pas de clause "only" sur le use et je n'ai pas non plus de "private" affectant le Proj dans le module.

**Sylvain Bergeron** · 09/08/2010, 14h57

Je ne vois pas ce qui ne fonctionne pas :

Proj est défini allocatable dans le module toto.
Il n'y a pas de private dans toto.
Il y a un implicit none dans la routine
Il y a un use toto dans la routine
Il n'y a pas de variable Proj masquant celle de toto dans la routine (sinon il n'y aurait pas de message "No implicit data type given for this symbol (PROJ)"

Peux-tu nous fournir le code, ou une version simplifiée produisant le problème ?

**Dreyliciouss** · 10/08/2010, 08h03

J'ai vérifié et oui tout est ok dans ce que tu viens de dire donc je ne comprend pas vraiment non plus.

Voici le code :

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
45
46
47
48
49
50
51
52
 
C -*- f90 -*-
 
       MODULE TOTO
          REAL,DIMENSION(:,:),ALLOCATABLE :: PROJ
       END MODULE TOTO
 
 
       SUBROUTINE LIREPROJ(FICPRJ,PROJ)
 
       USE TOTO
 
       IMPLICIT NONE   
 
       CHARACTER*150, INTENT(IN) :: FICPRJ   
       INTEGER :: a,b
       INTEGER :: NENRG
       INTEGER :: II,J
       INTEGER*4 :: TailleEnreg
 
       TailleEnreg   = 4*256
       NENRG = 0
 
       OPEN(UNIT=20,FILE=FICPRJ,FORM='UNFORMATTED',RECL=TailleEnreg,
     & STATUS='OLD',ACCESS='DIRECT')
 
 
! ~~~~~~~~~~~ Lecture de l'entete dans le fichier de sortie proj ~~~~~~~~~~~~~~
 
          READ (UNIT=20,REC=1)  a
          READ (UNIT=20,REC=2)  b
 
          NENRG=2
 
          if (allocated(PROJ)) deallocate(PROJ)
          allocate(PROJ(a,b))
 
! ~~~~~~~~ Lecture des données dans le fichier ~~~~~~~~~~~~~
 
          print* ,'Lancement de la lecture de ',FICPRJ
          DO J = 1 , a
 
             NENRG = NENRG + 1
             READ (20,REC=NENRG) (PROJ(J,II),II=1,b)
          END DO
 
          print* ,'Le fichier ',FICPRJ, 'a bien été lu'
 
       CLOSE(20)
 
       RETURN 
       END SUBROUTINE LIREPROJ

**genteur slayer** · 10/08/2010, 09h05

moi je vois des choses qui me dérange... je dis pas que c'est pas possible mais je les trouves bizarre:
dans la structure de la routine tu écrit:

Code :

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

SUBROUTINE LIREPROJ(FICPRJ,PROJ)

moi j'aurais donné un autre nom que 'PROJ' déjà...

mais surtout, je ne l'aurais même pas mis dans la déclaration... juste

Code :

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

SUBROUTINE LIREPROJ(FICPRJ)

parce que toute routine/fonction/program qui contient un 'use toto' connait automatiquement PROJ du coup pas besoin de le mettre en paramètre!!!

le reste de ta routine me semble correct...

je sais pas si c'est cela mais il est possible d'avoir un conflit de nom entre le PROJ du module et le PROJ des paramètre (qui n'est pas vraiment déclaré dans la routine hormis à travers le module... ça me semble louche...

**Dreyliciouss** · 10/08/2010, 09h50

Le problème c'est que je veux récupérer le tableau PROJ en sortie avec les bonnes dimensions.
Là, la routine marche bien en enlevant PROJ des paramètres. En revanche en sortie, l'ordinateur ne trouve pas l'objet retourné et je ne peux pas exploiter le tableau après l'utilisation de la routine.

**genteur slayer** · 10/08/2010, 13h25

pour le récupéré, il suffit de mettre 'use toto' dans la routine qui utilise...

si tu veut les tailles il y a un moyen simple:

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
 
MODULE TOTO
    REAL,DIMENSION(:,:),ALLOCATABLE :: PROJ
    INTEGER NX,NY
contains
 
     subroutine allocate_proj(NN,MM)
       implicit none
       integer,intent(in)::NN,MM
       if (allocated(PROJ)) deallocate(PROJ)
       Nx=NN
       Ny=MM
       allocate(PROJ(Nx,NY))
     end subroutine allocate_proj
 
END MODULE TOTO

et tu utilise la routine allocate_proj pour l'allocation, ainsi les taille sont connues...
mais tu peux également utiliser les fonctions SHAPE, SIZE ...etc....

et ta routine de lecture n'a pas besoin de sortie... je vois pas où est le problème? c'est parce que c'est utilisé par un bout dont tu n'a pas le code???

**Dreyliciouss** · 10/08/2010, 14h35

C'est moi qui veut que la routine puisse renvoyer en sortie le tableau afin de pouvoir l'exploiter dans un autre programme.
Il ne s'agit pas de récupérer le tableau dans la routine, ca la routine le fait déja.

**Sylvain Bergeron** · 10/08/2010, 14h54

Le problème est effectivement que le paramètre Proj masque la variable Proj du module toto.

Compte tenu de ce que te suggère genteur slayer et de ta réponse, tu dois t'interroger sur tes besoins et le design à utiliser.

Si tu utilises l'approche module, tu dois accéder à Proj via le module partout où tu en as besoin. Par exemple :

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
 
MODULE TOTO
     REAL,DIMENSION(:,:),ALLOCATABLE :: PROJ
     END MODULE TOTO
 
SUBROUTINE LIREPROJ(FICPRJ)
 
   USE TOTO
   ...
   allocate(PROJ(a,b))
   END SUBROUTINE LIREPROJ
 
subroutine Appelante
   use toto
   ...
   call LireProj(...)
   call UneAutreRoutine(Proj) ! Là, Proj est un paramètre. 
                                       ! Il ne sera donc pas accédé
                                       ! par le module toto...
   xyz = f(Proj)
...

Cette structure est la plus simple si une seule variable Proj peut exister dans ton programme.

Si tu veux cependant que LireProj puisse lire plusieurs fichiers et retourner plusieurs tableau Proj comme par exemple :

Code :

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

1
2
3
4
5
6
 
   call LireProj('Fichier1',Proj1)
   call LireProj('Fichier2',Proj2)
   call LireProj('Fichier3',Proj3)
   xyz = f(Proj1+Proj2+Proj3)
   ...

alors tu dois utiliser un paramètre et non passer par un module.

**genteur slayer** · 11/08/2010, 09h20

si tu tiens absolument à utiliser le tableau en paramètres tu peux utiliser les common... mais c'est pas très joli... il y a les attribut SAVE aussi, mais je ne sais pas très bien comment on les utilise.

mais si tu vaut utiliser dans un autre programme alors, c'est une routine d'écriture dans un fichier que tu as besoin, la lecture se fera à partir de l'autre programme....
si par hasard par 'programme' tu entend 'subroutine' dans le même 'program' alors justement tu n'a pas besoin de faire une sortie par paramètre, il te suffira de mettre use toto dans l'autre subroutine...

Allocation dynamique d'un tableau

Fortran

Discussions similaires

Partager

Partager