malloc matrix which points to malloc arrays(C)

Question

EDIT: I should not use [].

I have defined integer N with value 5 and *malloc.

#define N

void* malloc (size_t size);

...

int *p_mat=(int*)malloc(sizeof(int*) * N);

This is the matrix.

Now we need the arrays.

int p_arr1=(int)malloc(sizeof(int) * 4);

int p_arr2=(int)malloc(sizeof(int) * 3);

int p_arr3=(int)malloc(sizeof(int) * 1);

int p_arr4=(int)malloc(sizeof(int) * 2);

int p_arr5=(int)malloc(sizeof(int) * 5);

So we have 5 arrays in different sizes. Now how do I make each pointer of the matrix point to the first cell in the array?

And another question, how do I send these variables to a function, I mean - what are the parameters in the function key?

Answer 1

An array of N pointers to arrays-of-integers of different sizes.... (Note don't cast malloc return value in C - can hide errors - see Do I cast the result of malloc?).

int i = 0;
int *p[N];
size_t sizes[] = { 4, 3, ..., 5 }; // N sizes

for(; i < N; ++i)
{
    p[i] = malloc(sizeof(int) * sizes[i]);
}

Now p is an array of pointers-to-int. p[n] is therefore the nth pointer-to-int in the array.

int *p[n] would look something like this in memory:

int *p[n]
+-----+
|     | <------- Each element of the array is a pointer-to-an-integer
|     |
+-----+
|     |
|     |
+-----+
.
.
.
+-----+
|     |
|     |
+-----+

When we then do p[n] = malloc(sizeof(int) * sizes[i]), we are saying that the pointer p[n] (remember each element of the array p is a pointer), points to a block of memory the size of sizes[i] integers. So you get something like...

+-----+                                            +------+------+ ... +------+
|p[n] |-------- array element is a pointer to ---> | int1 | int2 |     | intm |
|     |                                            |      |      |     |      |
+-----+                                            +------+------+ ... +------+
.
.
.
+-----+
|     |
|     |
+-----+

So when you write p[n] you are accessing a pointer to the array of ints you malloc()ed...

Later on in your code you must remember to free() the memory allocated :)

for(; i < N; ++i)
{
    free(p[i]);
}

Hope this helps...

EDIT: Didn't read the last bit of your question but wilsonmichaelpatrick has answered it...

EDIT: Note, btw, that I'm not checking malloc() return for NULL and handling the possible error a this is just an example...

If you do not want to declare int *p[N]; on the stack and would prefer the heap, try the following...

int i = 0;
size_t sizes[] = { 4, 3, ..., 5 }; // N sizes
int **p = malloc(sizeof(int *) * N);
for(; i < N; ++i)
{
    p[i] = malloc( sizeof(int) * sizes[i]);
}

...
...

for(; i < N; ++i)
{
    free(p[i]);
}

free(p);

EDIT: Use #include <stdlib.h> for definitions of free() and malloc()

Answer 2

EDIT: First, let's start with some corrections:

int **p_mat=(int**)malloc(sizeof(int*) * N);
int *p_arr1=(int*)malloc(sizeof(int) * 4);
int *p_arr2=(int*)malloc(sizeof(int) * 3);
int *p_arr3=(int*)malloc(sizeof(int) * 1);
int *p_arr4=(int*)malloc(sizeof(int) * 2);
int *p_arr5=(int*)malloc(sizeof(int) * 5);

Now, you can make each element of the matrix point to the first element of the array like this:

p_mat[0] = p_arr1;
p_mat[1] = p_arr2;
p_mat[2] = p_arr3;
p_mat[3] = p_arr4;
p_mat[4] = p_arr5;

Now if you want to pass this to a function, you can just have

int SomeFunction(int **theMatrix)
{
    /* Get third element of second row */
    int nSecondElementFirstRow = theMatrix[1][2]; /* same as p_arr2[2] above */
}

and call

SomeFunction(p_mat);

Specific to your comment, you could have a function:

void print_number(int n)
{
    printf("%d\n", n);
}

and call it like this:

 print_number(p_mat[1][2]);

to print out the third element of second row; that would print out p_arr2[2]. You could set p_arr2[2] = 12345; right after you malloc p_arr2 to test.

Finally, many comments I've just read suggest not casting the results of malloc as I have done: Do I cast the result of malloc?

Answer 3

If you want to associate each array to the first one:

p_mat[0] = p_arr1;
p_mat[1] = p_arr2;
//(...)
p_mat[4] = p_arr5;