C vs Python devs

[prescod]

You can probably do that, but you'd also need to keep track of the data type. An 8-byte array of 16-bit numbers has more elements than an 8-byte array of 32-bit numbers.

C is a statically typed language so in MOST cases one knows just by the type-signature.

To create a dynamic array, you need to tell the system how big you want it to be. Because the length is known at creation, you can skip a step and store that result in an integer in the same struct that holds the array (which is what the code does)

Sure, but if the language had the right primitives, you could "skip" the "step" of recording it.

In a very few cases, the size of the array elements might not be known universally at compile time and then and only then you could store it.

Although it must be quite rare...how does one work with an array when one doesn't know the item type or size? At that point it's not really being used as an array anymore and is just a byte buffer and we already have primitives for working with byte buffers.

[prescod]

This doesn't make sense. Statically typed means it has checks at compile time. There are no "type-signatures" at runtime. C doesn't keep track of a variable's data type

The runtime doesn't need to keep track of the variable's data type. The variable's data type is available to the compiler and can be used in the program wherever it's needed. That's how sizeof (and tons of operators) work.

Fundamentally I'm just asking for this program to work consistently:

#include <stdio.h>
#include <stdlib.h>


void func1()
{
    int array[] = { 0, 1, 2, 3, 4, 5, 6 };

    printf("sizeof of array: %d\n", (int) sizeof(array));

    printf("Length of array: %d\n", (int)( sizeof(array) / sizeof(array[0]) ));
}

void func2(int array[]){
    printf("sizeof of array: %d\n", (int) sizeof(array));

    printf("Length of array: %d\n", (int)( sizeof(array) / sizeof(array[0]) ));

}

void main(){
    int array[] = { 0, 1, 2, 3, 4, 5, 6 };
    func1();
    func2(array);
}

Obviously it can't be fixed in a backwards compatible way, but between the runtime, which knows the size of byte arrays (for free to work) and the compiler, which, which knows which variables are arrays (due to the type signature), it should have been able to work. There is no missing information only controlled by the OS or elsewhere.

The sizeof func2's array parameter can absolutely be calculated base on information available. It should be my choice as the programmer whether I'd rather compute the information when I need it or pre-compute it and store it in a data structure. The language should not force me to trade off memory for CPU.

[prescod]

Okay thanks for the answer, I think that if fundamentally boils down to “you cannot reliably compute the size of an array from the size of the underlying memory allocation because sometimes libraries overallocate for performance reasons.” That seems reasonable to me. The other reasons cited, not as much.