Re: Recursion, Yo

On 15/04/2024 20:00, Keith Thompson wrote:

Ben Bacarisse <ben.usenet@bsb.me.uk> writes:

Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:

Janis Papanagnou <janis_papanagnou+ng@hotmail.com> writes:

On 14.04.2024 02:29, Michael S wrote:

<Algol 68 code elided>

It looks closer to C than to Pascal, i.e. pointer can point to any
object rather than just to dynamically allocated object.

>
The major difference is that they are closely bound to the type.
In that respect they are more like Pascal pointers. C pointers
open the can of issues with arithmetic on pointer values. You
don't find that in Pascal or Algol 68.

[...]
>
How are C pointers not "closely bound to the type"?

>
   int i = 42;
   memcpy(&i, &(float){3.14}, sizeof i);
   printf("%d\n", i);
>
That looks like a pretty loose association between pointer and object
type to me.  This is not an accident or an unintended loophole.  It's by
design.
>
Certainly every pointer value in C has an associated type, but the
intention is that this association can be changed by pointer type
conversion as needed.
>
You often /have/ to make us of this.  For example, when calling qsort,
you will usually change the association between the pointer and the
pointed-to type (void) in order to do the comparison.  And C does not
even insist that you change it back to the original pointed-to type as
you can legally write a comparison function for, say, float data that
uses the representation as "raw" bytes.

 OK.  The way I'd describe it is that C (non-void) pointers *are*
"closely bound to the type", but in addition C provides operations,
particularly pointer casts and implicit conversions to and from void*,
that can override that binding.
 Janis mentioned pointer arithmetic.  I wouldn't say that overrides the
type binding; it merely provides a set of operations, that some other
languages lack, for constructing a pointer value from another pointer
value.  I don't know whether Janis meant that to be an example of not
being closely bound to the type, or as a distinct statement.

Implicit in every C non-void object pointer, is that it points to an element of an array, so that you access neighbouring elements via P+1, P-2, ++P and so on.
That is the case whether or not P actually points within such a sequence.
That assumption appears to be missing from those other languages.
C itself doesn't seem that bothered; it just treats any isolated object that a pointer refers to, as though it was part of an imaginary 1-element array.
Then any attempt to refer beyond it via pointer arithmetic, is a mere bounds error. But it's a bit more serious than that. It's like treating *NULL as a bounds error, because it might be a few MB away from the nearest valid object.
(My own lower level language allows similar pointer arithmetic. But it doesn't allow P[i] syntax; pointers and arrays are more distinct and therefore safer.
With an older dynamic language, pointers had a length attribute attached. So that (IIRC) single targets had a length of 1 so pointer arithmetic was limited.)