Find the Array length inside Function

Question

Based on This Question Calculate Length of Array in C by Using Function i really need an explanation.

Let's say we have an Array like this:

int arr[] = {1,2,3};

here arr has the length 3, so passing into a Function will decay to Pointer and we lose track of its Length.

What happens if we Null terminate this array using '\0' like this:

int arr[] = {1,2,3,'\0'};

And pass it to a function like this:

void foo(int *arr){
    int length = 0;

    while(arr[length] != '\0'){
        length++;
    }

    printf("Length = %d\n",length);
}

Is this ok?

I wrote the following code:

#include<stdio.h>

void foo(int *arr);

int main(void){
    int arr1[]  = {10,'\0'};
    int arr2[]  = {12,44,'\0'};
    int arr3[]  = {87,1,71,'\0'};
    int arr4[]  = {120,15,31,82,'\0'};
    int arr5[]  = {28,49,16,33,11,'\0'};
    int arr6[]  = {19,184,90,52,38,77,'\0'};
    int arr7[]  = {2,17,23,41,61,78,104,'\0'};
    int arr8[]  = {16,92,11,35,52,118,79,44,'\0'};
    int arr9[]  = {20,44,33,75,49,36,9,2,11,'\0'};
    int arr10[] = {92,145,24,61,99,145,172,255,300,10,'\0'};

    foo(arr1);
    foo(arr2);
    foo(arr3);
    foo(arr4);
    foo(arr5);
    foo(arr6);
    foo(arr7);
    foo(arr8);
    foo(arr9);
    foo(arr10);
    return 0;
}


void foo(int *arr){
    int length = 0;

    while(arr[length] != '\0'){
        length++;
    }

    printf("Length = %d\n",length);
}

And i got the following Output:

Length = 1
Length = 2
Length = 3
Length = 4
Length = 5
Length = 6
Length = 7
Length = 8
Length = 9
Length = 10

Which prints the Length of all 10 arrays. Now I'm confused here, because as far of my concern, as I read in some books, there is no way to make it work.

Why foo prints the length of all arrays? It is illegal to use something like int arr[] = {1,2,3,'\0'}; ? I know that if the Array has a 0 inside like this int arr[] = {1,2,0,3,4}; the length will be 2, but this is not my question.

Answer 1

It is illegal to use something like int arr[] = {1,2,3,'\0'}; ?

No. It's perfectly legal. '\0' is an int which is same as 0. It's no different to using any number as marker to identify the end of the array. For example, you can use -1 if you array is going to contain only positive number. So your approach is valid.

The reason you wouldn't usually see in practice it's kind of needless to iterate over an array when you can simply pass it as an extra argument, which is easily understandable from maintenance point of view.

int arr[1024];
size_t len = sizeof arr/sizeof a[0];

func(arr, len);

void func(int *a, size_t length) {
}

Compare this with your approach.

Also, the size is calculated at compile-time whereas in your approach you have iterate over the array. Choosing the right sentinel could become difficult ( o or -1 or whatever) if it's also needed to be an element of the array.

Answer 2

This is how C-strings mark their end and length. And as they're just char arrays, naturally you can apply the same to other types of arrays as well.

Just remember that calculating the length of such an array through a pointer has a linear time complexity.

Answer 3

Sidenote: '\0' is really 0 here, as your store ints.

---

You're using a sentinel. C-style strings have been using this method for decades to mark where the string finishes. It has the same benefits, but it also has the same drawbacks.

As long as you maintain the invariant that the sentinel occours only at the last place of the array you'll be able to get the length of the array. In O(N) time, as you have to traverse the sequence.

Note that you can shrink the sequence by terminating it earlier with a sentinel:

1 2 3 4 0   //
1 2 3 0 *   // * as in: anything

But as soon as you do this, you cannot known the size of the array anymore. Even though you could technically append an extra element, a function without knowing the context cannot safely do this. In essence, you know the size of the sequence, but you don't known the size of the array anymore.

Answer 4

If you need a method to use to allow you to carry the array length with the array then try using one of these approaches.

Store the length in the start of the array

So (ideally) array[0], the first element would be a length.

The catch is that that only works if your array has a suitable type and the length fit in that type. You can in principle use union to define an element large enough to hold different types of data, including the length, but it's potentially wasteful.

Maintain a structure to store the array length and a pointer to the array data.

This is something like :

struct arrayinfo_s {
    int length ;
    char *data ;
    };

char name[1000] ;

struct arrayinfo a ;

a.length = sizeof(name) ;
a.data = name ;

myfunc( &arrayinfo ) ;

There are many variations on this possible.

The "standard" convention.

As someone already mentioned, it is typical to track the array length and pass it as a separate parameter to the function.

myfunc( array, length ) ;

If array is a fixed size declared like e.g. int nums[100] ; then you can use sizeof(nums) if the variable was declared in the same function as you used sizeof() or globally.

There is also a variation on this for allowing a function to return an array of unknown length. Typically you would do something like returning a point to the array, but pass a parameter that is a pointer to some integer type to store the length of the new array in.

char *newstuff( int *newlength )
{
    char *p = NULL ;

    p = malloc( 102 ) ;

    if( p == NULL )
    {
        *length = 102 ;
        return p ;
    }
    else
    {
        *length = 0 ;
        return NULL ;
    }
}