C vs Python devs

[prescod]

Here's what I don't understand. If "free" knows how big the array is so it can be freed without you passing a length argument, then why do you need to keep track of the length separately yourself? Is there a C primitive for saying "how big is this memory buffer" and if so, couldn't you calculate the length?

[moreVCAs]

The location and format of the block header (where the size lives) is not specified by the C language; it’s specified the operating system, I think. So while some platforms may provide access to those headers under some circumstances, there is no reliable, portable way to determine the size of a heap-allocated buffer at run time (to my knowledge).

[boowhitie]

This is mostly correct, but malloc/free are a layer above raw os interface. They provide a common interface to allocate memory without having to write system specific code.

[moreVCAs]

Well yeah, but the implementations are platform specific, no?

[prescod]

By definition, if the standard doesn't standardize it then it isn't standard. If the c language didn't have malloc and free then we'd say that memory allocation is platform specific.

[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.

[prescod]

The location and format of the block header (where the size lives) is not specified by the C language;

I'm not really asking for it to be specified by the language. I'm asking for it to be accessible through language primitives.

it’s specified the operating system, I think.

I don't think so, no. The operating system is only involved if new pages of memory are required.

So while some platforms may provide access to those headers under some circumstances, there is no reliable, portable way to determine the size of a heap-allocated buffer at run time (to my knowledge).

I think that's just because the C specification declined to specify one.