Is there a way to find array length in a function without passing an argument?

Question

Is there a way I could get the length of an array inside a function? I need to find the size of an array, however it is defined in the main function and I cannot pass the array size as an argument as I cannot change the main function. So is there any way to find it through the function?

The array's max size is set to be roughly 100, however the actual input will be anywhere between size 1 - 20. So I can't really take the max size approach either.

Answer 1

No, arrays always decay to pointers when passing into functions so you must pass the length in if you want the function to know the size. With some preconditions you have multiple ways to do that without an additional parameter:

• Add a null/zero/whatever special parameter at the last, similar to a null-terminated char array. This is only possible if you really know there's a unique value that never appears in the value list to put at the final position. This method is actually very common in Linux system calls, for example the exec family

  char *args[] = { "Hello", "C", "Programming", NULL /* ends the array */ };
  execv("./hello", args);
  

• Add a length prefix at the beginning

  void my_function(int array[])
  {
      int length = array[0];
      int* data = &array[1];
      // operate on data[];
  }
  
  int my_data[LENGTH + 1] = { LENGTH, /* values */ };
  my_function(my_data);
  

  Pascal also uses length-prefixed string, so its string is limited to only 255 characters with a 1-byte length. But this can be fixed by using a bigger length

  A variation of this is BSTR in Windows where the pointer points to the actual data instead of start of the struct

  typedef struct MY_ARRAY
  {
      int32_t length;
      my_type* data;  // array of the desired type
  } my_array;
  
  void my_function(my_type array[])
  {
      int length;
      memcpy(&length, (char*)array - sizeof(int32_t), sizeof(int32_t));
      // operate on array[];
  }
  
  my_type data_list[] = { /* some data */ };
  my_array my_data = { LENGTH, data_list };
  my_function(my_data.data);
  

Answer 2

if the function is declared for example like

void f( T a[] );

where T is some type specifier then the function deals with a pointer to the type T. That is the above declaration is equivalent to the following declaration

void f( T *a );

and the both declare the same one function.

So the only way to calculate the number of actual elements in the array pointed to by the pointer is to introduce a sentinel value that will differ from values of actual elements of the array.

For example a character array can have such a sentinel value like '\0' that is when a character array contains a string.

An array of strings can have as a sentinel value either an empty string "" or depending on how it is declared (for example as an array of element type char *) the sentinel value can be NULL.

For integer arrays you have yourself to select an appropriate value as a sentinel value. For example if actual elements are non-negative then the sentinel value can be set to -1.

Answer 3

You could include a for loop with a counter to see how many variables there are before the the next line.

int counter(int array[100]) {
    int counter = -1;
    for (i = 0; array != '\0'; i++) {
        counter = counter + 1;
    }
    return counter;
}

and then in the main section

int arraysize = counter();