what does sizeof() check as sentinel value for int array[] in c

Question

Let us consider int array[] = {2,33,4,56,7,8}; //case A

if sizeof() checked '\0' as end of char[] array! what does sizeof(array) check as a sentinel value to find end of int array, therefore size of array in case A?

If I were to implement sizeof (intArray) , there is no liberty to access of sentinel value information ?

Answer 1

sizeof does not check anything. It only looks like a function call, but it is really an operator, a compiler trick to insert the size as known to the compiler at compile time.

Here is how sizeof interacts with C arrays: when you declare an array, you specify its size as a constant, as a run-time integer expression, or implicitly by supplying a certain number of values to put into your array.

When the number of elements is known at compile time, the compiler replaces sizeof(array) with the actual number. When the number of elements does not become known until runtime, the compiler prepares a special implementation-specific storage location, and stores the size there. The running program will need this information for stack clean-up. The compiler also makes this hidden information known to the runtime portion of sizeof implementation to return a correct value.

Answer 2

I think you're confusing string literals having a '\0' (null-terminator) in the end with arrays in general. Arrays have compile-time length known to the compiler ¹. sizeof is an operator which gives the size based on the array length and the base type of the array.

So when someone does int a[] = {1, 2, 3}; there's no null-terminating character added in the end and number of elements is deduced as 3 by the compiler. On a platform where sizeof(int) = 4, you'll get sizeof(a) as 12.

The confusion is because for char b[] = "abc";, the element count would be 4 since all string literals have a '\0' automatically put up I.e. They are null-terminated automatically. It is not the sizeof operator which does a check for this; it simply gives 4 * sizeof(char) since for sizeof all that matters is the compile-time array length which is 4 = 1 + the number of characters explicitly stated in the string literal due to the nature of string literals in C.

However a character array not initialised by a string literal but with character literals doesn't have this quirk. Thus if char c[] = {'a', 'b', 'c'};, sizeof(c) would return 3 and NOT 4 as it is not a string literal and there's no null-terminating character. Again sizeof operator (not function) does this deduction at compile-time ².

Finally, how the sizeof operator itself is implemented to do this, is an implementation detail not mandated by the standard. A standard talks about conditions and results. How they're achieved by implementations isn't a concern of the standard (or to anyone except the developers who implement it).

---

¹ _{C99 introduced Variable Length Arrays (VLA) which allows arrays to have dynamic size.}

² _{Only for VLAs the sizeof operator and its operand are evaluated at run-time}

Answer 3

sizeof is not a function, but a compile-time operator, that is replaced with the size of the variable. In case of true arrays (not pointers) it is replaced with the size in bytes of the content of the array, because it's knows at compile time;

Try the following to convince yourself:

void print_size(int[] array)
{
  printf("%u\n", sizeof(array)); //Prints 4 (= sizeof(int*))
                                 //May print 8 on 64b architectures
}

int main()
{
  int array[] = {2,33,4,56,7,8};
  printf("%u\n", sizeof(array)); //Prints 24 (= 6*sizeof(int))
  print_size(array);
  return 0;
}

This is because, inside of main, the compiler knows that array is an array of 6 ints, while the function print_size may be called with any array, and so its size is not known in advance: it is treated just like a int* (except that I'm not sure if it's a lvalue)