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

In reply to "Keith Thompson" who wrote the following:

Phillip Frabott <nntp@fulltermprivacy.com> 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.
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.

Perhaps there is a better way to do it. Or maybe there can be a literal type
that is basically equal to const type for the purpose of coding or even perhaps
a [--treat-const-as-literal] compiler parameter for code where a literal value
and a const value should be treated the same. But I still think these two should
be treated differently.

I should note I don't have the original posting for this thread (I guess my
provider doesn't have it) so I don't have the original URI that started this
thread. If someone can share it in a reply I'd really appreciate it so I can be
sure I'm on the same page with what is being discussed.
Phillip Frabott
{Adam: Is a void really a void if it returns? - Jack: No, it's just nullspace at
that point.}


--
----------------------------------------- --- -- -
Posted with NewsLeecher v7.0 Final
Free Newsreader @ http://www.newsleecher.com/
------------------------------- ----- ---- -- -