memory allocation for 2D array of pointers

Question

I am getting super confused with dynamic memory allocation and deletion of a 2D array of pointers.

The goal is to have a 2D array in which each cell has a pointer to a linked list. This is what I am doing, and I don't see any errors but few warnings.

Warnings :

1)

a value of type queue ** cannot be used to initialize an entity of type queue ***
queue* (**table) = (queue**)malloc(sizeof(queue*)*3);

2)

a value of type queue * cannot be assigned to an entity of type queue **
    table[indexI] = (queue*)malloc(sizeof(queue*)*3);

3)

a value of type queue ** cannot be assigned to an entity of type queue ***
  if( !(table = allocate()) ) {

Here is the code:

queue **allocate() {

    queue* (**table) = (queue**)malloc(sizeof(queue*)*3);
    // Warning #1 at above line 
    for(.....) {

    table[index] = (queue*)malloc(sizeof(queue*)*3);
    // Warning #2 at above line. 
    }

    for(I index - 0 to 3) {
    for(J index - 0 to 3) {

    table[I][J] = NULL;

    }
    }
    return((queue**)table);
   }

    void deallocate(queue* **table) {


    // will handle list deletion
    // next deallocate table

    for(....) {
    free(table[index]);
    }
    free(table);

   }

void
add_list_to_queue(queue ***table) {

// here I create a list of queue type and assign it to
// those cells

}

modify_table() {

    queue* (**table) = NULL;

    table = allocate();
// Warning #3 at above line
.
.
.
    add_list_to_queue(table);

// do de allocation of table, list etc.,

    deallocate(table);

}

I have confusion in these areas

1. I am not sure if my declaration of 2D array of pointers is correct
2. How can I pass around this 2D array of pointers

Answer 1

The first warning is because the parentheses make no difference in the LHS of your expression

queue* (**table) = (queue**)malloc(sizeof(queue*)*3);

table is simply a three-level pointer to a queue. But malloc returns a pointer to a block of memory that can hold three pointers to queue, so you're allocating a two-level pointer to a queue.

Since table is a three-level pointer, table[indexI] is a two-level pointer. But you're inconsistent on the RHS of the expression:

table[indexI] = (queue*)malloc(sizeof(queue*)*3);

malloc is again returning a pointer to a block of memory that can hold three pointers to queue (i.e., malloc is returning a two-level pointer) but you're casting it as a one-level pointer, then assigning it to a two-level pointer.

As for the third warning, you've defined allocate() as returning a pointer to a pointer to a queue, but you're trying to assign it to table. As explained above, table is a three-level pointer, but allocate() returns only a two-level pointer.

But really, multiple levels of pointer indirection isn't what you need here. Keep it simple. What do you need? A pointer to rows, each row containing pointers to queue. That's what H2CO3's suggestion in his comment gives you:

queue *(*arr)[COLUMNS] = malloc(sizeof(*arr) * ROWS);

arr is a pointer to an array of ROWS, each row containing COLUMNS pointers to queue.

Edit: To pass this around to different functions as you asked in the comments, first declare and initialize the pointer:

queue* (*arr) [COLUMNS] = NULL;

Then to allocate memory, remember that you need to change what the pointer is pointing to. So you have to pass a pointer to the pointer. Your function prototype should be:

void allocate (queue* (**arr) [COLUMNS]);  // Note the (**arr)

The function call should be:

allocate (&arr);

(To make pointer indirection easier, you might want to declare and initialize a different pointer-to-array inside allocate() using the format first suggested by H2CO3 which I explained above, then assign that pointer to *arr.)

Remember that you have to allocate memory not just for the pointer to the 2D array, but also for each element inside the array, since that element is an uninitialized pointer. You can do this using a nested loop in allocate() or, if it is more logical given your data structures, in fill_table().

For fill_table(), you can simply pass the pointer-to-array itself. The prototype will be:

void fill_table (queue* (*arr) [COLUMNS]);

and the call:

fill_table (arr);

Hope this helps. The easiest way to do things might be to do everything inside process() to begin with, then see how you can separate the allocation and filling parts out into their own functions.

Answer 2

1) your first error (queue* (**table)) is that you don't have a 2D array here, but a 3D array, your line can be write like that : queue ***table. So, you just have to remove a star an you will declare a 2D array pointer.

2) with the first response, i think you will not have this warning anymore

3) This error is like the first, you juste have to remove a star.