Pointeur vers un tableau de pointeurs vers Listes liées

Question

hey les gars droite donc j'ai été à ce problème pour les 6 dernières heures et ont été frapper google comme fou en vain. Droit J'ai besoin d'un pointeur vers un tableau. Ce tableau contient des pointeurs vers des listes liées. Je vais devoir le faire car je ne connais pas la taille du tableau jusqu'à l'exécution.

LList **array 

ce fut ma première pensée, mais cela me donne un pointeur sur un tableau de LList. Ou au moins c'est ma compréhension. Quelqu'un peut-il me donner un coup de main? Alex

EDIT: ok quelques informations sur la façon dont il serait utilisé. Im implémentation d'une table de hachage très basique. il existe une structure qui contient un pointeur vers un tableau de pointeurs vers des listes liées. il doit être un pointeur vers le tableau de sorte que lorsque je redimensionne la table, je peux simplement changer le pointeur pour pointer vers la plus grande table.

Answer 1

On dirait que vous êtes sur la bonne voie.

LList **array; 
array = malloc(num_ptrs * sizeof(LList*)); 

array est maintenant un tableau de pointeurs vers LList, et des éléments tels que array[3] sera un pointeur vers un LList.

Les tableaux et les pointeurs sont très similaires en C (mais pas identiques!), Comme le montre l'exemple classique: *(array + 2) est principalement équivalent à array[2].

Edit: Lorsque vous avez besoin de redimensionner la table, vous aurez juste besoin de realloc l'espace supplémentaire:

LList **new_array; 
new_array = realloc(old_array, new_size * sizeof(LList*)); 

new_array et old_array peuvent ou peuvent ne pas être le même pointeur après, mais non manière new_array est garanti d'être un pointeur vers un espace suffisant pour le nouveau tableau (ou NULL si la mémoire ne pouvait être attribué)

2ème édition: Comme user411313 faisait allusion, si vous voulez que le pointeur réel au tableau, vous aurez besoin de prendre l'adresse du tableau:

LList ***p_array; 
p_array = &array; 

Answer 2

Un pointeur vers un objet est fondamentalement identique à un pointeur vers un tableau.

int * blah; // an int pointer. It could point to an array of ints, or a single int. 
int ** blah; // a pointer to an int pointer. It could point to something that points to an int, or it could be pointing to an array of pointers to single ints, or it could be a pointer that points to an array of ints. 

Tout dépend de la façon dont vous l'utilisez.

Answer 3

si vous devez écrire votre propre liste chaînée, vous pouvez le faire.

typedef struct LLNode { 
    LLNode* next; 
    int  data; 
} LLNode; 

LLNode* linkedList = null; // a linked list 

LLNode** linkedListArray = (LLNode**) malloc(arraySize* sizeof(LLNode*)); 

LLNode*** pointerToLListArray = &linkedListArray; 

avec une bibliothèque de liste chaînée:

LList* linkedListArray = (LList*) malloc(arraySize* sizeof(LList)); 

LList** pointerToLListArray = &linkedListArray; 

Answer 4

Un pointeur vers un pointeur peut aussi être un tableau de pointeurs.

int nLists; /* number of lists*/ 
LList **array; 
array = (LList **)malloc(nLists * sizeof(LList *)); 

fera array être un tableau de pointeurs vers LList. Puis array[i] vous donnera le pointeur vers la liste i-ème dans le tableau.

Answer 5

typedef struct LList LList; 
struct LList { 
int value; 
LList *next; }; 

LList *(*p)[3]; /* pointer to an array of 3 pointers to LList */ 
LList ll1 = {11}; 
LList ll2 = {22}; 
LList ll3 = {33}; 
size_t sizeofarray = sizeof*p/sizeof**p; /* calc arraysize at runtime here */ 
p = malloc(sizeofarray * sizeof**p); /* allocate space for each LList-pointer in array */ 
(*p)[0] = &ll1; 
(*p)[1] = &ll2; 
(*p)[2] = &ll3; 
/* test output here: */ 
printf("\n%d\n%d\n%d", ((*p)[0])->value,((*p)[1])->value,((*p)[2])->value); 
free(p);