const really constant?

[Mantorok Redgormor]

Is const really constant?

And on an OT note: how can I post with a modified e-mail address so I
don't get so much spam?

[Pieter Droogendijk]

On 19 Sep 2003 13:38:37 -0700
ne*****@tokyo.c om (Mantorok Redgormor) wrote:

Is const really constant?
No, const is a keyword. A variable defined to be const may not change value
after definition.
And on an OT note: how can I post with a modified e-mail address so I
don't get so much spam?

Read your newsreader's documentation and improvise.

--
char*x(c,k,s)ch ar*k,*s;{if(!k) return*s-36?x(0,0,s+1):s ;if(s)if(*s)c=1 0+(c?(x(
c,k,0),x(c,k+=* s-c,s+1),*k):(x(* s,k,s+1),0));el se c=10;printf(&x( ~0,0,k)[c-~-
c+"1"[~c<-c]],c);}main(){x(0 ,"^[kXc6]dn_eaoh$%c","-34*1'.+(,03#;+, )/'///*");}

[Alex]

Mantorok Redgormor <ne*****@tokyo. com> wrote:

Is const really constant?

Like Chris Torek always says, 'const' in C means 'read-only'. It
does not act as a constant when a constant expression is expected,
nor does it completely preclude modifications to the variable.

Consider:

const int x = 10;

int array[x]; /* ilegal, not constant expression */

and

const int x = 10;
int *p = (int *)&x;

*p = 2; /* ooops, just changed x */

Alex

[Nick Austin]

On 19 Sep 2003 21:02:05 GMT, Alex <al*******@hotm ail.com> wrote:

const int x = 10;
int *p = (int *)&x;

*p = 2; /* ooops, just changed x */

Is that not UB?

N869:
"J.2 Undefined behavior

[snip]

-- An attempt is made to modify an object defined with a
const-qualified type through use of an lvalue with non-
const-qualified type."

Nick.

[Alex]

Nick Austin <ni**********@n ildram.co.uk> wrote:

On 19 Sep 2003 21:02:05 GMT, Alex <al*******@hotm ail.com> wrote:

const int x = 10;
int *p = (int *)&x;

*p = 2; /* ooops, just changed x */

Is that not UB? N869:
"J.2 Undefined behavior [snip] -- An attempt is made to modify an object defined with a
const-qualified type through use of an lvalue with non-
const-qualified type."

Looks like you're right. Sorry.

Alex

[Ivan Vecerina]

Hi,
"Alex" <al*******@hotm ail.com> wrote in message
news:bk******** ****@ID-190529.news.uni-berlin.de...

Nick Austin <ni**********@n ildram.co.uk> wrote:

On 19 Sep 2003 21:02:05 GMT, Alex <al*******@hotm ail.com> wrote:

const int x = 10;
int *p = (int *)&x;

*p = 2; /* ooops, just changed x */

Is that not UB?

N869:
"J.2 Undefined behavior

[snip]

-- An attempt is made to modify an object defined with a
const-qualified type through use of an lvalue with non-
const-qualified type."

Looks like you're right. Sorry.

Yes, however the following is not UB and demonstrates the
same issue:

int f( int* a, int const* b )
{
*a += *b;
return *b; // must re-read *b, may have changed
}

int main()
{
int i = 10;
printf( "%d\n", f(&i,&i) );
return 0;
}

This program must print 20, and the compiler may
not optimize the two accesses to *b within f().
Const guarantees that the value cannot be modified
through the variable/pointer itself. But the
compiler cannot assume that the value will remain
unchanged.

This is why a variable can be both const and volatile.

This is also related to why 'restrict' was introduced
in the C99 standard ...
Kind regards,
Ivan
--
http://ivan.vecerina.com

[Peter Nilsson]

"Nick Austin" <ni**********@n ildram.co.uk> wrote in message
news:51******** *************** *********@4ax.c om...

On 19 Sep 2003 21:02:05 GMT, Alex <al*******@hotm ail.com> wrote:

const int x = 10;
int *p = (int *)&x;

*p = 2; /* ooops, just changed x */

Is that not UB?

N869:
"J.2 Undefined behavior

[snip]

-- An attempt is made to modify an object defined with a
const-qualified type through use of an lvalue with non-
const-qualified type."

The normative reference is 6.7.3p5

"If an attempt is made to modify an object defined with a const-qualified
type
through use of an lvalue with non-const-qualified type, the behavior is
undefined. ..."

--
Peter

[John L]

Alex wrote

Mantorok Redgormor <ne*****@tokyo. com> wrote:

Is const really constant?

Consider:

const int x = 10;

int array[x]; /* ilegal, not constant expression */

and

const int x = 10;
int *p = (int *)&x;

Sorry to digress, but is the cast above necessary? Isn't

int *p = &x;

correct?

Thanks!

[Michael Winter]

> > const int x = 10;

int *p = (int *)&x;

Sorry to digress, but is the cast above necessary? Isn't

int *p = &x;

correct?

I believe the reason is that &x will return a pointer that is of type "const
int *". As p doesn't have a const modifier, the assignment will be illegal.
The cast attempts to remove that modifier before assignment. As mentioned
by others, this is undefined in C, but quite legal as I understand (at least
with Microsoft's implementation) in C++.

Mike

--
Michael Winter
M.Winter@[no-spam]blueyonder.co.u k (remove [no-spam] to reply)

[Arthur J. O'Dwyer]

On Sat, 20 Sep 2003, Michael Winter wrote:

const int x = 10;
int *p = (int *)&x;
Sorry to digress, but is the cast above necessary? Isn't
int *p = &x;
correct?

I believe the reason is that &x will return a pointer that is of type "const
int *". As p doesn't have a const modifier, the assignment will be illegal.

That's correct. The address of an 'int' is a pointer to 'int'; the
address of a 'const int' is a pointer to 'const int'.
The cast attempts to remove that modifier before assignment. As mentioned
by others, this is undefined in C,
Not quite. The initialization

const int x = 42;
int *p = (int *)&x;

is absolutely legal in C. What's *not* legal is following that
up with

(*p) = 43;

because that tries to modify a const-qualified value. And
since it would be burdensome to make the compiler catch all
such errors, the standard simply calls the result of the
modification "undefined behavior" and leaves it at that.
but quite legal as I understand (at least
with Microsoft's implementation) in C++.

I seriously doubt this. My impression is that C++ is *more*
strict about type-safety than C, not less.

-Arthur