🚀 go-pugleaf

<dab@acri-st.fr> a �crit dans le message de news: 
1128082651.908510.81550@o13g2000cwo.googlegroups.com...
> J'ai essay� en traitant mes 2 tables comme 2 vecteurs de pointeurs.

donc : t_sorted_grid_point** distTable ;

> J'ai chang� le prototype de ma fonction: computeNeighbors comme ceci:
> void computeNeighbors(t_grid_point* gridPointTable[], int
> gridPointTableSize,
>                         t_sorted_grid_point* distTable[]);

Ok : c'est coherent avec la d�claration

> J'acc�de � chaque �lement ainsi distTable[x*NB_NEIGHBOR+y].

Non : ici tu le traites comme une matrice plate : distTable[z] est un 
pointeur vers t_sorted_grid_point. Je me demande comment �a peut compiler !
Il faut y acc�der par distTable[x][y] :
    distTable[x] est un pointeur vers t_sorted_grid_point (ou vers un 
vecteur)
    distTable[x][y] est le y�me de ce vecteur et donc bien un 
t_sorted_grid_point

> J'ai modifi� le code en fonction et je fais des malloc pour cr�er
> chaque  t_sorted_grid_point au moment ou je l'ins�re et �a marche.

Ok pour l'allocation

> Mais je ne sais toujours pas d'ou proviens l'erreur.
>
> Quand on utilise cette notation distTable[x][y], le compilo
> consid�re-t-il automatiquement que la m�moire est contigu quelle que
> soit la mani�re dont a �t� initialis� distTable?

Tout d�pend de la fa�on de d�clarer ta variable.

Si tu la d�clares en Type Table[LIGNES][COLONNES] , il va effectivement 
supposer la m�moire contigue et chercher l'�lement � la position 
x*COLONNES+y
Dans ce cas la zone utilis�e contient les LIGNESxCOLONNES �l�ments.

Si tu la d�clares en Type **Table (et si tu l'alloues correctement), il va 
partir de l'adresse contenue dans Tables et chercher la valeur contenue dans 
la position x (qui est un pointeur) puis, � partir de cette nouvelle adresse 
chercher l'�lement contenu dans la position y.
Table[x][y] est alors une traduction de *(*(Table+x))+y)
Dans ce cas, il y a une zone allou�e pour LIGNES pointeurs, et chacun pointe 
vers une zone allou�e contenant COLONNES �l�ments.

M�me si on utlise la m�me notation Table[x][y] pour y acc�der dans les 2 
cas, les m�canismes utilis�s sont diff�rents.
C'est l'�ternel probl�me de similitude de syntaxe entre tableaux et 
pointeurs en C, alors que ce sont 2 choses totalement diff�rentes.

>
> Si on alloue distTable ainsi, comment est-ce qu'on peut allouer aux
> �l�ments du tableau en utilisant quelque chose comme (*distTable[x
> ])[y ]  ?
>
> distTable = malloc(NB_MAX_GRID_POINT*sizeof(void *));
> for(inc=0; inc<NB_MAX_GRID_POINT; inc++) {
>         distTable[inc] =
> malloc(NB_NEIGHBOR*sizeof(t_sorted_grid_point));
> }

tu y acc�des simplement par distTable[x][y]