const

[shaanxxx]

#include<stdio.h>

void f(const int& a)
{
int * i = (int *)&a ;
printf("i=%d , a = %d \n", *i , a);
*i =2 ;
printf("i=%d , a = %d \n", *i , a);

}
int main()
{
f(int()); // ?
f(1); // ?
return 1;
}
I am not getting how above code works .

[Kai-Uwe Bux]

shaanxxx wrote:

#include<stdio.h>

void f(const int& a)
{
int * i = (int *)&a ;
printf("i=%d , a = %d \n", *i , a);
*i =2 ;
printf("i=%d , a = %d \n", *i , a);

}
int main()
{
f(int()); // ?
f(1); // ?
return 1;
}
I am not getting how above code works .

There is no 'how' in this: the code does not 'work'. Instead, the code has
undefined behavior: it tries to modify the constant 1. That does not fly
according to [7.1.5.1/4]:

Except that any class member declared mutable (7.1.1) can be modified, any
attempt to modify a const object during its lifetime (3.8) results in
undefined behavior.
Best

Kai-Uwe Bux

[S S]

shaanxxx wrote:

#include<stdio.h>

void f(const int& a)
{
int * i = (int *)&a ;
printf("i=%d , a = %d \n", *i , a);
*i =2 ;
printf("i=%d , a = %d \n", *i , a);

}
int main()
{
f(int()); // ?
f(1); // ?
return 1;
}
I am not getting how above code works .

What you want that should not work according to you?

[David Harmon]

On 5 Oct 2006 23:10:24 -0700 in comp.lang.c++, "shaanxxx"
<sh******@yahoo.comwrote,

>#include<stdio.h>

void f(const int& a)
{
int * i = (int *)&a ;
printf("i=%d , a = %d \n", *i , a);
*i =2 ;
printf("i=%d , a = %d \n", *i , a);

}
int main()
{
f(int()); // ?
f(1); // ?
return 1;
}
I am not getting how above code works .

It doesn't work. Without any doubt, it was written for no other
purpose than to be an example of code that doesn't work.

[Mehturt]

shaanxxx wrote:

#include<stdio.h>

void f(const int& a)
{
int * i = (int *)&a ;
printf("i=%d , a = %d \n", *i , a);
*i =2 ;
printf("i=%d , a = %d \n", *i , a);

}
int main()
{
f(int()); // ?

This is ok.

f(1); // ?

This is undefined behavior.

return 1;
}
I am not getting how above code works .

[shaanxxx]

Kai-Uwe Bux wrote:

shaanxxx wrote:

#include<stdio.h>

void f(const int& a)
{
int * i = (int *)&a ;
printf("i=%d , a = %d \n", *i , a);
*i =2 ;
printf("i=%d , a = %d \n", *i , a);

}
int main()
{
f(int()); // ?
f(1); // ?
return 1;
}
I am not getting how above code works .

There is no 'how' in this: the code does not 'work'. Instead, the code has
undefined behavior: it tries to modify the constant 1. That does not fly
according to [7.1.5.1/4]:

Except that any class member declared mutable (7.1.1) can be modified, any
attempt to modify a const object during its lifetime (3.8) results in
undefined behavior.
Best

Kai-Uwe Bux

g++ -Wall -pedantic conref.c
(no warning)

out put :

i=0 , a = 0
i=2 , a = 2
i=1 , a = 1
i=2 , a = 2

[shaanxxx]

Kai-Uwe Bux wrote:

shaanxxx wrote:

#include<stdio.h>

void f(const int& a)
{
int * i = (int *)&a ;
printf("i=%d , a = %d \n", *i , a);
*i =2 ;
printf("i=%d , a = %d \n", *i , a);

}
int main()
{
f(int()); // ?
f(1); // ?
return 1;
}
I am not getting how above code works .

There is no 'how' in this: the code does not 'work'. Instead, the code has
undefined behavior: it tries to modify the constant 1. That does not fly
according to [7.1.5.1/4]:

Except that any class member declared mutable (7.1.1) can be modified, any
attempt to modify a const object during its lifetime (3.8) results in
undefined behavior.
Best

Kai-Uwe Bux

g++ -Wall -pedantic conref.c
(no warning)

out put :

i=0 , a = 0
i=2 , a = 2
i=1 , a = 1
i=2 , a = 2

[Stuart Golodetz]

"shaanxxx" <sh******@yahoo.comwrote in message
news:11**********************@m73g2000cwd.googlegr oups.com...

>
Kai-Uwe Bux wrote:

>shaanxxx wrote:

#include<stdio.h>

void f(const int& a)
{
int * i = (int *)&a ;
printf("i=%d , a = %d \n", *i , a);
*i =2 ;
printf("i=%d , a = %d \n", *i , a);

}
int main()
{
f(int()); // ?
f(1); // ?
return 1;
}
I am not getting how above code works .

There is no 'how' in this: the code does not 'work'. Instead, the code
has
undefined behavior: it tries to modify the constant 1. That does not fly
according to [7.1.5.1/4]:

Except that any class member declared mutable (7.1.1) can be modified,
any
attempt to modify a const object during its lifetime (3.8) results in
undefined behavior.
Best

Kai-Uwe Bux

g++ -Wall -pedantic conref.c
(no warning)

out put :

i=0 , a = 0
i=2 , a = 2
i=1 , a = 1
i=2 , a = 2

It doesn't matter what it happens to do on any particular compiler. If the
behaviour's undefined, it means it can do what it likes, including the
above.

Regards,
Stu

[Jacek Dziedzic]

shaanxxx wrote:

Kai-Uwe Bux wrote:

>>shaanxxx wrote:

>>>#include<stdio.h>

void f(const int& a)
{
int * i = (int *)&a ;
printf("i=%d , a = %d \n", *i , a);
*i =2 ;
printf("i=%d , a = %d \n", *i , a);

}
int main()
{
f(int()); // ?
f(1); // ?
return 1;
}
I am not getting how above code works .

There is no 'how' in this: the code does not 'work'. Instead, the code has
undefined behavior: it tries to modify the constant 1. That does not fly
according to [7.1.5.1/4]:

Except that any class member declared mutable (7.1.1) can be modified, any
attempt to modify a const object during its lifetime (3.8) results in
undefined behavior.
Best

Kai-Uwe Bux

g++ -Wall -pedantic conref.c
(no warning)

out put :

i=0 , a = 0
i=2 , a = 2
i=1 , a = 1
i=2 , a = 2

So?

- J.

PS. Out of sarcasm mode, Undefined behaviour may easily
disguise in the form of "appearing to work".

[Default User]

shaanxxx wrote:

>
Kai-Uwe Bux wrote:

There is no 'how' in this: the code does not 'work'. Instead, the
code has undefined behavior: it tries to modify the constant 1.
That does not fly according to [7.1.5.1/4]:

g++ -Wall -pedantic conref.c
(no warning)

It sounds a tautology, but there is no defined behavior for undefined
behavior.

Say that over and over to yourself. That means:

1. There are no required compiler diagnostics.

2. There is no particular thing the problem SHOULD do or SHOULD NOT do.
The behavior of the program is undefined. That means what it does is
NOT DEFINED. The behavior, it has no definition. Definition for the
behavior does not exist.

Brian

[Kai-Uwe Bux]

shaanxxx wrote:

>
Kai-Uwe Bux wrote:

>shaanxxx wrote:

#include<stdio.h>

void f(const int& a)
{
int * i = (int *)&a ;
printf("i=%d , a = %d \n", *i , a);
*i =2 ;
printf("i=%d , a = %d \n", *i , a);

}
int main()
{
f(int()); // ?
f(1); // ?
return 1;
}
I am not getting how above code works .

There is no 'how' in this: the code does not 'work'. Instead, the code
has undefined behavior: it tries to modify the constant 1. That does not
fly according to [7.1.5.1/4]:

Except that any class member declared mutable (7.1.1) can be modified,
any attempt to modify a const object during its lifetime (3.8) results
in undefined behavior.
Best

Kai-Uwe Bux

g++ -Wall -pedantic conref.c
(no warning)

No surprise here: the standard does not require any diagnostics for this
kind of programming error. That is why it says undefined behavior instead
of putting down a diagnosable rule whose violation would need to be
indicated by a conforming implementation.

out put :

i=0 , a = 0
i=2 , a = 2
i=1 , a = 1
i=2 , a = 2

No surprise here either: undefined behavior is exactly that -- undefined.
Anything can happen. In particular, things you would expect might happen
(which is in some sense the most hideous incarnation of undefined behavior
since you won't notice until you change/upgrade compilers and all of a
sudden code you thought was rock solid breaks in unpredictable ways).
Hope this helps

Kai-Uwe Bux