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

On 15/08/2024 09:43, Tim Rentsch wrote:
 > Bart <bc@freeuk.com> writes:
 >
 > [on comparing array arguments in C with call-by-reference]
 >
 >> [...] the differences [between C rules and true call-by-reference]
 >> can be summarised here;  [...]
 >>
 >>                                   Call     Array access in callee
 >>
 >>      C call-by-value              F(A)     A[i]
 >>
 >>      true call-by-reference       H(A)     A[i]
 >>
 >> What the user has to write is what's important, and here it is clear
 >> that they write the same thing [in the two cases shown].
 >
 >
 > The comparison above is misleading because it is incomplete.
 > Let's compare the two modes more fully:
 >
 >
 >                          C call-by-value         call-by-reference
 >                          ===============         =================
 >    at call:
 >
 >      (array argument)    F(A)                    H(A)
 >
 >      (pointer argument)  F(p)                    (disallowed)
My posts were about passing *arrays* and the fact that C's pass-by-value was remarkably similar to pass-by-reference.
However your entry for pointers is not correct: you can pass pointers by reference (in C, it means passing a T** type instead of T* to emulate that).
 >
 >      (null argument)     F(0)                    (disallowed)
Pass-by-reference necessarily requires an lvalue at the call-site since it effectively applies & to the argument.
 >
 >    inside function:
 >
 >      (access)            A[i]                    A[i]
 >
 >      (update)            A[i] = ...              A[i] = ...
 >
 >      sizeof A            (pointer size)          (array size)
That's one of the small differences. But you only get the array size in a language where the array type includes its length. Otherwise, you only get it if it's part of the parameter type.
 >      A++                 (changes A variable)    (disallowed)
(In my language ++A is allowed. I'm not sure why, it's likely a bug.)
 >      A = (new value)     (changes A variable)    (disallowed)
This is allowed too in my language, if the array has a fixed size. It reassigns the whole array.
In C you can't do A = B for other reasons, since arrays aren't manipulated by value. But you can do this:
     memcpy(A, B, n);
and it will overwrite caller's array with B. That other language can also choose to call memcpy().
 > The more complete comparion illustrate why C semantics should not
 > be thought of as call-by-reference.
It was made clear more than once that it wasn't exact call-by-reference.
It was also made clear that there were enough similarities that adding real call-by-reference arrays to C would buy you very little.