Discussion :

[Elby]

J'ai une structure contenant une liste de pointeurs.
Je souhaiterais peupler cette liste petit à petit dans des subroutines, mais je me heurte à des problèmes d'allocation/desallocation.

Voici comment je déclare mes structures dans le programme principal :

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
 
        ! type contenant les informations sur un bloc cycle
        type t_cycle_bloc
            sequence
            character(20)       :: nom
            integer             :: nb = 0
            logical             :: contains_cycle
            type (t_cycle_check):: has_col
            type (t_cycle_row), dimension(:), pointer  :: tab => null()
        end type t_cycle_bloc
 
        ! pointeur sur un cycle
        type t_ptr_cycle
            type (t_cycle_bloc), pointer :: p => null()
        end  type t_ptr_cycle
 
        ! type contenant la liste des blocs cycles 
        type t_liste_cycles
            integer                                 :: nb = 0
            type (t_ptr_cycle), dimension(G_NBLOCS) :: tab
        end type t_liste_cycles
 
        ! Declarations des variables 
        ! ----------------------
        type (t_liste_cycles)                      :: liste_cycles

J'ai crée une subroutine read_cycle dont le but est de remplir petit à petit la liste liste_cycle.
Pour ce faire, je cree dans cette subroutine une structure de type bloc_cylce et je fais pointer le ieme elt d ma liste dessus :

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
 
            SUBROUTINE read_cycle(f_unit, line, words, dont_read, liste_cycles, cond)
                ! lit le bloc contenant la definition d'un cycle et ajoute
                ! la structure correspondante dans la liste liste_cycles en consequence
 
                Integer, intent(in)                 :: f_unit
                Integer, intent(inout)              :: cond
                logical, intent(inout)              :: dont_read
                character(G_NCHARS), intent(inout)  :: line
                character(G_NCHARS), dimension(:), allocatable :: words     ! mots de la ligne
                type(t_liste_cycles), intent(inout)  :: liste_cycles
 
		[..]
                type(t_cycle_bloc), target            :: bloc_cycle
		[..]
 
                ! remplissage de bloc_cycle
                [...]
 
		! ajout a la liste des cycles
		i = liste_cycles%nb +1
		liste_cycles%nb = i  
		liste_cycles%tab(i)%p => bloc_cycle
 
		print *, " >>  IN read_cycle : "
		print *, 'i=', i
		print *, 'liste_cycles%tab(i)%p%nb=', liste_cycles%tab(i)%p%nb
		if (liste_cycles%tab(i)%p%has_col%nom) print *, 'Noms   : ', liste_cycles%tab(i)%p%tab%nom

Et j'appelle le tout dans mon programme principal comme ceci :

Code :

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

1
2
3
4
5
6
7
8
 
 
        call read_cycle(f_unit, line, words, dont_read, liste_cycles, cond)
 
	print *, " >>  IN main : "
	print *, 'i=', i
	print *, 'liste_cycles%tab(i)%p%nb=', liste_cycles%tab(i)%p%nb
	if (liste_cycles%tab(i)%p%has_col%nom) print *, 'Noms   : ', liste_cycles%tab(i)%p%tab%nom

Quand je lance le programme, j'obtiens dans le meilleur des cas un segfault et les affichages suivants :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
  >>  IN read_cycle : 
 i=           1
 liste_cycles%tab(i)%p%nb=           3
 Noms   : Cycle_2             Cycle_3             Cycle_2             
           1  blocs cycle
  >>  IN main : 
 i=           1
 liste_cycles%tab(i)%p%nb=           4
 Noms   :

Bref, j'ai l'impression que l'objet sur lequel pointait liste_cycles%tab(i)%p a ete detruit à la sortie de la subroutine.
Est-ce bien ça le problème ?
Comment me conseillez-vous de peupler cette liste ?

--
Elby

[Elby]

il semblerait qu'en déclarant bloc_cycle comme un pointeur au lieu de target dans ma subroutine et en faisant un allocate(bloc_cycle) dans cette fonction le problème soit réglé.

Je suis pourtant toujours intéressé pour savoir si c'est la bonne façon de faire.
Quand faut-il utiliser l'attribut target ?
J'ai l'impression que cela peut être remplacer par pointer dans la plupart des cas.

--
Elby

[Sylvain Bergeron]

J'ai lu en diagonale car je n'ai pas le temps (il est 14h30 ici).

Si j'ai compris, tu fais pointer un paramètre dummy (et tu le retourne à l'appelant) sur une variable locale. Si c'est le cas, ça ne peut pas fonctionner car le lifetime de la variable locale se termine à la sortie de la fonction. Tu dois absolument utiliser une allocation dynamique sur un pointeur pour que le lifetime ne soit pas limité au temps que tu es dans la fonction.