Write a c program to determine the size of an array?

Answer 1

using sizeof operator the size of whole array can be calculated, then divide it with the zise of the datatype(E.g. for int =4, char =2....etc.)

Example:

#define Narray (sizeof(array)/sizeof(array[0]))

Answer 2

It is not possible to determine the size of an array without also knowing the number of elements. But if you know the number of elements then you also know the size, so there's really nothing to determine.

int size_of_array (int a[], int size) {

return size;

}

Clearly this is a pointless function given that the caller has to know the size in advance. The a parameter isn't even used but you might ask why we even need to pass the size at all. Why can't we simply calculate the size from the a parameter alone? Well, let's just try that:

int size_of_array (int a[]) { return sizeof (a);

}

On a 32-bit system the return value will always be 4. On a 64-bit system the return value will always be 8. This is because although we declared the variable 'a' to be an array of type int, what we actually passed was a pointer to int. That is; we'd get exactly the same result as we would had we declared the function as follows instead:

int size_of_array (int* a) {

return sizeof (a);

}

In other words the function returns the length of the pointer (in bytes) not the size of the array being pointed at. What if we dereference the pointer?

int size_of_array (int a[]) {

return sizeof (*a);

}

Again this won't work because a is really a pointer to int so the return value will be sizeof (int) rather than sizeof (int*). Remember that an int and a pointer are not necessarily the same length. On a 64-bit system a pointer is always 8 bytes long but an int may only be 4 bytes long. On such a system this function will always return 4.

It therefore follows that in order to pass an array to a function we must also pass its size, which means we must know its size in advance. Every array we create has a size which must be known in advance because without knowing the size we wouldn't know how much memory to allocate to the array:

void f (const int size) {

int* a = (int*) malloc (size * sizeof (int));

// use array...

free (a);

}

In other words, the size of an array, even variable-length arrays, has to be known in advance. In the above example the actual size is determined at runtime but the function doesn't have to determine what the size is because it has to be given via the size parameter. Thus the function knows the size before the array is physically allocated; thus it is known in advance. And if the function needs to pass the array to another function then it must also pass the size of that array.

Given that the size and type of an array must be known in advance of actually using that array, it follows that we can determine how much memory (in bytes) has been allocated to the array; we simply multiply the number of elements by the size of its type:

int length_of_array (int a[], const int size) {

return size * sizeof (int);

}

But we're not actually determining anything we didn't already know. Look again at our call to malloc in the previous function and you will see that we'd already calculated the length in bytes:

int* = (int*) malloc (size * sizeof (int));

In other words, we could have simply saved that value in advance:

void f (const int size) {

const int length = size * sizeof (int);

int* a = (int*) malloc (length);

// use array...

free (a);

}

The function f now knows everything it needs to know about array a; its type, size and length. However, the length really isn't that useful because any function that needs to know the length can easily calculate it from the size and type alone, which is also the minimum information required whenever we pass any array into a function.

Statically allocated arrays and local fixed-size arrays work slightly differently in that when we use the sizeof operator upon them we actually get the number of elements. However, given that we already know the number of elements at design time, we are not determining anything that we didn't already know. Consider the following:

int a[100]; // global array (statically allocated)

void main (void) {

const int a_size = sizeof (a);

assert (a_size==100); // ok

int b[1000]; local array (allocated on the stack)

const int b_size = sizeof (b);

assert (b_size==1000); // ok

}

The values 100 and 1000 are literal constants. Being constants we do not need to determine their value, they are already known in advance, at design time. This means we may as well store those values as named constants so we can more easily refer to them by a symbolic name which, in turn, makes it easier for us to assign different values to those constants rather then searching for each occurrence of a "magic number".

const int a_size = 100; // global constant

int a[a_size]; // global array (statically allocated)

void main (void) {

const int b_size = 1000; // local constant

int b[b_size]; local array (allocated on the stack)

}

Note that all constants (including literal constants) are statically allocated regardless of their scope. However, we cannot take the address of a literal constant unless we assign it to a named constant. When we do this, the literal constant is replaced with the named constant so it costs nothing to symbolise literal constants. It only costs memory when we have two or more named constants with the same literal value, but if they serve different purposes it is better to give them separate names.