Puntero a una matriz de punteros a listas vinculadas

Question

Hola chicos bien, así que he estado en este problema durante las últimas 6 horas y he estado llegando a google como loco sin ningún resultado. Derecha Necesito un puntero a una matriz. Esta matriz contiene punteros a las listas vinculadas. Voy a tener que malloc ya que no sé el tamaño de la matriz hasta el tiempo de ejecución.

LList **array 

esto fue mi primer pensamiento, pero esto solo me da un puntero a una serie de LList. O al menos eso es lo que entiendo. ¿Alguien puede ayudarme? Alex

EDIT: bien alguna información sobre cómo se usaría. Im implementando una tabla hash muy básica. hay una estructura que contiene un puntero a una matriz de punteros a las listas vinculadas. necesita ser un puntero a la matriz para que cuando cambie el tamaño de la tabla, simplemente pueda cambiar el puntero para apuntar a la tabla más grande.

Answer 1

Parece que va por buen camino.

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

array es ahora una matriz de punteros a LList, y elementos tales como array[3] habrá un puntero a una LList.

Las matrices y los punteros son muy similares en C (pero no idénticos), como se muestra en el ejemplo clásico: *(array + 2) es en su mayoría equivalente a array[2].

Editar: Cuando tenga que cambiar el tamaño de la tabla, sólo tendrá que realloc el espacio adicional:

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

new_array y old_array puede o no ser el mismo puntero después, pero de cualquier new_array manera se garantiza que sea un puntero al espacio suficiente para albergar la nueva matriz (o NULL si la memoria no se ha podido asignar)

segunda edición: Como user411313 aludido, si desea que el puntero real a la matriz, que tendrá que tomar la dirección de la matriz:

LList ***p_array; 
p_array = &array; 

Answer 2

Un puntero a un objeto, es básicamente lo mismo que un puntero a una matriz.

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. 

Todo depende de cómo lo use.

Answer 3

si tiene que escribir su propia lista enlazada, se puede hacer esto.

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

LLNode* linkedList = null; // a linked list 

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

LLNode*** pointerToLListArray = &linkedListArray; 

con una biblioteca lista enlazada:

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

LList** pointerToLListArray = &linkedListArray; 

Answer 4

Un puntero a un puntero también puede ser una matriz de punteros.

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

hará que array ser un array de punteros a LList. Luego, array[i] le dará el puntero a la lista enlazada i-th en la matriz.

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