Discussion :

[sandball22]

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 :

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
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 :

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

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

[Lucien63]

216 messages pas de balise code ?!!!

Bon !

Code :

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

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 :

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

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

[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 !

[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

[Lucien63]

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 :

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

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

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 :

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

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.

[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.

[Lucien63]

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 ....

[sandball22]

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 :

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
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	*/
}

[diogene]

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 :

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

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 ;
}

[sandball22]

Y aurait-il une doc interessante sur les tableaux de pointeurs pointant vers les structures?
Merci.

[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)