Re: question about linker

Bart <bc@freeuk.com> writes:

On 28/11/2024 19:58, Keith Thompson wrote:

Bart <bc@freeuk.com> writes:
[...]

I think 'const' is confusing for similar reasons that VLAs can be both
confusing and awkward to implement.
>
That's because both really apply to /types/, not directly to variables.

Sure.  For example, given
     const int n = 42;
n is of type `const int`, and &n is of type `consts int*`.  Of course
that implies that n itself is const.

>
But that is a separate thing. Suppose T was an alias for 'const int'. Then:
>
  T x;           // defines a readonly variable (which probably needs
                 // initialising)
  T* y;          // defines a variable pointer
>
'const' is out of the picture.

You say T is an alias (what, a macro?) for 'const int', you show code
using T, and then you say "'const' is out of the picture".  If you have
a point, it escapes me.

                               Other languages tend to have special
keywords that apply to the variable declaration, not the type, for
example:
>
  let x:int        # non-mutable
  var y:int*       # mutable (using whatever pointer syntax)

Yes, other languages are different.  Few, if any, languages that
are not based on C have adopted C's odd declaration syntax.

'const' C looks like it works like that, but it doesn't.

It doesn't look like it works like that if you understand how it
actually does work.

                                                         There also
examples like this:
>
  int const * const p;
>
Here storage for p is allocated, but it it the second 'const' that
makes it readonly. The first 'const' is not involved in allocation at
all. This is easy to get mixed up.

Yes, and you seem determines to make it easier to get mixed up.

[...]

VLAs are mostly linked to stack allocation. But that only applies when
the array is at the top level of the type spec, in the same why that
it's the top-level 'const' that would determine whether storage is
read-only - if declaring a variable.
>
As I said, other languages tend to only have that top-level aspect. I
consider that less confusing. I don't think you'd see multiple 'let'
or 'mut' keywords within one variable declaration.

Other languages confuse you less than C does.  We know.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */