C programming: get the size of a two-dimensional pointer to arrays

Question

I am creating a two-dimensional array in C as follows:

int array1[] = {1,2,3,4,5,6,7,8,9,10};
int array2[] = {11,12,13,14,15};
int* array3[2] = {array1,array2};

and now I want to get the size of both dimensions. For the first dimension I get the correct result of 2 if I use the following code:

int array3_x = sizeof(array3)/sizeof(*array3);    // array3_x = 2

but I am not able to get the size of the other dimension. So far I have tried the following:

for (int i = 0; i < array3_x; ++i) {
  array3_y[i] = sizeof(array3[i])/sizeof(*array3[i]);
}

I always get a result of 1. Is there a way to get the correct sizes of 10 and 5?

Answer 1

There is this idea of arrays being pointers. They're not. Arrays can degenerate into pointers. The idea here is that arrays are stored contiguous in memory, so if we have a pointer to the first element, we can use pointer arithmetics to get the rest. But understand that this is a pointer to the first element, not an array.

By typing int* array3[2] = {array1,array2};, you create an array that consists of two pointer to first elements of arrays. Those pointers do not carry any information about the length of the arrays. Ever seen a function that takes such a pointer as argument? Those tend to also get the size as another argument. (except for the null-terminated arrays of char)

As a result, you have to store the information in some other way. Being used to C++, my approach would be to use a structure that imitates a class. Essentially imitating the C++ std::vector. That said, I'm not that used to C, no idea if this is the standard approach here.

Edit: An important thing here is your application. The best approach of course needs to know what you want to do. If for example you'd want to store 2D grid data, I'd simply go with a 1D array of size n*m. If you want to store jagged data, you could simply accompany it with an array that stores the sub-arrays sizes.

Answer 2

Perhaps this might work:

If you can turn the arrays into zero-terminated arrays:

int  array1[]  = {1,2,3,4,5,6,7,8,9,10,0};
int  array2[]  = {11,12,13,14,15,0};
int* array3[2] = {array1,array2};

Then you can use a function like this to get the length of each:

/********************************************************************
** Get the length of a zero-terminated int array.
*/
size_t LengthOfIntArray(int *array)
   {
   int *index = array;

   while(*index)
      ++index;

   return((size_t)(index - array));
   }

And you can print the length of each array like this:

/********************************************************************
** Program start
*/
int main(void)
   {
   int i;
   int array3_x = sizeof(array3)/sizeof(*array3);    // array3_x = 2

   printf("Height of array3: %d\n", array3_x);

   for(i = 0; i < array3_x; ++i)
      printf("Length of array3[%d]: %zd\n", i, LengthOfIntArray(array3[i]));

   return(0);
   }

The output will be:

Height of array3: 2
Length of array3[0]: 10
Length of array3[1]: 5

Answer 3

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

int main() {
    int array1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    int array2[] = {10, 11, 12, 13, 14};
    int *array3[] = {array1, array2};
    unsigned long int c1, c2, c3;

    c1 = sizeof(array1) / sizeof(*array1);
    c2 = sizeof(array2) / sizeof(*array2);
    c3 = sizeof(array3) / sizeof(*array3);

    printf("size of array1 : %2lu\n", c1);
    printf("size of array2 : %2lu\n", c2);
    printf("size of array3 : %2lu\n", c3);

    /* so far, so good ...
       however, the following "printf"s will fail
       to give assumed results
    */

    c1 = sizeof(array3[0]) / sizeof(*array3[0]);
    c2 = sizeof(array3[1]) / sizeof(*array3[1]);

    printf("size of array1 : %2lu\n", c1);
    printf("size of array2 : %2lu\n", c2);

    return 0;
}

In your code, on line array3_y[i] = sizeof(array3[i])/sizeof(*array3[i]); in the for loop, array3[i] does no more point to an array --the compiler has no information about the length of the variable that it's pointing at, whether it is an array, a single char or an int or something else-- but it is just a plain pointer (presumably a pointer pointing to a default int).

I think your current system is using 32 bits for addressing (sizeof(unsigned int) / sizeof(int)); my system, using 64 bits, spits "2" as a result (i.e. sizeof(unsigned long int) / sizeof(int)).

Answer 4

No. You can't. The compiler never knows the array size your pointer is pointing to.

Ref: How to find the 'sizeof' (a pointer pointing to an array)?