To know the size of an array in c

Question

I am learning C language. I want to know the size of an array inside a function. This function receive a pointer pointing to the first element to the array. I don't want to send the size value like a function parameter.

My code is:

#include <stdio.h>

void ShowArray(short* a);

int main (int argc, char* argv[])
{
    short vec[] = { 0, 1, 2, 3, 4 };
    short* p = &vec[0];
    ShowArray(p);

    return 0;
}

void ShowArray(short* a)
{
    short i = 0;

    while( *(a + i) != NULL )
    {
        printf("%hd ", *(a + i) );

        ++i;
    }

    printf("\n");
}

My code doesn't show any number. How can I fix it?

Thanks.

Answer 1

Arrays in C are simply ways to allocate contiguous memory locations and are not "objects" as you might find in other languages. Therefore, when you allocate an array (e.g. int numbers[5];) you're specifying how much physical memory you want to reserve for your array.

However, that doesn't tell you how many valid entries you have in the (conceptual) list for which the physical array is being used at any specific point in time.

Therefore, you're required to keep the actual length of the "list" as a separate variable (e.g. size_t numbers_cnt = 0;).

I don't want to send the size value like a function parameter.

Since you don't want to do this, one alternative is to use a struct and build an array type yourself. For example:

struct int_array_t {
    int *data;
    size_t length;
};

This way, you could use it in a way similar to:

struct int_array_t array;
array.data    = // malloc for array data here...
array.length  = 0;
// ...
some_function_call(array);  // send the "object", not multiple arguments

Now you don't have to write: some_other_function(data, length);, which is what you originally wanted to avoid.

To work with it, you could simply do something like this:

void display_array(struct int_array_t array)
{
    size_t i;
    printf("[");
    for(i = 0; i < array.length; ++i)
        printf("%d, ", array.data[i]);
    printf("]\n");
}

I think this is a better and more reliable alternative than another suggestion of trying to fill the array with sentinel values (e.g. -1), which would be more difficult to work with in non-trivial programs (e.g. understand, maintain, debug, etc) and, AFAIK, is not considered good practice either.

For example, your current array is an array of shorts, which would mean that the proposed sentinel value of -1 can no longer be considered a valid entry within this array. You'd also need to zero out everything in the memory block, just in case some of those sentinels were already present in the allocated memory.

Lastly, as you use it, it still wouldn't tell you what the actual length of your array is. If you don't track this in a separate variable, then you'll have to calculate the length at runtime by looping over all the data in your array until you come across a sentinel value (e.g. -1), which is going to impact performance.

In other words, to find the length, you'd have to do something like:

size_t len = 0;
while(arr[len++] != -1);        // this is O(N)
printf("Length is %u\n", len);

The strlen function already suffers from this performance problem, having a time-complexity of O(N), because it has to process the entire string until it finds the NULL char to return the length.

Relying on sentinel values is also unsafe and has produced countless bugs and security vulnerabilities in C and C++ programs, to the point where even Microsoft recommends banning their use as a way to help prevent more security holes.

I think there's no need to create this kind of problem. Compare the above, with simply writing:

// this is O(1), does not rely on sentinels, and makes a program safer
printf("Length is %u\n", array.length);

As you add/remove elements into array.data you can simply write array.length++ or array.length-- to keep track of the actual amount of valid entries. All of these are constant-time operations.

You should also keep the maximum size of the array (what you used in malloc) around so that you can make sure that array.length never goes beyond said limit. Otherwise you'd get a segfault.

Answer 2

One way, is to use a terminator that is unique from any value in the array. For example, you want to pass an array of ints. You know that you never use the value -1. So you can use that as your terminator:

#define TERM (-1)

void print(int *arr)
{
    for (; *arr != TERM; ++arr)
        printf("%d\n", *arr);
}

But this approach is usually not used, because the sentinel could be a valid number. So normally, you will have to pass the length.

You can't use sizeof inside of the function, because as soon as you pass the array, it decays into a pointer to the first element. Thus, sizeof arr will be the size of a pointer on your machine.

Answer 3

#include <stdio.h>

void ShowArray(short* a);

int main (int argc, char* argv[])
{
    short vec[] = { 0, 1, 2, 3, 4 };
    short* p = &vec[0];
    ShowArray(p);

    return 0;
}

void ShowArray(short* a)
{
    short i = 0;
    short j;

    j = sizeof(*a) / sizeof(short);

    while( i < j )
    {
        printf("%hd ", *(a + i) );
        ++i;
    }

    printf("\n");
}

Not sure if this will work tho give it a try (I don't have a pc at the moment)