the size of dynamically allocated array in C

Question

I know that this question has been asked before, but my question is more specific, here is the code:

#include <stdio.h>
#include <time.h>    /* must be included for the time function */

main()
{
    time_t t = time(NULL);
    srand((unsigned) t);

    int i = rand();

    int a[i];

    printf("%d\n", i);        /* ouptut: 18659 */
    printf("%d\n", sizeof a); /* output: 74636 */
}

I compiled this code using gcc and -ansi option to restrict it to recognize the ANSI C only. I know that there is no way that the compiler could know at compile-time the size of the array because it's determined randomly at run-time. Now my question is is the value returned by sizeof is just a random value, or it has a meaning?

This is not valid C89 code, due to the variable-length array. It's valid in C99+, where sizeof explicitly does runtime magic on VLAs (hint: what is 74636 / 18659 ?) — Oliver Charlesworth, May 11 '17 at 12:05
Lets do an exercise - we try to multiply 18659 with 4. What do we get? — Ajay Brahmakshatriya, May 11 '17 at 12:06
If You want ANSI C only, Use with `-pedantic` option (with `-Werror`). (Turn off GCC's extensions.) — BLUEPIXY, May 11 '17 at 12:06
from your output obviously that `sizeof a` is real size of `int a[I]` — RbMm, May 11 '17 at 12:07
BTW, to avoid UB this should be `printf("%zu\n", sizeof a);`. sizeof returns a size_t, not int. — Jens, May 11 '17 at 12:07
Says TFM "The -ansi option does not cause non-ISO programs to be rejected gratuitously. For that, -pedantic is required in addition to -ansi". — n. m. could be an AI, May 11 '17 at 12:12
@MaykelJakson But variable arrays are C99 and not C89. You can't have it both ways. And even in C89, a size_t is not an int, and as such you have UB. — Jens, May 11 '17 at 13:52
@Jens indeed, I didn't know that, because **gcc file.c -ansi** didn't complain, but I knew later that I had to add another option **-pedantic** if I _'realy'_ wanted gcc to compile c89 code only. — Maykel Jakson, May 11 '17 at 15:08

score 6 · Answer 1 · answered May 11 '17 at 12:08

The sizeof operator is evaluated at compile time for most operands. In the case of a VLA, it is evaluated at runtime.

From section 6.5.3.4 of the C standard:

2 The sizeof operator yields the size (in bytes) of its operand, which may be an expression or the parenthesized name of a type. The size is determined from the type of the operand. The result is an integer. If the type of the operand is a variable length array type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an integer constant

So the size returned by sizeof is the size in bytes of the VLA. In your example, that would be i * sizeof(int)

score 3 · Accepted Answer · answered May 11 '17 at 12:08

The value returned by sizeof is a pseudo-random value that has a meaning:

The value represents the size of VLA a, in bytes
It is random only in the sense that the number of array elements is determined by a call to rand.

It appears that sizeof(int) on your system is 4, because the number returned by sizeof is four times the number of elements in the array.

Note: One of the consequences of allowing VLAs in C99 is that sizeof is no longer a purely compile-time expression. When the argument of sizeof operator is a VLA, the result is computed at run-time.

Marievi · Answer 3 · 2017-05-11T12:26:42.700

is the value returned by sizeof is just a random value, or it has a meaning?

It does have a meaning, as 74636 / 18659 = 4, which apparently is the size of int on your machine.

So sizeof (which will be computed at run-time instead of compile-time since the argument is a VLA), will return the size of array a in bytes, which is the number of ints it contains (in other words i or 18659) multiplied by the size of int, which is 4 on your machine.

As i (the result of rand) is random, you can consider that the value of sizeof will be random too in that sense.

score 2 · Answer 4 · answered May 11 '17 at 12:12

2

From the gcc manual

The -ansi option does not cause non-ISO programs to be rejected gratuitously. For that, -Wpedantic is required in addition to -ansi.

answered May 11 '17 at 12:12

pmg

106,608
13
126
198

That is not really the answer to the question (sizeof(a) valid for VLA), is it? – Aconcagua May 11 '17 at 12:15
@Aconcagua actually it is, because it means that sizeof(a) is no more evaluated in compile time only as it is the case in C89 (not using -Wpedantic option). – Maykel Jakson May 11 '17 at 12:19
@MaykelJakson The word 'sizeof' is not even mentioned in the answer - neither any word about evaluating it at compile/run time, neither a confirmation that the struct is valid. *This* would have been what makes the right answer - given one answers the question "How to compile ANSI only with GCC?", which OP (incorrectly) assumed already being doing... – Aconcagua May 11 '17 at 15:37

the size of dynamically allocated array in C

4 Answers4