Passing arbitrary size 2D array of structs to function in C

Question

I am new to C.

I have a 2D array of structs whose sizes i,j are determined at runtime.

I want to pass this array as argument to a function and iterate over all elements.

Here is a prototype of the code:

typedef struct obj {
    char id[10];
    int value;
} Object;

I tried the following but it didn't work:

int sum_all_elements(Object *obj_ptr);

int main() {
    int i, j; //gotten from user input which I omitted

    Object o[i][j];

    int total = sum_all_elements(&o);
}

What is the correct way to pass o[i][j] and how to iterate over it in the function?

Also, I would like to create functions that update elements in the 2D array, is there a way I can make changes in a function and have the effects persist when I return from the function?

Answer 1

With your typedef as follows:

enum { IDL = 10 };

typedef struct {
    char id[IDL];
    int value;
} obj;

If you are intent on using a 2D VLA, then you are better off thinking of passing the address of the first row, rather than the address of the first element. (even though the two address are the same) Why? An array (e.g. obj o[i][j];) when passed as a parameter to a function will have the first level of indirection converted to a pointer (e.g. obj o[i][j] becomes obj (*o)[j]).

Take for example your VLA declared in main as follows:

    obj o[i][j];    /* declare VLA */

So your function declaration will need to match (and since the number of columns is non-constant, be in the correct order) For instance:

int sum_all_elements (int i, int j, obj (*obj_ptr)[j]);

You can then call the function within your program as, for example:

    printf ("\n sum : %d\n\n", sum_all_elements (i, j, &o[0]));

which is simply equivalent to:

    printf ("\n sum : %d\n\n", sum_all_elements (i, j, o));

Putting a short example together (and just filling obj[a][b].value = a + b;), you can do something similar to the following:

#include <stdio.h>

enum { IDL = 10 };

typedef struct {
    char id[IDL];
    int value;
} obj;

int sum_all_elements (int i, int j, obj (*obj_ptr)[j]);

int main (void) {

    int i, j;

    printf ("\n enter i & j: ");
    if (scanf (" %d %d", &i, &j) != 2) {
        fprintf (stderr, "error: invalid input, i, j.\n");
        return 1;
    }

    obj o[i][j];    /* declare VLA */

    for (int a = 0; a < i; a++)
        for (int b = 0; b < j; b++)
            o[a][b].value = a + b;  /* fill value with misc a + b */

    printf ("\n sum : %d\n\n", sum_all_elements (i, j, o));

    return 0;
}

/* some all .value for i x j array of obj */
int sum_all_elements (int i, int j, obj (*obj_ptr)[j])
{
    int sum = 0;

    for (int a = 0; a < i; a++)
        for (int b = 0; b < j; b++)
            sum += obj_ptr[a][b].value;

    return sum;
}

Example Use/Output

$ ./bin/p2p2a

 enter i & j: 10 10

 sum : 900

Answer 2

If you are using C99 or later you can use VLAs to accomplish this. Here is an example that asks the user to enter the information for the id and value fields of your Object struct, and then calls a function to display the contents of the 2d VLA:

#include <stdio.h>

typedef struct obj {
    char id[10];
    int value;
} Object;

void show_obj(int rows, int cols, Object arr[rows][cols]);

int main(void)
{
    int num_rows, num_cols;
    int row, col;

    num_rows = 3;
    num_cols = 3;

    Object obj_arr[num_rows][num_cols];

    for (row = 0; row < num_rows; row++)
        for (col = 0; col < num_cols; col++) {
            printf("Element [%d][%d]:\n", row, col);
            printf("    enter id: ");
            scanf("%9s", obj_arr[row][col].id);
            printf("    enter value: ");
            scanf("%d", &(obj_arr[row][col].value));
        }

    show_obj(num_rows, num_cols, obj_arr);

    return 0;
}

void show_obj(int num_rows, int num_cols, Object obj_arr[num_rows][num_cols])
{
    int row, col;

    for (row = 0; row < num_rows; row++)
        for (col = 0; col < num_cols; col++) {
            printf("Element [%d][%d]:\n", row, col);
            printf("    id: %s\n", obj_arr[row][col].id);
            printf("    value: %d\n", obj_arr[row][col].value);
        }
}

When you pass a VLA to a function, notice that you have to pass the dimensions of the array first.

Another approach is to manually allocate memory for the structs, and then to simulate a 2d array. You can allocate space for a number of pointers to pointers to Object structs. Each of these pointers points to the first Object of a row of Object structs, so you then allocate space to store Objects in each row. The following code demonstrates this second approach. Once it is set up, obj_arr is accessed and passed around as if it were a 2d array. One downside of this approach is that you are required to manually free your memory allocations. But, this approach will work on pre-C99 compilers:

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

typedef struct obj {
    char id[10];
    int value;
} Object;

void show_obj(Object **arr, int rows, int cols);

int main(void)
{
    int num_rows, num_cols;
    int row, col;

    num_rows = 3;
    num_cols = 3;

    Object **obj_arr = malloc(sizeof(Object *) * num_rows);

    for (row = 0; row < num_rows; row++)
        obj_arr[row] = malloc(sizeof(Object) * num_cols);

    for (row = 0; row < num_rows; row++)
        for (col = 0; col < num_cols; col++) {
            printf("Element [%d][%d]:\n", row, col);
            printf("    enter id: ");
            scanf("%9s", obj_arr[row][col].id);
            printf("    enter value: ");
            scanf("%d", &(obj_arr[row][col].value));
        }

    show_obj(obj_arr, num_rows, num_cols);

    /* Free allocated memory */
    for (row = 0; row < num_rows; row++)
        free(obj_arr[row]);
    free(obj_arr);       

    return 0;
}

void show_obj(Object **obj_arr, int num_rows, int num_cols)
{
    int row, col;

    for (row = 0; row < num_rows; row++)
        for (col = 0; col < num_cols; col++) {
            printf("Element [%d][%d]:\n", row, col);
            printf("    id: %s\n", obj_arr[row][col].id);
            printf("    value: %d\n", obj_arr[row][col].value);
        }
}

Answer 3

Are you absolutely, positively sure that you need:

• a 2-dimensional array?
• …allocated as a VLA? VLAs are considered bad practice.

I`d recommend to use a «linear» array and allocate memory via malloc() (or calloc() if you want it zero-initialized upon creation). Something like that:

Object *o;
o = (Object*)calloc(i * j, sizeof(Object));

... (doing something with o)

int total = sum_all_elements(o, i, j);

... (now it is time to free the allocated memory)

free(o);
o = 0;

 

int sum_all_elements(Object *obj_ptr, int i, int j) {
    int x, y, s;
    for (s = y = 0; y < j; y++)
        for (x = 0; x < i; x++) {
            s += obj_ptr[j * y + x].value;
        }
    return s;
}