CODEWITHSUNDEEP
cpointersmalloc
Crystal
Crystal

Reputation: 29458

Dynamic allocation (malloc) of contiguous block of memory

For an assignment, I have to allocate a contiguous block of memory for a struct, but I'm first trying to do it with a 2D array of ints first and see if I understand it correctly. We had an example in the book that creates a block of memory for the pointer array (rows), and then initializes the cols and points the pointer to them. This example was:

int **CreateInt2D(size_t rows, size_t cols)
{
    int **p, **p1, **end;
    p = (int **)SafeMalloc(rows * sizeof(int *));
    cols *= sizeof(int);
    for (end = p + rows, p1 = p; p1 < end; ++p1)
        *p1 = (int *)SafeMalloc(cols);
    return(p);
}

void *SafeMalloc(size_t size)
{
    void *vp;

    if ((vp = malloc(size)) == NULL) {
        fputs("Out of mem", stderr);
        exit(EXIT_FAILURE);
    }
    return(vp);
}

I basically need to do what the above code does except make it one contiguous block of memory. The constraint is I'm only allowed to call malloc once, and then I have to use pointer math to know what to initialize the pointers to. So I thought I would initialize enough memory with something like:

int *createInt2D(size_t rows, size_t cols) 
{
    malloc(rows * sizeof(int *) + (row + cols) * sizeof(int));
}

But that doesn't seem quite right since I would think I would have to typecast the void * returned from malloc, but it's a combination of int and int*. So I'm not quite sure if I'm on the right track. Thoughts?

Upvotes: 1

Views: 3100

Answers (4)

Karthik
Karthik

Reputation: 11

malloc((row * cols) * sizeof(int));

It's row*cols which is number of elements in the 2D array and not row+cols.

Upvotes: 1

mpez0
mpez0

Reputation: 2883

You are on the right track. The block returned by malloc is guaranteed to be aligned properly for either int * or int; you can use it for either. Typecasting isn't a one time operation.

If you are going to use array[row, col] addressing exclusively, you can get by without allocating extra space for the row pointers. If you would like to be able to use array[row] to get an int * column list, you'll have to include space for the column pointers in your allocation.

Hope that's enough to help with your exercise.

Upvotes: 1

wallyk
wallyk

Reputation: 57774

No need to multiply by the size of int *. That's only used to allocate the pointers for the rows. Same too with the sum of rows and cols. It's sufficient to allocate (rows * cols) * sizeof whatever structure is being allocated.

Upvotes: 0

Anon.
Anon.

Reputation: 59983

If you want a contiguous array, you should malloc(rows * cols * sizeof(int)).

Then you'd access arr[x, y] like:

arr[x * cols + y]

Upvotes: 2

Related Questions