Re: technology discussion → does the world need a "new" C ?

On 11/07/2024 12:04, bart wrote:

On 11/07/2024 09:54, Michael S wrote:

No, it isn't.
If [in C] it was possible to pass arrays to functions, either by value
or by reference, then callee would know the length of passed array. As
it is, callee does not know it.

 

The length can be passed in a separate parameter, but then it does not
have to be the same as an original.

 That's rather specious. In my language (probably in C too), most passed arrays are unbounded, allowing the same function to work with arrays of different sizes.
 So that would need a separate Length parameter, even using by-reference.

No.
Like any object, an array has data, and characteristics including the type of the elements, and for an array, the length of the array.  If you pass an object, by reference or by value, the receiver (function parameter, or caller if we are talking about return values) gets the characteristics as well as the data.
In C, if you write code that looks a bit like it is passing an array, the object's characteristics don't follow along with it - therefore you are not passing the array.  If in your language, the characteristics also do not follow, as part of the parameter, then your language cannot pass arrays either.
If you need to have a separate manual length parameter, then your language is doing the same as C - you are passing a pointer by value without the full object information.
So perhaps your confusion here lies in a misunderstanding of how arrays as passed in your own language, and you have carried that confusion over to C.

 In that regard, it's no different from the C: my array by-ref and C's alledged by-ref both cannot determine the array length solely from the parameter.
 (In my language, attempts to get the length yields 0, which makes sense as the parameter's bounds are zero. In C, it will yield the size of the pointer.)
 But when the array IS bounded, then in C:
    typedef byte vector[4];
    void F(vector a) {
       printf("%zu\n", sizeof(a));
       printf("%zu\n", sizeof(vector));
   }
 The first printf shows 8 (the pointer size); the second shows 4 (the array size). So it /can/ access the bounds.

No, it cannot access the bounds of the "array parameter" here.  (I use quotation marks because there are no array parameters in C - just things that look a little like them.)
F takes a pointer to byte as a parameter, not a "vector" or an array of bytes or a pointer to an array.  The function has no more access to the size of a "vector" than it has access to the size of a "float".

 (For unbounded arrays, my language offers an alternative: slices, which contain their length. This is available whatever the calling mechanism.)
 

A slice is presumably an object that encapsulates a pointer to data and size information - a struct.  It might give a nice syntax in your language, but it is a different concept entirely.