tableau de pointeur pointant sur des structures.

Version imprimable

15/08/2009, 16h23
sandball22

tableau de pointeur pointant sur des structures.
Bonjour,
j'aimerais faire un tableau de pointeur pointant sur des structures.

donc en faite avant j'avais un tableau de tableau de structures:
j'ai la structure suivante:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 struct { int A; ..... }t_Session typdef t_Session t_Sessions[N] ... t_Sessions a_Sessions { initialisation pour 0 .... initialisation pour N-1 } ------
Maintenant je voudras passer par des pointers
et je déclare:
Code:

1 2 3 4 5 6 7 8 typdef t_Session *p_Sessions[N] p_Sessions *a_Sessions { initialisation 0 initialisation N-1 }
est ce que cela fonctionne?me manque-t-til quelque chose?
Merci de votre aide

216 messages pas de balise code ?!!! :scarymov:

Bon !
Code:

1 2 3 4 5 6 7 struct { int A; ..... }t_Session typdef t_Session t_Sessions[N]
Ton premier code sans pointeur je pense pas qu'il compilait
Code:

1 2 3 4 5 6 7 struct t_Session { int A; /* ... */ }; typedef struct t_Session t_Sessions[N];

15/08/2009, 19h10
Lucien63

Pour repondre à ta question comme tu aura un tableau de pointeur en plus de l'initialisation il va falloir penser aussi à l'allocation.

Essais dans la mesure du possible de poster des morceaux de code qui compile !
15/08/2009, 19h17
sandball22

dsl mais pour le tableau de pointeurs sur la structure la déclaration se fait comment et l'initialisation se fait comment?
Merci de votre aide

Citation:

Maintenant je voudras passer par des pointers
et je déclare:
typdef t_Session *p_Sessions[N]

Là tu n'était pas bien loin
Code:

1 2 3 4 5 6 7 8 struct t_Session { int A; /* ... */ }; typedef struct t_Session *p_Sessions[N];
Citation:

mais pour le tableau de pointeurs sur la structure la déclaration se fait comment et l'initialisation se fait comment?

Un petit exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 int i; p_Sessions a_Sessions; for(i=0; i<N; i++) { /* allocation */ a_Sessions[i] = malloc(sizeof(struct t_Session)); /* initialisation */ a_Sessions[i]->A = 10; } for(i=0; i<N; i++) printf("Valeur de a_Sessions[%d]->A : %d\n", i, a_Sessions[i]->A );
Il faut prévoir les tests sur les retours des malloc en cas d'echec de l'allocation.

Et ne pas oublier de libérer la mémoire allouée quand tu n'en a plus besoin.

Le fait d'utiliser des typedef pour tes tableaux n'est peut-être pas une bonne idée si tu n'est pas trop d'accord avec les pointeurs.

17/08/2009, 18h38
sandball22

Merci de ton aide.
je voudrais tester ce tableau de pointeurs avant d'effectuer l'allocation.
En fait je voudrais pourvoir tester si le 1er element est déja alloué ou non. si il est deja alloué, je vais à l'élément 2 etc...

Comment dois je m'y prendre pour faire cette manip?

Merci de votre aide.
18/08/2009, 12h13
Lucien63

Citation:

je voudrais tester ce tableau de pointeurs avant d'effectuer l'allocation.

?? je ne comprend pas ce que tu veux faire ?

Avant l'allocation ton tableau de pointeur à des élément non initialisé, c'est à dire qui pointe n'importe où ! tu ne doit donc pas les utiliser tant qu'il ne pointe pas sur un espace mémoire valide.

Tu devrais consulter un cours sur les pointeurs, les tableaux ....

En faite je vais appeler une fonction qui va faire l'allocation. Quand j'appelerais cette fonction je veux allouer au bon endroit dasn mon tableau de pointeurs. Je ne veux pas écraser la 1ere allocation.

Je pensais faire comme ceci:

Code:

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
my_fonction_allocation{
while((a_Sessions[i]!=NULL)&&(i<N))
  	{
  	 i++;
  	}
 
/*Tant que je ne pointe pas sur un élément null j'incremente*/		
 
if(a_Sessions[i]==NULL)
{/* Allocation */
    a_Sessions[i] = malloc(sizeof(struct t_Session));
 
}	
 
}
GLOBAL p_Sessions a_Sessions
= {
   { NULL }     /* 1rst  instance	*/
  ,{ NULL } 	/* 2nd  instance	*/
  ,{ NULL }	 	/* 3rd  instance	*/
  ,{ NULL }  	/* 4th  instance	*/
  ,{ NULL }  	/* 5th  instance	*/
  ,{ NULL }  	/* 6th  instance	*/
  ,{ NULL }  	/* 7th  instance	*/
  ,{ NULL } 	/* 8th  instance	*/
  ,{ NULL }  	/* 9th  instance	*/
  ,{ NULL }  	/* 10th  instance	*/
}

Quelques remarques sur cette ébauche de code :

- La fonction my_fonction_allocation devrait prendre en argument le tableau de pointeur et le nombre d'éléments de ce tableau et renvoyer, par exemple, le pointeur obtenu par le malloc (ce qui permet à l'appelant de savoir si l'allocation a réussi et si il y avait une place suffisante dans le tableau pour la placer)

- if(a_Sessions[i]==NULL).... La condition est insuffisante, puisqu'elle ne détecte pas si le tableau est plein (i==N)

On devrait avoir quelque chose du genre :
Code:

1 2 3 4 5 6 7 struct t_Session * my_fonction_allocation ( p_Sessions a_Sessions, int N) { int i; for(i=0; i<N && a_Sessions[i] != NULL ;i++){} if(i<N) a_Sessions[i] = malloc(sizeof(struct t_Session)); return i<N ? a_Sessions[i] : NULL ; }

19/08/2009, 18h22
sandball22

Y aurait-il une doc interessante sur les tableaux de pointeurs pointant vers les structures?
Merci.
19/08/2009, 20h15
diogene

A ma connaissance, non.

En fait, la raison est que les tableaux de pointeurs sur structures ou pointeurs sur autre chose se comportent sans particularités spéciales par rapport à des tableaux de n'importe quoi (sauf peut-être pour des tableaux de tableaux, c'est à dire des tableaux de dimension supérieure à 1)