Mallocing a 3 dimensions array

Question

I have to use a 3 dimensions array because I want to divide a pic into squares and store the average of the RGB of each square in my array. I want it to be this size, tab[height][width][3], so I did that:

i = 0; j = 0; k = 0;

    float*** tab;
    tab = malloc((hauteur+1)*sizeof(float*));

    while(i <= hauteur){
        tab[i] = malloc((largeur+1)*sizeof(float**) );
        i++;
    }
    i = 0;
    while(i <= hauteur){
        j = 0;
        while (j <= largeur){
            tab[i][j] = malloc(3*sizeof(float***));
            j++;
        }
        i++;
    }

but I have a segfault after : tab[1][30][2];.

Is there a problem in my malloc?

It's strange because it doesn't segfault when I declare tab using: tab[hauteur][largeur][3].

(Sorry: "hauteur" means "height" in French and "largeur" means "width".)

(If you think you need to check my whole function: http://pastebin.com/eqQXz8Ad; it's a writer for a JPEG file.)

Answer 1

Your types aren't right in your malloc calls. I'd suggest the following:

tab = malloc( (hauteur + 1) * sizeof *tab );       // sizeof (float **)
tab[i] = malloc( (largeur + 1) * sizeof *tab[i] ); // sizeof (float *)
tab[i][j] = malloc( 3 * sizeof *tab[i][j] );       // sizeof (float)

Given the declaration of tab, the following are all true:

Expression                Type
----------                ----
       tab                float ***
      *tab                float **
    tab[i]                float **
   *tab[i]                float *
 tab[i][j]                float *
*tab[i][j]                float

I usually recommend taking the sizeof of the target expression, rather than an explicit type; that way, if you ever change the type of tab (from float to double, for example), you never have to touch the malloc calls.

Answer 2

What you are crafting is basically an array of array of array of pointers to float, not a three dimensional array of floats. You may want have a look at this Ambiguity in 2d array declaration in C. It works out a similar problem with a bidimensional array.

Maybe the solution for your problem can looks like:

float (*tab)[hauteur][largeur][3];    //declare a pointer to a real array

tab = malloc(hauteur * largeur * 3 * sizeof(float));    //Allocate room for threedimensional array

for (int i=0; i<hauteur; i++)
    for (int j=0; j<largeur; j++)
        for (int k=0; k<3; k++)
        {
            (*tab)[i][j][k] = (float)((i*100)+j*1000+k);    //Fill elements with something using threedimensional subscripting
        }
for (int i=0; i<hauteur; i++)
    for (int j=0; j<largeur; j++)
        for (int k=0; k<3; k++)
        {
            printf("[%d][%d][%d]=%f\n", i, j, k, (*tab)[i][j][k]);    //Check back data...
        }

EDITED Looking at comments I see that it is someway 'unnatural' to access an array using the pointer to array notation (*array)[a][b]...[n] even if this notation explicitly report whole dimensions in declaration. To make more friendly the usage you can use the form below that allows the well known format:

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

int largeur = 10;
int hauteur = 10;

int main(int argc, char *argv[])
{
    float (*tab)[largeur][3];    //declare a bidimensional array of pointers to our variable
                               //this fools the compiler acting as a one more dimension array of variable

    tab = malloc(hauteur * largeur * 3 * sizeof(float));    //Allocate room for threedimensional array

    for (int i=0; i<hauteur; i++)
        for (int j=0; j<largeur; j++)
            for (int k=0; k<3; k++)
            {
                tab[i][j][k] = (float)((i*100)+j*1000+k);    //Fill elements with something using threedimensional subscripting
                //This use the natural addressing...
            }
    for (int i=0; i<hauteur; i++)
        for (int j=0; j<largeur; j++)
            for (int k=0; k<3; k++)
            {
                printf("[%d][%d][%d]=%f\n", i, j, k, tab[i][j][k]);    //Check back data...
            }
}

This kind of trick works because of the lack of multidimensional array concept in C language.
C knows only of array, or better it should have been string, of something, so a bidimensional array is simply an array of arrays of something. If we add one more dimension it is an array of an array of an array of something ... and so on for each more dimension we add.
This defines the memory layout of arrays in C and the addressing method that the compiler uses to access data. Because the data is streamed in memory to access a value at a specific subscript the compiler need to compute the space used for all dimensions but the very first.

+++ I fixed a bug, now the sample can be compiled under any C99-C11 compliant compiler and works.

Answer 3

If you care a lot about efficiency, you should consider having a single dimension array (like in Frankie_C's answer):

 int height = something_to_compute_height();
 int width = something_to_compute_width();
 double *arr = malloc(height*width*3*sizeof(double));
 if (!arr) { perror("malloc"); exit(EXIT_FAILURE); }

^{(as an aside, even if we both are native French speakers, let's try to use English in questions and code here)}

then you might define a macro to ease speaking of some element inside arr

#define ELEM_ARR(a,i,j,k) a[i*width*height+j*width+k]
#define ARR(i,j,k) ELEM_ARR(arr)

^{(You've got the idea, details can be different)}

This is probably more efficient than your array of pointers to array of pointers because of cache locality and because you need only one single allocation.

Choose carefully row-major or column-major access to fit the most frequent access patterns.

If height & width are specific to each array, you could use some flexible array member as last in a struct.

As a rule of thumb, it is useful in C to use multidimensional arrays only if all the dimensions (except perhaps the last) are a compile-time constant, e.g. double arr3d[3][4][5];; otherwise, better have a single-dimension array and do the index computing by yourself.

BTW, if you care a lot about performance, you might be concerned by OpenCL and OpenMP (and both usually prefer single-dimensional arrays).