malloc in C, but use multi-dimensional array syntax

ah I knew it was possible! take that, nay-sayers... @Tim: Sorry, but I didn't realize your solution did what I wanted, caf's made it blatantly obvious.

@Tim: Aye, I upvoted yours when I saw it, too - but I figured I might as well leave my answer, since it seemed to be only two of us against the world ;)

@Claudiu: It's probably worth pointing out that foo[] in function parameter declarations is just syntactic sugar for (*foo) - it's just that [] means something different in actual variable declarations (where it means an array whose size is determined by the initialiser).

Vader B Over a year ago

You can do even more magic by using VLA feature of C99! int (*MOREMAGICVAR)[b] = (int (*)[b]) malloc(a * b * sizeof(int));

@VaderB: Yes, the VLA feature is really only useful in variable declarations like that. You can still use the a * sizeof MOREMAGICVAR[0] formulation for the size, by the way (ie. don't repeat b).

|

Tim Schaeffer · Accepted Answer · 2016-08-31 17:29:43Z

19

Use a pointer to arrays:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int (*arr)[10];

    arr = malloc(10*10*sizeof(int));
    for (int i = 0; i < 10; i++)
        for(int j = 0; j < 10; j++)
            arr[i][j] = i*j;

    for (int i = 0; i < 10; i++)
        for(int j = 0; j < 10; j++)
            printf("%d\n", arr[i][j]);
    free(arr);
    return 0;
}

edited Aug 31, 2016 at 17:29

answered Jun 29, 2010 at 20:28

Tim Schaeffer

2,6461 gold badge16 silver badges20 bronze badges

1 Comment

gen Over a year ago

how do I free() memory here?

Cogwheel · Accepted Answer · 2010-06-29 20:16:46Z

5

If extra indirection isn't a concern, you can use an array of pointers.

Edit

Here's a variation on @Platinum Azure's answer that doesn't make so many calls to malloc. Besides faster allocation, all the elements are guaranteed to be contiguous:

#define ROWS 400
#define COLS 200

int **memory = malloc(ROWS * sizeof(*memory));
int *arr = malloc(ROWS * COLS * sizeof(int));

int i;
for (i = 0; i < ROWS; ++i)
{
    memory[i] = &arr[i * COLS];
}

memory[20][10] = 3;

edited Jun 29, 2010 at 20:16

answered Jun 29, 2010 at 19:49

Cogwheel

23.3k4 gold badges51 silver badges67 bronze badges

3 Comments

hmm interesting... a bit more setup than i'd like (which is 1 line of special syntax), but this is probably closest that can be done... sadly w/ some overhead for the array of pointers.

Ooh, fewer mallocs? I like it. I should take note of this and use it myself. (+1)

This works, but a pointer-to-array is simpler (doesn't require the setup loop) and is exactly what the OP is after.

Jon Purdy · Accepted Answer · 2010-06-29 20:45:28Z

3

In the same vein as Cogwheel's answer, here's a (somewhat dirty) trick that makes only one call to malloc():

#define ROWS 400
#define COLS 200
int** array = malloc(ROWS * sizeof(int*) + ROWS * COLS * sizeof(int));
int i;
for (i = 0; i < ROWS; ++i)
    array[i] = (int*)(array + ROWS) + (i * COLS);

This fills the first part of the buffer with pointers to each row in the immediately following, contiguous array data.

answered Jun 29, 2010 at 20:45

Jon Purdy

55.4k9 gold badges101 silver badges170 bronze badges

2 Comments

jamesdlin Over a year ago

This has the advantage of working even when the size of neither dimension is known at compile-time. Also see: c-faq.com/aryptr/dynmuldimary.html

M.M Over a year ago

@jamesdlin Since C99 the other solutions also work when the dimension is not known at compile-time; and this has the disadvantage that the first entry in the array (after the pointer table) might not be correctly aligned.

Nikolai Fetissov · Accepted Answer · 2010-06-30 01:08:23Z

2

#define ROWS 400
#define index_array_2d(a,i,j) (a)[(i)*ROWS + (j)]
...
index_array_2d( memory, 20, 10 ) = -1;
int x = index_array_2d( memory, 20, 10 );

Edit:

Arrays and pointers look very much the same, but the compiler treats them very differently. Let's see what needs to be done for an array indexing and de-referencing a pointer with offset:

Say we declared a static array (array on the stack is just a bit more complicated, fixed offset from a register, but essentially the same):

static int array[10];
And a pointer:

static int* pointer;
We then de-deference each as follows:

x = array[i];
x = pointer[i];

The thing to note is that address of the beginning of array, as well as, address of pointer (not its contents) are fixed at link/load time. Compiler then does the following:

For array de-reference:
- loads value of i,
- adds it to the value of array, i.e. its fixed address, to form target memory address,
- loads the value from calculated address
For pointer de-reference:
- loads the value of i,
- loads the value of pointer, i.e. the contents at its address,
- adds two values to form the effective address
- loads the value from calculated address.

Same happens for 2D array with additional steps of loading the second index and multiplying it by the row size (which is a constant). All this is decided at compile time, and there's no way of substituting one for the other at run-time.

Edit:

@caf here has the right solution. There's a legal way within the language to index a pointer as two-dimentional array after all.

edited Jun 30, 2010 at 1:08

answered Jun 29, 2010 at 19:54

Nikolai Fetissov

84.6k13 gold badges118 silver badges175 bronze badges

8 Comments

Nikolai Fetissov Over a year ago

yeah but the compiler is smart enough to do this in syntax when I declare a 2D array. is there no way to tell it to treat a single pointer like this?

Cogwheel Over a year ago

As platinum azure said, the compiler has no way of knowing (read: there is no way to tell it).

When you declare 2D array you have to tell the compiler the outer dimension - that's how it's "smart enough". There's no way to figure that out without this information.

I know, but I'm willing to supply this information for the sake of convenience. e.g I can imagine syntax like "int *arrayptr[][200] = memory", then it knows what the outer dimension is. but i take it there's no way to do this? (Also it needs the inner dimension, not the outer)

@Nikolai: no way of doing it for pointers, except for the function trick in my update =)

|

Platinum Azure · Accepted Answer · 2015-06-29 15:01:16Z

1

The compiler and runtime have no way of knowing your intended dimension capacities with only a multiplication in the malloc call.

You need to use a double pointer in order to achieve the capability of two indices. Something like this should do it:

#define ROWS 400
#define COLS 200

int **memory = malloc(ROWS * sizeof(*memory));

int i;
for (i = 0; i < ROWS; ++i)
{
    memory[i] = malloc(COLS * sizeof(*memory[i]);
}

memory[20][10] = 3;

Make sure you check all your malloc return values for NULL returns, indicating memory allocation failure.

edited Jun 29, 2015 at 15:01

answered Jun 29, 2010 at 19:49

Platinum Azure

46.4k13 gold badges112 silver badges136 bronze badges

7 Comments

exactly, but can I just tell it somehow? There are plenty of things in C you can tell the compiler to do, even if it might know you are wrong =P.

You could just use fixed-width arrays in that case. :-P

@Platinum: wrong, it is too big! See stackoverflow.com/questions/3144135/… . that's why i have to malloc in the first place

Well, that's my point then: Sometimes you just can't have everything. Especially with a low-level language. You can't just declare an array to be fixed-width unless you're using compile-time constants. And if you want SOME heap benefits, or all, you need to work within the constraints of the heap and the language. It sucks, I know, but what you want is just not possible in portable ANSI C.

@Platinum: see latest update, I can get it to work when passing things to a function.. really there's nothing that inherently restricts the compiler from doing this. it's not as if memory on the heap is inherently any different than memory on the stack.. but I can see that this particular feature is probably not supported.

|

par · Accepted Answer · 2015-02-11 21:10:11Z

Working from Tim's and caf's answers, I'll leave this here for posterity:

#include <stdio.h>
#include <stdlib.h>

void Test0() {
    int                             c, i, j, n, r;
    int                             (*m)[ 3 ];

    r = 2;
    c = 3;

    m = malloc( r * c * sizeof(int) );

    for ( i = n = 0; i < r; ++i ) {
        for ( j = 0; j < c; ++j ) {
            m[ i ][ j ] = n++;
            printf( "m[ %d ][ %d ] == %d\n", i, j, m[ i ][ j ] );
        }
    }

    free( m );
}

void Test1( int r, int c ) {
    int                             i, j, n;

    int                             (*m)[ c ];

    m = malloc( r * c * sizeof(int) );

    for ( i = n = 0; i < r; ++i ) {
        for ( j = 0; j < c; ++j ) {
            m[ i ][ j ] = n++;
            printf( "m[ %d ][ %d ] == %d\n", i, j, m[ i ][ j ] );
        }
    }

    free( m );
}

void Test2( int r, int c ) {
    int                             i, j, n;

    typedef struct _M {
        int                         rows;
        int                         cols;

        int                         (*matrix)[ 0 ];
    } M;

    M *                             m;

    m = malloc( sizeof(M) + r * c * sizeof(int) );

    m->rows = r;
    m->cols = c;

    int                             (*mp)[ m->cols ] = (int (*)[ m->cols ]) &m->matrix;

    for ( i = n = 0; i < r; ++i ) {
        for ( j = 0; j < c; ++j ) {
            mp[ i ][ j ] = n++;
            printf( "m->matrix[ %d ][ %d ] == %d\n", i, j, mp[ i ][ j ] );
        }
    }

    free( m );
}

int main( int argc, const char * argv[] ) {
    int                             cols, rows;

    rows = 2;
    cols = 3;

    Test0();
    Test1( rows, cols );
    Test2( rows, cols );

    return 0;
}

Community · Accepted Answer · 2015-06-29 09:58:22Z

0

int** memory = malloc(sizeof(*memory)*400); 
for (int i=0 ; i < 400 ; i++) 
{
    memory[i] = malloc(sizeof(int)*200);
}

edited Jun 29, 2015 at 9:58

CommunityBot

11 silver badge

answered Jun 29, 2010 at 19:48

Sean Nilan

1,7451 gold badge14 silver badges21 bronze badges

1 Comment