Passing a 2D array to a function in C?

Question

I need to pass a 2D array to a function.

#include <stdio.h>

#define DIMENSION1 (2)
#define DIMENSION2 (3)

void func(float *name[])
{
    for( int i=0;i<DIMENSION1;i++){
        for( int j=0;j<DIMENSION2;j++){
            float element = name[i][j];
            printf("name[%d][%d] = %.1f \n", i, j, element);
        }
    }
}


int main(int argc, char *argv[])
{
        float input_array[DIMENSION1][DIMENSION2] = 
        { 
            {0.0f, 0.1f, 0.2f}, 
            {1.0f, 1.1f, 1.2f} 
        };

        func(input_array);

        return 0;
}

Dimensions vary depending on the use case, and the func should stay the same.

I tried the above int func(float *[]) but compiler complains expected ‘float **’ but argument is of type ‘float (*)[3]’, and also I get the segmentation fault error at runtime when trying to access the array at element = name[i][j].

What would be the proper signature of my function? Or do I need to call the func differently?

Answer 1

This is going to present a very old solution, one that works on every C compiler that exists. The idea goes something like this:

• I have multiple pieces of information to keep track of
• I should keep them together

This leads us to the idea that we can use a composite type to hold all the related information in one place and then treat that object as a single entity in our code.

There is one more pebble in our bowl of sand:

• the size of the information varies

Whenever we have varying-sized objects, dynamic memory tends to get involved.

Arrays vs Pointers

C has a way of losing information when you pass an array around. For example, if you declare a function like:

void f( int a[] )

it means exactly the same thing as:

void f( int * a )

C does not care that the size of the array is lost. You now have a pointer. So what do we do? We pass the size of the array also:

void f( int * a, size_t n )

C99 says “I can make this prettier, and keep the array size information, not just decay to a pointer”. Okay then:

void f( size_t dim1, size_t dim2, float array[dim1][dim2] )

We can see that it is pretty, but we still have to pass around the array’s dimensions!

^{This is reasonable, as the compiler needs to make the function work for any array, and array size information is kept by the compiler, never by executable code.}

The other answers here either ignore this point or (helpfully?) suggest you play around with macros — macros that only work on an array object, not a pointer. This is not an inherently bad thing, but it is a tricky gotcha: you can hide the fact that you are still individually handling multiple pieces of information about a single object, except now you have to remember whether or not that information is available in the current context.

I consider this more grievous than doing all the hard stuff once, in one spot.

Instead of trying to juggle all that, we will instead use dynamic memory (we are messing with dynamic-size arrays anyway, right?) to create an object that we can pass around just like we would with any other array.

The old solution presented here is called “the C struct hack”. It is improved in C99 and called “the flexible array member”. The C struct hack has always worked with all known compilers just fine, even though it is technically undefined behavior. The UB problem comes in two parts:

• writing past the end of any array is unchecked, and therefore dangerous, because the compiler cannot guarantee you aren’t doing something stupid outside of its control
• potential memory alignment issues

Neither of these are an actual issue. The ‘hack’ has existed since the beginning (much to Richie’s reported chagrin, IIRC), and is now codified (and renamed) in C99.

How does this magic work, you ask?

Wrap it all up in a struct:

struct array2D
{
  int rows, columns;
  float values[];     // <-- this is the C99 "flexible array member"
};
typedef struct array2D array2D;

This struct is designed to be dynamically-allocated with the required size. The more memory we allocate, the larger the values member array is.

Let’s write a function to allocate and initialize it properly:

array2D * create2D( int rows, int columns )
{
  array2D * result = calloc( sizeof(array2D) + sizeof(float) * rows * columns, 1 );  // The one and only hard part
  if (result)
  {
    result->rows    = rows;
    result->columns = columns;
  }
  return result;
}

Now we can create a dynamic array object, one that knows its own size, to pass around:

array2D * myarray = create2D( 3, 4 );
printf( "my array has %d rows and %d columns.\n", myarray->rows, myarray->columns );
free( myarray );  // don’t forget to clean up when we’re done with it

The only thing left is the ability to access the array as if it were two-dimensional. The following function returns a pointer to the desired element:

float * index2D( array2D * a, int row, int column )
{
  return a->values + row * a->columns + column;  // == &(a->values[row][column])
}

Using it is easy, if not quite as pretty as the standard array notation. But we are messing with a compound object here, not a simple array, and it goes with the territory.

*index2D( myarray, 1, 3 ) = M_PI;  // == myarray[ 1 ][ 3 ] = M_PI

If you find that intolerable, you can use the suggested variation:

float * getRow2D( array2D * a, int row )
{
  return a->values + row * a->columns;  // == a->values[row]
}

This will get you “a row”, which you can array-index with the usual syntax:

getRow2D( myarray, 1 )[ 3 ] = M_PI;  // == myarray[ 1 ][ 3 ] = M_PI

You can use either if you wish to pass a row of your array to a function expecting only a 1D array of floats:

void some_function( float * xs, int n );

some_function( index2D( myarray, 1, 0 ), myarray->columns );
some_function( getRow2D( myarray, 1 ), myarray->columns );

At this point you have already seen how easy it is to pass our dynamic 2D array type around:

void make_identity_matrix( array2D * M )
{
  for (int row = 0;  row < M->rows;     row += 1)
  for (int col = 0;  col < M->columns;  col += 1)
  {
    if (row == col)
      *index2D( M, row, col ) = 1.0;
    else
      *index2D( M, row, col ) = 0.0;
  }
}

Shallow vs Deep

As with any array in C, passing it around really only passes a reference (via the pointer to the array, or in our case, via the pointer to the array2D struct). Anything you do to the array in a function modifies the source array.

If you want a true “deep” copy of the array, and not just a reference to it, you still have to do it the hard way. You can (and should) write a function to help. This is no different than you would have to do with any other array in C, no matter how you declare or obtain it.

array2D * copy2D( array2D * source )
{
  array2D * result = create2D( source->rows, source->columns );
  if (result)
  {
    for (int row = 0;  row < source->rows;  row += 1)
    for (int col = 0;  col < source->cols;  col += 1)
      *index2D( result, row, col ) = *index2D( source, row, col );
  }
  return result;
}

Honestly, that nested for loop could be replaced with a memcpy(), but you would have to do the hard stuff again and calculate the array size:

array2D * copy2D( array2D * source )
{
  array2D * result = create2D( source->rows, source->columns );
  if (result)
  {
    memcpy( result->values, source->values, sizeof(float) * source->rows * source->columns );
  }
  return result;
}

And you would have to free() the deep copy, just as you would any other array2D that you create. This works the same as any other dynamically-allocated resource, array or not, in C:

 array2D * a = create2D( 3, 4 ); // 'a' is a NEW array
 array2D * b = copy2D( a );      // 'b' is a NEW array (copied from 'a')
 array2D * c = a;                // 'c' is an alias for 'a', not a copy
 
 ...
 
 free( b );  // done with 'b'
 free( a );  // done with 'a', also known as 'c'

That c reference thing is exactly how pointer and array arguments to functions work in C, so this should not be something surprising or new.

void myfunc( array2D * a ) // 'a' is an alias, not a copy

Hopefully you can see how easy it is to handle complex objects like variable-size arrays that keep their own size in C, with only a minor amount of work in one or two spots to manage such an object. This idea is called encapsulation (though without the data hiding aspect), and is one of the fundamental concepts behind OOP (and C++). Just because we’re using C doesn’t mean we can’t apply some of these concepts!

Finally, if you find the VLAs used in other answers to be more palatable or, more importantly, more correct or useful for your problem, then use them instead! In the end, what matters is that you find a solution that works and that satisfies your requirements.

Answer 2

As noted above in the comment, the key problem is that int func(float *name[]) declares name to be an array of pointers to float.

In this sense, the following modification to main() works:

int main(int argc, char *argv[])
{
        float input_array[DIMENSION1][DIMENSION2] = 
        { 
            {0.0f, 0.1f, 0.2f}, 
            {1.0f, 1.1f, 1.2f} 
        };

        /* Declare an array of pointers, as this is what func requires at input: */
        float* in_p[DIMENSION1];       
        /* ... and initialize this array to point to first elements of input array: */
        for( int i=0;i<DIMENSION1;i++)
            in_p[i] = input_array[i];
        /* ... and send this array of pointers to func: */
        func(in_p);

        return 0;
}

Answer 3

You can use the following function prototype:

int func(int dim1, int dim2, float array[dim1][dim2]);

For this you have to pass both dimensions to the function (you need this values anyhow in the function). In your case it can be called with

func(DIMENSION1, DIMENSION2, input_array);

To improve the usability of the function call, you can use the following macro:

#define FUNC_CALL_WITH_ARRAY(array) func(sizeof(array)/sizeof(*(array)), sizeof(*(array))/sizeof(**(array)), array)

Then you can call the function and it will determine the dimensions itself:

FUNC_CALL_WITH_ARRAY(input_array);

Full example:

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

#define FUNC_CALL_WITH_ARRAY(array) func(sizeof(array)/sizeof(*(array)), sizeof(*(array))/sizeof(**(array)), array)
int func(int dim1, int dim2, float array[dim1][dim2])
{
    printf("dim1 %d, dim2 %d\n", dim1, dim2);

    return 0;
}

#define DIMENSION1 (4)
#define DIMENSION2 (512)



int main(int argc, char *argv[])
{
    float input_array[DIMENSION1][DIMENSION2];

    FUNC_CALL_WITH_ARRAY(input_array);

    float input_array2[7][16];

    FUNC_CALL_WITH_ARRAY(input_array2);
}

Will print

dim1 4, dim2 512
dim1 7, dim2 16

Answer 4

Dimensions vary depending on the use case, and the func should stay the same.

Use VLA:

void func (int r, int c, float arr[r][c]) {
    //access it like this
    for (int i = 0; i < r; ++i) {
        for (int j = 0; j < c; ++j) {
            printf ("%f\n", arr[i][j]);
        }
    }
}

// call it like this

func (DIMENSION1, DIMENSION2, input_array);

Answer 5

You can change your function like this;

int func(float (*arr)[DIMENSION2])
{

}

But also you should change your main code like this;

float input[DIMENSION1][DIMENSION2];//I just upload the dimension1 to dimension2