Why I am able to modify const variable through classes and not in plain code. C++

Question

When I write this code fragment, after modifying the value of const variable i through pointer I am getting value of i as 10, but when i print *ptr i get 110.

const int i = 10;
int *ptr = const_cast<int *>(&i);
*ptr = *ptr + 100;
cout << "i:     " << i << "\t*ptr:      " << *ptr << endl;

I am getting output i: 10 and *ptr :110.

And in this case I am having a const variable x as a member variable of class Base. And through function show() I am able to modify the value of const variable x i.e when I print x and *ptr I get changed value in both.

class Base
{
public:
const int x;
Base(int i) : x(i) {}
virtual void show()
{
            int *ptr = const_cast<int *>(&x);        
            int *ptr = const_cast<int *>(&x);
            cout << "In Base show:\n";
            cout << "Address of x   :       " << &x << endl;
            cout << "Address in ptr :       " << ptr << endl;
            cout << "value in x     :       " << x << endl;
            cout << "value in ptr   :       " << *ptr << endl;
            *ptr = *ptr + 10;
            cout << "After modifying        " << endl;
            cout << "value in x     :       " << x << endl;
            cout << "value in ptr   :       " << *ptr << endl;
    }
};

class Derived : public Base
{
    public:
    Derived(int i) : Base(i){}
    virtual void show()
    {
            int *ptr = const_cast<int *>(&x);
            cout << "In Derived show:\n";
            cout << "Address of x   :       " << &x << endl;
            cout << "Address in ptr :       " << ptr << endl;
            cout << "value in x     :       " << x << endl;
            cout << "value in ptr   :       " << *ptr << endl;
            *ptr = *ptr + 10;
            cout << "After modifying        " << endl;
            cout << "value in x     :       " << x << endl;
            cout << "value in ptr   :       " << *ptr << endl;
    }
};
int main()
{
    Base bobj(5),*bp;
    Derived dobj(20), *dptr;
    bp = &bobj;
    bp->show();
    bp = &dobj;
    bp->show();
    return 0;
}


The output which I am getting is this 
In Base show:
Address of x    :   0x7fff82697588
Address in ptr  :   0x7fff82697588
value in x          :   5
value in ptr    :   5
After modifying 
value in x          :   15
value in ptr    :   15

In Derived show:
Address of x        :       0x7fff82697578
Address in ptr      :   0x7fff82697578
value in x          :       20
value in ptr        :       20
After modifying 
value in x          :       30
value in ptr        :       30

Can anybody help.

You are invoking undefined behaviour here. That means anything could happen. — juanchopanza, May 09 '13 at 08:21

Kerrek SB · Answer 1 · 2013-05-09T08:30:52.600

3

Your code simply has undefined behaviour: You must not modify a constant object, and your const_cast allows you to violate that (which is why it's basically never a good idea to use const_cast, with very few and very rare exceptions). So there's little purpose in asking about the whys and hows of the particular way your code breaks. But if you must know, constant integral expressions are often folded by value right into the places where they're referred to, which looks like what's happening in your case.

edited May 09 '13 at 08:30

answered May 09 '13 at 08:25

Kerrek SB

464,522
92
875
1,084

1

`const` objects are generally placed in write protected memory (the code segment) as well, so if the constant folding didn't occur, you will typically get a core dump. `const` member objects can't be placed in write protected memory, because they're part of a larger object, and because the const only takes effect once the constructor initializer list has finished executing. – James Kanze May 09 '13 at 08:53
So should I consider using const_cast is not useful. – Daemon May 09 '13 at 10:19
@Gaurav: Indeed. `const_cast` is only useful in very specific, specialized sitiations (like a C-style `strchr` implementation, for example). – Kerrek SB May 09 '13 at 11:14

score 1 · Accepted Answer · answered May 09 '13 at 09:08

The reason is that your compiler has inlined the value of i into the code when compiling this line:

cout << "i: " << i << "\t*ptr: " << *ptr << endl;

Because i is a const variable, the compiler has optimised the code by replacing i in the above line with 10. If we look at the generated assembly (I'm using VS2010):

002314F2  mov         ecx,dword ptr [ptr]  // ptr is being pushed here (110)
002314F5  mov         edx,dword ptr [ecx]  
002314F7  push        edx  
002314F8  push        offset string "\t*ptr:      " (23783Ch)     
002314FD  mov         ebx,esp  
002314FF  push        0Ah  //  0Ah is being pushed here (A is hex for 10)
00231501  push        offset string "i:     " (237830h)

What has happened is that you have modified the constant in memory, but the generated assembly doesn't actually use the memory address - it simply outputs '10' regardless of what's in memory.

As said by Kerrek, this is undefined behavior, so other compilers may do something completely different to this.

In general it is a bad idea to use const_cast with few exceptions.

So using const_cast or modifying the const variable's value is of no use as the result is undefined. Does mutable also gives undefined behaviour. — Daemon, May 09 '13 at 10:43
@Gaurav - `const` says "I'm not going to change this". If you do change it, you've lied to the compiler, and anything can happen. `mutable` (which only applies to member data) says "even if the object that holds this data is const, this data can be modified". Nothing undefined there. — Pete Becker, May 09 '13 at 10:59
@Gaurav: It's not that "the result is undefined". Your *entire program* is broken if it has undefined behaviour. — Kerrek SB, May 09 '13 at 11:15

Why I am able to modify const variable through classes and not in plain code. C++

2 Answers2