const值运行时评估

Question

The output of the following code:

const int i= 1;
(int&)i= 2;          // or:  const_cast< int&>(i)= 2;
cout << i << endl;

is 1 (at least under VS2012)

My question:

• Is this behavior defined?
• Would the compiler always use the defined value for constants?
• Is it possible to construct an example where the compiler would use the value of the latest assignment?

Answer 1

It is totally undefined. You just cannot change the value of constants.

It so happens that the compiler transforms your code into something like

cout << 1 << endl;

but the program could just as well crash, or do something else.

If you set the warnings level high enough, the compiler will surely tell you that it is not going to work.

Answer 2

Is this behavior defined?

The behavior of this code is not defined by the C++ standard, because it attempts to modify a const object.

Would the compiler always use the defined value for constants?

What value the compiler uses in cases like this depends on the implementation. The C++ standard does not impose a requirement.

Is it possible to construct an example where the compiler would use the value of the latest assignment?

There might be cases where the compiler does modify the value and use it, but they would not be reliable.

Answer 3

The answer is that the behavior is undefined.

I managed to set up this conclusive example:

#include <iostream>

using namespace std;

int main(){

        const int i = 1;

        int *p=const_cast<int *>(&i);
        *p = 2;
        cout << i << endl;

        cout << *p << endl;

        cout << &i << endl;

        cout << p << endl;

        return 0;
}

which, under gcc 4.7.2 gives:

1
2
0x7fffa9b7ddf4
0x7fffa9b7ddf4

So, it is like you have the same memory address as it is holding two different values.

The most probable explanation is that the compiler simply replaces constant values with their literal values.

Answer 4

As said by others, the behaviour is undefined.

For the sake of completeness, here is the quote from the Standard:

(§7.1.6.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. [ Example:

[...]

 const int* ciq = new const int (3); // initialized as required int* iq = const_cast<int*>(ciq); // cast required *iq = 4; // undefined: modifies a const object 

]

Note that the word object is this paragraph refers to all kinds of objects, including simple integers, as shown in the example – not only class objects.

Although the example refers to a pointer to an object with dynamic storage, the text of the paragraph makes it clear that this applies to references to objects with automatic storage as well.

Answer 5

You are doing a const_cast using the C-like cast operator .

Using const_cast is not guaranteeing any behaviour.

if ever you do it, it might work or it might not work.

(It's not good practice to use C-like operators in C++ you know)

Answer 6

Yes you can, but only if you initiate a const as a read-only but not compile-time const, as follows:

int y=1;
const int i= y;
(int&)i= 2;
cout << i << endl; // prints 2

C++ const keyword can be missleading, it's either a const or a read-only.