does this have undefined behaviour

[subramanian100in]

Consider the following code:

#include <iostream>
#include <cstdlib>

using namespace std;

int main()
{
const double& ref = 100;
double& d = const_cast<doub le&>(ref);
cout << d << endl;
d = 1.1;
cout << ref << endl;

return EXIT_SUCCESS;
}

In both g++ and VC++ 2005 Express Edition, the output is
100
1.1

But my doubt is: "does using 'd' invoke undefined behavior or is it
valid."

double& d = const_cast<doub le&>(ref);

Kindly clarify.

Thanks
V.Subramanian

[Victor Bazarov]

su************* *@yahoo.com wrote:

Consider the following code:

#include <iostream>
#include <cstdlib>

using namespace std;

int main()
{
const double& ref = 100;
double& d = const_cast<doub le&>(ref);
cout << d << endl;
d = 1.1;
cout << ref << endl;

return EXIT_SUCCESS;
}

In both g++ and VC++ 2005 Express Edition, the output is
100
1.1

But my doubt is: "does using 'd' invoke undefined behavior or is it
valid."

double& d = const_cast<doub le&>(ref);

What you're doing here is changing the value of the temporary
bound to a const reference. Such temporary is not const, so,
changing its value by casting away const-ness should be OK.
I can't find any place in the Standard that would prohibit
such functionality. Then my guess is that it's allowed.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[werasm]

On Dec 21, 5:04 am, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

subramanian10.. [e-mail] wrote:

Consider the following code:

#include <iostream>
#include <cstdlib>

using namespace std;

int main()
{
const double& ref = 100;
double& d = const_cast<doub le&>(ref);
cout << d << endl;
d = 1.1;
cout << ref << endl;

return EXIT_SUCCESS;
}

In both g++ and VC++ 2005 Express Edition, the output is
100
1.1

But my doubt is: "does using 'd' invoke undefined behavior or is it
valid."

double& d = const_cast<doub le&>(ref);

What you're doing here is changing the value of the temporary
bound to a const reference. Such temporary is not const, so,
changing its value by casting away const-ness should be OK.
I can't find any place in the Standard that would prohibit
such functionality. Then my guess is that it's allowed.

I think the OP might have thought that he actually changed the value
of "ref" (the constant one). I don't think he realized that a
temporary was created - therefore changing the value of "d" does
not change the value of "ref".

Regards,

Werner

[Victor Bazarov]

werasm wrote:

On Dec 21, 5:04 am, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

>subramanian10. [e-mail] wrote:

>>Consider the following code:

>>#include <iostream>
#include <cstdlib>

>>using namespace std;

>>int main()
{
const double& ref = 100;
double& d = const_cast<doub le&>(ref);
cout << d << endl;
d = 1.1;
cout << ref << endl;

>>return EXIT_SUCCESS;
}

>>In both g++ and VC++ 2005 Express Edition, the output is
100
1.1

>>But my doubt is: "does using 'd' invoke undefined behavior or is it
valid."

>>double& d = const_cast<doub le&>(ref);

What you're doing here is changing the value of the temporary
bound to a const reference. Such temporary is not const, so,
changing its value by casting away const-ness should be OK.
I can't find any place in the Standard that would prohibit
such functionality. Then my guess is that it's allowed.

I think the OP might have thought that he actually changed the value
of "ref" (the constant one). I don't think he realized that a
temporary was created - therefore changing the value of "d" does
not change the value of "ref".

No, that's incorrect, IMO. First off, you can't change the value
of ref because it's a reference, it doesn't really have a value
(aside from the fact that it refers to some particular object).
The temporary created is of type 'double', it has initial value
of 100.00 and it starts its lifetime just before 'ref' is bound
to it. The integral expression '100' is the initialiser for that
temporary.

The temporary to which 'ref' is bound is not a const object. It
is perfectly OK to change its value. Whether it makes sense to
do so or not is another question, but the idea is the same as in

void foo(int const& rci)
{
int& ri = const_cast<int& >(rci);
ri = 666; /// Is this OK? -- I say, yes, it is!
}

#include <iostream>
#include <ostream>
int main() {
int a = 42;
std::cout << "Before a = " << a << std::endl;
foo(a);
std::cout << "After a = " << a << std::endl;
}

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Andre Kostur]

"su************ **@yahoo.com, India" <su************ **@yahoo.comwro te
in news:404f0505-3d9f-4173-8361-a0a328537882
@i29g2000prf.go oglegroups.com:

Consider the following code:

#include <iostream>
#include <cstdlib>

using namespace std;

int main()
{
const double& ref = 100;
double& d = const_cast<doub le&>(ref);

Dangerous. You might attempt to modify what d refers to.

cout << d << endl;
d = 1.1;

Undefined behaviour. You are modifying a const object.

cout << ref << endl;

return EXIT_SUCCESS;
}

In both g++ and VC++ 2005 Express Edition, the output is
100
1.1

But my doubt is: "does using 'd' invoke undefined behavior or is it
valid."

double& d = const_cast<doub le&>(ref);

This isn't Undefined Behaviour. Attempting to modify what d refers to
is the Undefined Behaviour.

[Old Wolf]

On Dec 21, 5:04 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

subramanian10.. [e-mail] wrote:

{
const double& ref = 100;
double& d = const_cast<doub le&>(ref);

What you're doing here is changing the value of the temporary
bound to a const reference. Such temporary is not const, so,
changing its value by casting away const-ness should be OK.

The temporary is const. See 8.3.5#5 [dcl.init.ref], last clause.

So the behaviour is undefined when the attempt is made to
modify d (the cast itself is fine though).

[Old Wolf]

On Dec 22, 3:10 am, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

The temporary to which 'ref' is bound is not a const object. It
is perfectly OK to change its value.

Actually it is const, as per 8.3.5#5

the idea is the same as in

void foo(int const& rci)
{
int& ri = const_cast<int& >(rci);
ri = 666; /// Is this OK? -- I say, yes, it is!
}

#include <iostream>
#include <ostream>
int main() {
int a = 42;
std::cout << "Before a = " << a << std::endl;
foo(a);
std::cout << "After a = " << a << std::endl;
}

This code is OK; since a is an lvalue, a temporary
is not created.

[Victor Bazarov]

Andre Kostur wrote:

"su************ **@yahoo.com, India" <su************ **@yahoo.comwro te
in news:404f0505-3d9f-4173-8361-a0a328537882
@i29g2000prf.go oglegroups.com:

>Consider the following code:

#include <iostream>
#include <cstdlib>

using namespace std;

int main()
{
const double& ref = 100;
double& d = const_cast<doub le&>(ref);

Dangerous. You might attempt to modify what d refers to.

> cout << d << endl;
d = 1.1;

Undefined behaviour. You are modifying a const object.

> cout << ref << endl;

return EXIT_SUCCESS;
}

In both g++ and VC++ 2005 Express Edition, the output is
100
1.1

But my doubt is: "does using 'd' invoke undefined behavior or is it
valid."

double& d = const_cast<doub le&>(ref);

This isn't Undefined Behaviour. Attempting to modify what d refers to
is the Undefined Behaviour.

Could you please elaborate on why it is undefined behaviour?

Thanks.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Rahul]

>

The temporary to which 'ref' is bound is not a const object. It
is perfectly OK to change its value. Whether it makes sense to
do so or not is another question, but the idea is the same as in

I think, as the temp object is that of an in-built type, it is fine.
But had it been that of a custom type, the temp object would have been
an constant object...

[Victor Bazarov]

Rahul wrote:

>The temporary to which 'ref' is bound is not a const object. It
is perfectly OK to change its value. Whether it makes sense to
do so or not is another question, but the idea is the same as in

I think, as the temp object is that of an in-built type, it is fine.
But had it been that of a custom type, the temp object would have been
an constant object...

Any standard quote to support that claim?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask