From:  Keith Thompson <Keith.S.Thompson+u@gmail.com>
Date:  29 Sep 2024 06:17:10 Hong Kong Time
Newsgroup:  news.alt119.net/comp.lang.c
Subject:  

Re: relearning C: why does an in-place change to a char* segfault?

NNTP-Posting-Host:  null

Phillip Frabott  writes:
> In reply to "Keith Thompson" who wrote the following:
>> Phillip Frabott  writes:
>> > In reply to "Janis Papanagnou" who wrote the following:
>> [...]
>> > > I also think (for various reasons) that "constants" is not a good
>> > > term. (Personally I like terms like the Algol 68 term, that seems
>> > > to "operate" on another [more conceptual] abstraction level.)
>> > > 
>> > > But you'll certainly have to expect a lot of anger if the terminology
>> > > of some standards documents get changed from one version to another.
>> > 
>> > The only gripe I would have if we synonymized constants and literals
>> > is that not every const is initialized with a literal. There have been
>> > times where I have initialized a const from the value of a variable. I
>> > don't think that const and literals are the same thing because of
>> > this.
>> 
>> Though the word "const" is obviously derived from the English word
>> "constant", in C "const" and "constant" are very different things.
>> 
>> The "const" keyword really means "read-only" (and perhaps would have
>> been clearer if it had been spelled "readonly").
>
> In the context of C I agree. Although I would point out that for some langauges 
> const and readonly are two completely different things. (just a brevity remark, 
> but I'll get back on topic now)
>
>> A "constant" is what some languages call a "literal", and a "constant
>> expression" is an expression that can be evaluated at compile time.
>> 
>> For example, this:
>> 
>>     const int r = rand();
>> 
>> is perfectly valid.
>
> Maybe the expression can be determined/evaluated at compile time but not the 
> result. When I think of literals the resulting value has to be determined at 
> compile time. So const int r = 15; would be to me a literal result. The compiler 
> can bake that in without needing further runtime execution to get such result. 
> But a const can be either a literal or non-literal in my view. Anything that 
> cannot give a predetermined value at compile time is a const. So to me:
>
> const int r = rand();
>
> is not a literal only because the output of rand() is unknown until
> runtime.

Of course that's not a literal, nor is it constant.  The object r is
*const* (its value cannot be changed after its initialization), not
*constant*.

> From a human-readable code perspective I get it. And fine, there can be a 
> similarity between const and literal on the surface. But the moment you need to 
> know exactly what the compiler is doing, those two things have to be separate.

Certainly "const" and "literal" are separate.  They mean almost
completely different things.

I can't help wondering if you missed the point.

A literal, as the term is commonly used, is a single token that
represents a constant (compile-time) value of some type.  Examples are
42 and "foo".  (C compound literals are more complicated.)

C uses the term "constant" (as a noun) for tokens of numeric types, like
42 and 1.5, that represent compile-time values.  C2Y will likely refer
to these as "literals".  See
    https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3239.htm
which is the proposal to use the word "literal", and
    https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3301.pdf
particularly section 6.4.5, which is a C2Y draft that incorporates the
proposal (when open-std.org is up and running again).

The word "constant" is also used as an adjective in the phrase "constant
expression".  A constant expression,  like (2+2), is one that's required
to be evaluated at compile time in certain contexts, so it can't refer
to the value of a variable.

The keyword "const" is almost unrelated to either "const" or "literal".
It means that an object cannot legally be modified after it's been
initialized.

The planned change for C2Y is to use the word "literal" rather than
"constant".  There's no change to the phrase "constant expression".

[...]

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