How does the computer(C compiler, or something else) handle "automatic array declaration"? | C language

Question

I am attempting to return a dynamically declared array from a function; thus far I am returning a structure to hold a pointer to the memory block that malloc() assigned for the array AND an integer to store the length of the array.

---

This made me wonder; How does the C Compiler(or whatever) handle an automatic array declared in a program? eg.

main()
{
    //delcare an array holding 3 elements
    int array[] = {1,2,3};


    /*variable to hold length of array
     *size of array / size of 1st element in the array == length of the array
     *this will == 3
     */ 
    int array_Length = (sizeof(array))/(sizeof(*array));


    //call malloc for a block of memory to hold 3 integers(worth of memory)
    int* ptr = malloc(3*(sizeof(int)));


    /*not exactly sure what this formula means when using a pointer???
     *but it seems to always == 1
     */
    int dynamic_array_length = (sizeof(ptr))/(sizeof(*ptr));

    return 0;
}

My point is, the sizeof() operator somehow knows that the automatically declared array has 3 integers within it.

Or more generally:

sizeof(array)

where array is (N x type_size)

N is the number of elements within the array

type_size is the number of bytes of memory used to store the data type

---

Are automatic arrays stored with additional information about their size/length?

Are dynamic arrays stored differently? (I know that we control when a dynamic variable is freed from memory)

Answer 1

Operator sizeof is a compile-time construct (with the exception of VLA arguments). It tells you the object size in bytes because it knows the exact compile-time object type. And when you know the exact type the size is also immediately known. There's no need to separately store the number of elements anywhere.

Your declaration

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

is equivalent to

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

meaning that array has type int[3]. So your sizeof(array) is interpreted as sizeof(int[3]), which is immediately known to the compiler.

sizeof does not know and does not care about any "dynamic arrays" of yours. All it cares about is that in sizeof(ptr) operator sizeof is applied to a pointer. So it evaluates to pointer size.

Answer 2

sizeof(...) is not a function call. It doesn't actually execute at runtime - that value is replaced at the compile time, so what's actually compiled is:

int array_length = 3;

The calculation of dynamic_array_length is incorrect. You divide the size of a pointer by the size of int. Which in your case happens to be the same and get 1 as a result.

Your dynamic array is stored differently - the pointer (on the stack) is separate from the data (on the heap). The first array is just data on the stack - the memory address is constant (for that stack frame) and gets used where needed.